41 KiB

Raw Blame History

WHATWG HTML5 specification-compliant, fast and ready for production HTML parsing/serialization toolset for Node.

parse5 contains nearly everything what you will need to deal with the HTML. It's the fastest spec-compliant HTML parser for Node to the date and will parse HTML the way the latest version of your browser does. It's stable and used by such projects as [jsdom](https://github.com/tmpvar/jsdom), [Angular2](https://github.com/angular/angular), [Polymer](https://www.polymer-project.org/1.0/) and many more.

Install
Usage
API Reference
FAQ
Version history
License

Install

$ npm install parse5

Usage

var parse5 = require('parse5');

var document     = parse5.parse('<!DOCTYPE html><html><body>Hi there!</body></html>');
var documentHtml = parse5.serialize(document);


var fragment     = parse5.parseFragment('<td>Yo!</td>');
var fragmentHtml = parse5.serialize(fragment);

For more advanced examples see API reference and FAQ.

API Reference

Objects

parse5 : object

## Typedefs

ElementLocationInfo : Object
LocationInfo : Object
ParserOptions : Object
SAXParserOptions : Object
SerializerOptions : Object
TreeAdapter : Object

## parse5 : object **Kind**: global namespace

parse5 : object
- .ParserStream ⇐ stream.Writable
  - new ParserStream(options)
  - .document : ASTNode.<document>
  - "script" (scriptElement, documentWrite(html), resume)
- .SAXParser ⇐ stream.Transform
- .SerializerStream ⇐ stream.Readable
  - new SerializerStream(node, [options])
- .treeAdapters
- .parse(html, [options]) ⇒ ASTNode.<Document>
- .parseFragment([fragmentContext], html, [options]) ⇒ ASTNode.<DocumentFragment>
- .serialize(node, [options]) ⇒ String

parse5.ParserStream ⇐ `stream.Writable`

Kind: instance class of parse5 Extends: stream.Writable

.ParserStream ⇐ stream.Writable
- new ParserStream(options)
- .document : ASTNode.<document>
- "script" (scriptElement, documentWrite(html), resume)

new ParserStream(options)

Streaming HTML parser with the scripting support. Writable stream.

Param	Type	Description
options	`ParserOptions`	Parsing options.

Example

var parse5 = require('parse5');
var http = require('http');

// Fetch google.com content and obtain it's <body> node
http.get('http://google.com', function(res) {
 var parser = new parse5.ParserStream();

 parser.on('finish', function() {
     var body = parser.document.childNodes[0].childNodes[1];
 });

 res.pipe(parser);
});

parserStream.document : `ASTNode.<document>`

Resulting document node.

Kind: instance property of ParserStream

"script" (scriptElement, documentWrite(html), resume)

Raised then parser encounters <script> element. If event has listeners then parsing will be suspended on event emission. So, if <script> has src attribute you can fetch it, execute and then resume parser like browsers do.

Kind: event emitted by ParserStream

Param	Type	Description
scriptElement	`ASTNode`	Script element that caused the event.
documentWrite(html)	`function`	Write additional `html` at the current parsing position. Suitable for the DOM `document.write` and `document.writeln` methods implementation.
resume	`function`	Resumes the parser.

Example

var parse = require('parse5');
var http = require('http');

var parser = new parse5.ParserStream();

parser.on('script', function(scriptElement, documentWrite, resume) {
  var src = parse5.treeAdapters.default.getAttrList(scriptElement)[0].value;

  http.get(src, function(res) {
     // Fetch script content, execute it with DOM built around `parser.document` and
     // `document.write` implemented using `documentWrite`
     ...
     // Then resume the parser
     resume();
  });
});

parser.end('<script src="example.com/script.js"></script>');

parse5.SAXParser ⇐ `stream.Transform`

Kind: instance class of parse5 Extends: stream.Transform

.SAXParser ⇐ stream.Transform

new SAXParser(options)

Streaming SAX-style HTML parser. Transform stream (which means you can pipe through it, see example).

Param	Type	Description
options	`SAXParserOptions`	Parsing options.

Example

var parse5 = require('parse5');
var http = require('http');
var fs = require('fs');

var file = fs.createWriteStream('/home/google.com.html');
var parser = new SAXParser();

parser.on('text', function(text) {
 // Handle page text content
 ...
});

http.get('http://google.com', function(res) {
 // SAXParser is the Transform stream, which means you can pipe
 // through it. So you can analyze page content and e.g. save it
 // to the file at the same time:
 res.pipe(parser).pipe(file);
});

saxParser.stop()

Stops parsing. Useful if you want parser to stop consume CPU time once you've obtained desired info from input stream. Doesn't prevents piping, so data will flow through parser as usual.

Kind: instance method of SAXParser Example

var parse5 = require('parse5');
var http = require('http');
var fs = require('fs');

var file = fs.createWriteStream('/home/google.com.html');
var parser = new parse5.SAXParser();

parser.on('doctype', function(name, publicId, systemId) {
 // Process doctype info ans stop parsing
 ...
 parser.stop();
});

http.get('http://google.com', function(res) {
 // Despite the fact that parser.stop() was called whole
 // content of the page will be written to the file
 res.pipe(parser).pipe(file);
});