(function($) {
	$.extend({pwTyper: {

		wrap: function(s) {

			// remove legacy span.pwtext elements			
			s = s.replace(/(<span[^>]*?class="[^"]*pwText[^"]*>)([^<]*)(<\/span>)/g, '$2');

			// wraps all text nodes in a span.pwtext element 
			s = s.replace(/(>|^(?!<))([^<]+)(<|(?!>)$)/g, '$1<span class="pwText">$2</span>$3');

			// groups special characters such as &amp; into a span.pwSpecial element
			// only match special characters within existing .pwText elements (not in attributes)
			s = s.replace(/<span class="pwText">[^<]*&\S*;[^<]*<\/span>/g, function(m) { return m.replace(/(&[^;]+;)/g, '</span><span class="pwSpecial">$1</span><span class="pwText">'); });

			// remove empty pwText tags and wrap in a span.pwText if needed
			// s = s.replace(/<span class="pwText">[\n\r]+?<\/span>/g, "");
			
			return s;
		},
		
		// adds the next letter 
		type: function(G) {
//		alert("?");
			// increase dataIndex, which moves to the next element
			if (G.charCount > G.data[G.dataIndex].count) {
				G.dataIndex++;
			}
			
			// If typing is complete, restore the original state
			if (G.dataIndex == G.dataLength) {
				G.thisElement.data("finished", true);
				G.thisElement.html(G.content);
				
				
				// if typing is complete for ALL elements
				if (G.thisElement.data("callback")) {
					var finished = true;
					$(G.thisElement.data("get")).each(function() {
						if (!$(this).data("finished")) { finished = false; }														 
					});
					if (finished) {
						var callback = G.thisElement.data("callback");
						if (callback) {
							callback.call();
						}
					}
				}
				return false;
			}
	
			// show the current element and all previous elements which are still hidden
			var newOrder = G.data[G.dataIndex].element.data("order");
			for (G.order; G.order <= newOrder; G.order++) {
				G.thisElement.find('.order-'+G.order).removeClass('pwHidden');
			}
			
			// type the next character
			G.data[G.dataIndex].element.html(G.data[G.dataIndex].text.substr(0, G.charCount - ((G.dataIndex > 0) ? G.data[G.dataIndex-1].count : 0)));
			G.delay = Math.round(G.minInterval + (Math.random() * (G.maxInterval - G.minInterval)));
			G.thisElement.data("int", setTimeout(function() { $.pwTyper.type(G) }, G.delay));			
			
			G.charCount++;	
			
			// Stores the G data in the element to use in pause and stop functions
			G.thisElement.data("G", G);
		},
		
		// removes the last letter 
		untype: function(G) {
						
			// increase dataIndex, which moves to the next element
			if (G.dataIndex > 0 && G.charCount <= G.data[G.dataIndex - 1].count) {
				G.dataIndex--;
			}
			
			// If untyping is complete
			if (G.charCount === 0) {
				G.thisElement.data("finished", true);
				G.thisElement.html("");
				
				// if untyping is complete for ALL elements
				if (G.thisElement.data("callback") && $(G.thisElement.data("get")).data('finished')) {
					var finished = true;
					$(G.thisElement.data("get")).each(function() {
						if (!$(this).data("finished")) { finished = false; }														 
					});
					if (finished) {
						var callback = G.thisElement.data("callback");
						if (callback) {
							callback.call();
						}
					}
				}
				return false;
			}
	
			// show the current element and all previous elements which are still hidden
			var newOrder = G.data[G.dataIndex].element.data("order");
			for (G.order; G.order > newOrder; G.order--) {
				G.thisElement.find('.order-'+G.order).remove();		
			}
			
			// type the next character
			G.data[G.dataIndex].element.html(G.data[G.dataIndex].text.substr(0, G.charCount - 1 - ((G.dataIndex > 0) ? G.data[G.dataIndex-1].count : 0)));
			G.delay = Math.round(G.minInterval + (Math.random() * (G.maxInterval - G.minInterval)));
			G.thisElement.data("int", setTimeout(function() { $.pwTyper.untype(G) }, G.delay));			
			
			G.charCount--;
			
			// Stores the G data in the element to use in pause and stop functions
			G.thisElement.data("G", G);
		},
		
		createCSS: function (selector, declaration) {
			
			// test for IE
			var ua = navigator.userAgent.toLowerCase();
			var isIE = (/msie/.test(ua)) && !(/opera/.test(ua)) && (/win/.test(ua));
		
			// create the style node for all browsers, if it doesn't already exists	
			var style_node = document.getElementById('pwTyperStyles');
			if ( !style_node ) {
				style_node = document.createElement("style");
				style_node.setAttribute("type", "text/css");
				style_node.setAttribute("media", "screen");
				style_node.setAttribute("id", "pwTyperStyles");
			}
			
			// if the rule doesn't already exist, add it
			if ( style_node.innerHTML.indexOf(selector + " {" + declaration + "}") === -1 ) {
				
				// append a rule for good browsers
				if (!isIE) style_node.appendChild(document.createTextNode(selector + " {" + declaration + "}\n"));

				// append the style node
				document.getElementsByTagName("head")[0].appendChild(style_node);

				// use alternative methods for IE
				if (isIE && document.styleSheets && document.styleSheets.length > 0) {
					var last_style_node = document.styleSheets[document.styleSheets.length - 1];
					if (typeof(last_style_node.addRule) == "object") last_style_node.addRule(selector, declaration);
				}
			}
		}	
	}});
	
	
	$.fn.extend({
	
		stopTyper: function() {
			clearInterval(this.data("int"));
			return this;
		},
		
		resumeTyper: function() {
			this.data('func').call($.pwTyper, this.data("G"));
			return this;
		},
		
		finishTyper: function() {
			clearInterval(this.data("int"));
			if (this.data('func') == $.pwTyper.type) {
				this.html(this.data("content"));
			} else {
				this.empty();
			}
			
			var callback = this.data("callback");
			if (callback) {
				callback.call();
			}

			return this;
		},
					
		type: function(options) {
			
			// add CSS styles if they haven't already been added
			$.pwTyper.createCSS('.pwHidden', 'display:none;');

			clearInterval(this.data("int"));
			
			// Default settings
			var settings = {
				minInterval: 30,
				maxInterval: 90
			};
			
			// Processing settings
			settings = jQuery.extend(settings, options || {});
			
			this.data("func", $.pwTyper.type);
			this.data("get", this.get());
			this.data("callback", (settings.callback) ? settings.callback : null);
			
			
			return this.each(function() {
				
				var G = {
					charCount: 0,
					charTotal: 0,
					data: [],
					dataLength: 0,
					dataIndex: 0,
					thisElement: $(this),
					order: 0, 
					delay: 0,
					newText: "",
					content: "",
					minInterval: settings.minInterval,
					maxInterval: settings.maxInterval
				};
			
				if (!settings.content) {
					G.content = G.thisElement.html();	
				} else if (settings.content instanceof jQuery) {
					G.content = $(settings.content).html();
				} else {
					G.content = settings.content;	
				}
				G.thisElement.data("finished", false);
				G.thisElement.data("content", G.content);
			
				// wraps all text nodes in a pwText span element 
				G.newText = $.pwTyper.wrap(G.content);
			
				// Creates an order for all elements to progressively show them as the typing happens
				G.thisElement.html(G.newText).find('*').each(function(i) {
					$(this).addClass("pwHidden").data("order", i).addClass("order-" + i);									
				});

				// empties the text from the span elements and stores it in the 'data' variable
				G.thisElement.find('.pwText').each(function(i) {
					G.data[i] = {
						order:$(this).data("order"),
						text: $(this).html(),
						element: $(this),
						count: (i > 0) ? $(this).html().length + G.data[i-1].count : $(this).html().length
					};
					$(this).empty();
				});
				
				G.dataLength = G.data.length;
				G.charTotal = G.data[G.dataLength-1].count;

				// if a time is specified, calculate the delay
				if (settings.time) {
					G.delay = Math.floor(settings.time / G.charTotal);
					if (G.delay === 0) { G.delay = 1; }
					if (settings.deviation) {
						if (settings.deviation > 1) { settings.deviation = 1; }
						G.minInterval = Math.round(G.delay * (1 - settings.deviation));
						G.maxInterval = G.delay + (G.delay - G.minInterval);
						if (G.minInterval === 0) { G.minInterval = 1; }
					} else {
						G.minInterval = G.delay;
						G.maxInterval = G.delay;
					}
				}

				if (settings.delay) {
					G.thisElement.data("int", setTimeout( function() { $.pwTyper.type(G) }, settings.delay));
				} else {
					$.pwTyper.type(G);	
				}
			});			
		},
	
		untype: function(options) {
			
			// add CSS styles if they haven't already been added
			$.pwTyper.createCSS('.pwHidden', 'display:none;');
			
			clearInterval(this.data("int"));
			
			// Default settings
			var settings = {
				minInterval: 30,
				maxInterval: 90
			};
			
			// Processing settings
			settings = jQuery.extend(settings, options || {});
			
			this.data("func", $.pwTyper.untype);
			this.data("get", this.get());
			this.data("callback", (settings.callback) ? settings.callback : null);
		
			
			return this.each(function() {
			
				var G = {
					charCount: 0,
					charTotal: 0,
					data: [],
					dataLength: 0,
					dataIndex: 0,
					thisElement: $(this),
					order: 0,
					delay: 0,
					newText:"",
					content: $(this).html(),
					minInterval: settings.minInterval, 
					maxInterval: settings.maxInterval
				};
				G.thisElement.data("finished", false);
				
				// wraps all text nodes in a pwText span element 
				G.newText = $.pwTyper.wrap(G.content);
					
				// Creates an order for all elements to progressively show them as the typing happens
				G.thisElement.html(G.newText).find('*').each(function(i) {
					$(this).data("order", i).addClass("order-" + i);									
				});
				
				// takes the text from the span elements and stores it in the 'data' variable
				G.thisElement.find('.pwText').each(function(i) {
					G.data[i] = {order:$(this).data("order"), text:$(this).html(), element:$(this), count: (i > 0) ? $(this).html().length + G.data[i-1].count : $(this).html().length};
				});
				
				if (G.data.length > 0) {
					G.dataIndex = G.data.length - 1;
					G.charTotal = G.data[G.dataIndex].count;
					G.charCount = G.charTotal;
					G.order = G.data[G.dataIndex].element.data("order");
					
					// if a time is specified, calculate the delay
					if (settings.time) {
						G.delay = Math.floor(settings.time / G.charTotal);
						if (G.delay === 0) { G.delay = 1; }
						if (settings.deviation) {
							if (settings.deviation > 1) { settings.deviation = 1; }
							G.minInterval = Math.round(G.delay * (1 - settings.deviation));
							G.maxInterval = G.delay + (G.delay - G.minInterval);
							if (G.minInterval === 0) { G.minInterval = 1; }
						} else {
							G.minInterval = G.delay;
							G.maxInterval = G.delay;
						}
					}
				}
				
				if (settings.delay) {
					G.thisElement.data("int", setTimeout(function() { $.pwTyper.untype(G) }, settings.delay));
				} else {
					$.pwTyper.untype(G);	
				}
			});
			
		}
	});
		
})(jQuery);