☰

htmlparser

HTML Parser By John Resig

Este script no debería instalarse directamente. Es una biblioteca que utilizan otros scripts mediante la meta-directiva de inclusión // @require https://update.greatest.deepsurf.us/scripts/4535/15389/htmlparser.js 

  1. /*
  2.  * HTML Parser By John Resig (ejohn.org)
  3.  * Original code by Erik Arvidsson, Mozilla Public License
  4.  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  5.  *
  6.  * // Use like so:
  7.  * HTMLParser(htmlString, {
  8.  *     start: function(tag, attrs, unary) {},
  9.  *     end: function(tag) {},
  10.  *     chars: function(text) {},
  11.  *     comment: function(text) {}
  12.  * });
  13.  *
  14.  * // or to get an XML string:
  15.  * HTMLtoXML(htmlString);
  16.  *
  17.  * // or to get an XML DOM Document
  18.  * HTMLtoDOM(htmlString);
  19.  *
  20.  * // or to inject into an existing document/DOM node
  21.  * HTMLtoDOM(htmlString, document);
  22.  * HTMLtoDOM(htmlString, document.body);
  23.  *
  24.  */
  25.  
  26. (function(){
  27.  
  28. 	// Regular Expressions for parsing tags and attributes
  29. 	var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[-:A-Za-z0-9_]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
  30. 		endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/,
  31. 		attr = /([-:A-Za-z0-9_]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
  32. 		
  33. 	// Empty Elements - HTML 4.01
  34. 	var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed");
  35.  
  36. 	// Block Elements - HTML 4.01
  37. 	var block = makeMap("address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,isindex,li,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
  38.  
  39. 	// Inline Elements - HTML 4.01
  40. 	var inline = makeMap("a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
  41.  
  42. 	// Elements that you can, intentionally, leave open
  43. 	// (and which close themselves)
  44. 	var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
  45.  
  46. 	// Attributes that have their values filled in disabled="disabled"
  47. 	var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
  48.  
  49. 	// Special Elements (can contain anything)
  50. 	var special = makeMap("script,style");
  51.  
  52. 	var HTMLParser = this.HTMLParser = function( html, handler ) {
  53. 		var index, chars, match, stack = [], last = html;
  54. 		stack.last = function(){
  55. 			return this[ this.length - 1 ];
  56. 		};
  57.  
  58. 		while ( html ) {
  59. 			chars = true;
  60.  
  61. 			// Make sure we're not in a script or style element
  62. 			if ( !stack.last() || !special[ stack.last() ] ) {
  63.  
  64. 				// Comment
  65. 				if ( html.indexOf("<!--") == 0 ) {
  66. 					index = html.indexOf("-->");
  67. 	
  68. 					if ( index >= 0 ) {
  69. 						if ( handler.comment )
  70. 							handler.comment( html.substring( 4, index ) );
  71. 						html = html.substring( index + 3 );
  72. 						chars = false;
  73. 					}
  74. 	
  75. 				// end tag
  76. 				} else if ( html.indexOf("</") == 0 ) {
  77. 					match = html.match( endTag );
  78. 	
  79. 					if ( match ) {
  80. 						html = html.substring( match[0].length );
  81. 						match[0].replace( endTag, parseEndTag );
  82. 						chars = false;
  83. 					}
  84. 	
  85. 				// start tag
  86. 				} else if ( html.indexOf("<") == 0 ) {
  87. 					match = html.match( startTag );
  88. 	
  89. 					if ( match ) {
  90. 						html = html.substring( match[0].length );
  91. 						match[0].replace( startTag, parseStartTag );
  92. 						chars = false;
  93. 					}
  94. 				}
  95.  
  96. 				if ( chars ) {
  97. 					index = html.indexOf("<");
  98. 					
  99. 					var text = index < 0 ? html : html.substring( 0, index );
  100. 					html = index < 0 ? "" : html.substring( index );
  101. 					
  102. 					if ( handler.chars )
  103. 						handler.chars( text );
  104. 				}
  105.  
  106. 			} else {
  107. 				html = html.replace(new RegExp("(.*)<\/" + stack.last() + "[^>]*>"), function(all, text){
  108. 					text = text.replace(/<!--(.*?)-->/g, "$1")
  109. 						.replace(/<!\[CDATA\[(.*?)]]>/g, "$1");
  110.  
  111. 					if ( handler.chars )
  112. 						handler.chars( text );
  113.  
  114. 					return "";
  115. 				});
  116.  
  117. 				parseEndTag( "", stack.last() );
  118. 			}
  119.  
  120. 			if ( html == last )
  121. 				throw "Parse Error: " + html;
  122. 			last = html;
  123. 		}
  124. 		
  125. 		// Clean up any remaining tags
  126. 		parseEndTag();
  127.  
  128. 		function parseStartTag( tag, tagName, rest, unary ) {
  129. 			tagName = tagName.toLowerCase();
  130.  
  131. 			if ( block[ tagName ] ) {
  132. 				while ( stack.last() && inline[ stack.last() ] ) {
  133. 					parseEndTag( "", stack.last() );
  134. 				}
  135. 			}
  136.  
  137. 			if ( closeSelf[ tagName ] && stack.last() == tagName ) {
  138. 				parseEndTag( "", tagName );
  139. 			}
  140.  
  141. 			unary = empty[ tagName ] || !!unary;
  142.  
  143. 			if ( !unary )
  144. 				stack.push( tagName );
  145. 			
  146. 			if ( handler.start ) {
  147. 				var attrs = [];
  148. 	
  149. 				rest.replace(attr, function(match, name) {
  150. 					var value = arguments[2] ? arguments[2] :
  151. 						arguments[3] ? arguments[3] :
  152. 						arguments[4] ? arguments[4] :
  153. 						fillAttrs[name] ? name : "";
  154. 					
  155. 					attrs.push({
  156. 						name: name,
  157. 						value: value,
  158. 						escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
  159. 					});
  160. 				});
  161. 	
  162. 				if ( handler.start )
  163. 					handler.start( tagName, attrs, unary );
  164. 			}
  165. 		}
  166.  
  167. 		function parseEndTag( tag, tagName ) {
  168. 			// If no tag name is provided, clean shop
  169. 			if ( !tagName )
  170. 				var pos = 0;
  171. 				
  172. 			// Find the closest opened tag of the same type
  173. 			else
  174.       {
  175.         tagName = tagName.toLowerCase();
  176. 				for ( var pos = stack.length - 1; pos >= 0; pos-- )
  177. 					if ( stack[ pos ] == tagName )
  178. 						break;
  179. 			}
  180.       
  181. 			if ( pos >= 0 ) {
  182. 				// Close all the open elements, up the stack
  183. 				for ( var i = stack.length - 1; i >= pos; i-- )
  184. 					if ( handler.end )
  185. 						handler.end( stack[ i ] );
  186. 				
  187. 				// Remove the open elements from the stack
  188. 				stack.length = pos;
  189. 			}
  190. 		}
  191. 	};
  192. 	
  193. 	this.HTMLtoXML = function( html ) {
  194. 		var results = "";
  195. 		
  196. 		HTMLParser(html, {
  197. 			start: function( tag, attrs, unary ) {
  198. 				results += "<" + tag;
  199. 		
  200. 				for ( var i = 0; i < attrs.length; i++ )
  201. 					results += " " + attrs[i].name + '="' + attrs[i].escaped + '"';
  202. 		
  203. 				results += (unary ? "/" : "") + ">";
  204. 			},
  205. 			end: function( tag ) {
  206. 				results += "</" + tag + ">";
  207. 			},
  208. 			chars: function( text ) {
  209. 				results += text;
  210. 			},
  211. 			comment: function( text ) {
  212. 				results += "<!--" + text + "-->";
  213. 			}
  214. 		});
  215. 		
  216. 		return results;
  217. 	};
  218. 	
  219. 	this.HTMLtoDOM = function( html, doc ) {
  220. 		// There can be only one of these elements
  221. 		var one = makeMap("html,head,body,title");
  222. 		
  223. 		// Enforce a structure for the document
  224. 		var structure = {
  225. 			link: "head",
  226. 			base: "head"
  227. 		};
  228. 	
  229. 		if ( !doc ) {
  230. 			if ( typeof DOMDocument != "undefined" )
  231. 				doc = new DOMDocument();
  232. 			else if ( typeof document != "undefined" && document.implementation && document.implementation.createDocument )
  233. 				doc = document.implementation.createDocument("", "", null);
  234. 			else if ( typeof ActiveX != "undefined" )
  235. 				doc = new ActiveXObject("Msxml.DOMDocument");
  236. 			
  237. 		} else
  238. 			doc = doc.ownerDocument ||
  239. 				doc.getOwnerDocument && doc.getOwnerDocument() ||
  240. 				doc;
  241. 		
  242. 		var elems = [],
  243. 			documentElement = doc.documentElement ||
  244. 				doc.getDocumentElement && doc.getDocumentElement();
  245. 				
  246. 		// If we're dealing with an empty document then we
  247. 		// need to pre-populate it with the HTML document structure
  248. 		if ( !documentElement && doc.createElement ) (function(){
  249. 			var html = doc.createElement("html");
  250. 			var head = doc.createElement("head");
  251. 			head.appendChild( doc.createElement("title") );
  252. 			html.appendChild( head );
  253. 			html.appendChild( doc.createElement("body") );
  254. 			doc.appendChild( html );
  255. 		})();
  256. 		
  257. 		// Find all the unique elements
  258. 		if ( doc.getElementsByTagName )
  259. 			for ( var i in one )
  260. 				one[ i ] = doc.getElementsByTagName( i )[0];
  261. 		
  262. 		// If we're working with a document, inject contents into
  263. 		// the body element
  264. 		var curParentNode = one.body;
  265. 		
  266. 		HTMLParser( html, {
  267. 			start: function( tagName, attrs, unary ) {
  268. 				// If it's a pre-built element, then we can ignore
  269. 				// its construction
  270. 				if ( one[ tagName ] ) {
  271. 					curParentNode = one[ tagName ];
  272. 					if ( !unary ) {
  273. 						elems.push( curParentNode );
  274. 					}
  275. 					return;
  276. 				}
  277. 			
  278. 				var elem = doc.createElement( tagName );
  279. 				
  280. 				for ( var attr in attrs )
  281. 					elem.setAttribute( attrs[ attr ].name, attrs[ attr ].value );
  282. 				
  283. 				if ( structure[ tagName ] && typeof one[ structure[ tagName ] ] != "boolean" )
  284. 					one[ structure[ tagName ] ].appendChild( elem );
  285. 				
  286. 				else if ( curParentNode && curParentNode.appendChild )
  287. 					curParentNode.appendChild( elem );
  288. 					
  289. 				if ( !unary ) {
  290. 					elems.push( elem );
  291. 					curParentNode = elem;
  292. 				}
  293. 			},
  294. 			end: function( tag ) {
  295. 				elems.length -= 1;
  296. 				
  297. 				// Init the new parentNode
  298. 				curParentNode = elems[ elems.length - 1 ];
  299. 			},
  300. 			chars: function( text ) {
  301. 				curParentNode.appendChild( doc.createTextNode( text ) );
  302. 			},
  303. 			comment: function( text ) {
  304. 				// create comment node
  305. 			}
  306. 		});
  307. 		
  308. 		return doc;
  309. 	};
  310.  
  311. 	function makeMap(str){
  312. 		var obj = {}, items = str.split(",");
  313. 		for ( var i = 0; i < items.length; i++ )
  314. 			obj[ items[i] ] = true;
  315. 		return obj;
  316. 	}
  317. })();