fb55/htmlparser2 sits at 4.8k stars on GitHub, written primarily in TypeScript. The fast & forgiving HTML and XML parser
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
htmlparser2 is the fastest HTML parser, and takes some shortcuts to get there. If you need strict HTML spec compliance, have a look at parse5.
Installation
npm install htmlparser2
A live demo of htmlparser2 is available on AST Explorer.
Ecosystem
Name
Description
htmlparser2
Fast & forgiving HTML/XML parser
domhandler
Handler for htmlparser2 that turns documents into a DOM
domutils
Utilities for working with domhandler's DOM
css-select
CSS selector engine, compatible with domhandler's DOM
cheerio
The jQuery API for domhandler's DOM
dom-serializer
Serializer for domhandler's DOM
Usage
htmlparser2 itself provides a callback interface that allows consumption of documents with minimal allocations.
For a more ergonomic experience, read Getting a DOM below.
import * as htmlparser2 from "htmlparser2";
const parser = new htmlparser2.Parser({
onopentag(name, attributes) {
/*
* This fires when a new tag is opened.
*
* If you don't need an aggregated `attributes` object,
* have a look at the `onopentagname` and `onattribute` events.
*/
if (name === "script" && attributes.type === "text/javascript") {
console.log("JS! Hooray!");
}
},
ontext(text) {
/*
* Fires whenever a section of text was processed.
*
* Note that this can fire at any point within text and you might
* have to stitch together multiple pieces.
*/
console.log("-->", text);
},
onclosetag(tagname) {
/*
* Fires when a tag is closed.
*
* You can rely on this event only firing when you have received an
* equivalent opening tag before. Closing tags without corresponding
* opening tags will be ignored.
*/
if (tagname === "script") {
console.log("That's it?!");
}
},
});
parser.write(
"Xyz <script type='text/javascript'>const foo = '<<bar>>';</script>",
);
parser.end();
All callbacks are optional. The handler object you pass to Parser may implement any subset of these:
Event
Description
onopentag(name, attribs, isImplied)
Opening tag. attribs is an object mapping attribute names to values. isImplied is true when the tag was opened implicitly (HTML mode only).
onopentagname(name)
Emitted for the tag name as soon as it is available (before attributes are parsed).
onattribute(name, value, quote)
Attribute. quote is " / ' / null (unquoted) / undefined (no value, e.g. disabled).
onclosetag(name, isImplied)
Closing tag. isImplied is true when the tag was closed implicitly (HTML mode only).
ontext(data)
Text content. May fire multiple times for a single text node.
oncomment(data)
Comment (content between <!-- and -->).
oncdatastart()
Opening of a CDATA section (<![CDATA[).
oncdataend()
End of a CDATA section (]]>).
onprocessinginstruction(name, data)
Processing instruction (e.g. <?xml ...?>).
oncommentend()
Fires after a comment has ended.
onparserinit(parser)
Fires when the parser is initialized or reset.
onreset()
Fires when parser.reset() is called.
onend()
Fires when parsing is complete.
onerror(error)
Fires on error.
Parser options
Option
Type
Default
Description
xmlMode
boolean
false
Treat the document as XML. This affects entity decoding, self-closing tags, CDATA handling, and more. Set this to true for XML, RSS, Atom and RDF feeds.
decodeEntities
boolean
true
Decode HTML entities (e.g. & -> &).
lowerCaseTags
boolean
!xmlMode
Lowercase tag names.
lowerCaseAttributeNames
boolean
!xmlMode
Lowercase attribute names.
recognizeSelfClosing
boolean
xmlMode
Recognize self-closing tags (e.g. <br/>). Always enabled in xmlMode.
recognizeCDATA
boolean
xmlMode
Recognize CDATA sections as text. Always enabled in xmlMode.
Usage with streams
While the Parser interface closely resembles Node.js streams, it's not a 100% match.
Use the WritableStream interface to process a streaming input:
The parseDocument helper parses a string and returns a DOM tree (a Document node).
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(
`<ul id="fruits">
<li class="apple">Apple</li>
<li class="orange">Orange</li>
</ul>`,
);
parseDocument accepts an optional second argument with both parser and DOM handler options:
const dom = htmlparser2.parseDocument(data, {
// Parser options
xmlMode: true,
// domhandler options
withStartIndices: true, // Add `startIndex` to each node
withEndIndices: true, // Add `endIndex` to each node
});
Searching the DOM
The DomUtils module (re-exported on the main htmlparser2 export) provides helpers for finding nodes:
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(`<div><p id="greeting">Hello</p></div>`);
// Find elements by ID, tag name, or class
const greeting = htmlparser2.DomUtils.getElementById("greeting", dom);
const paragraphs = htmlparser2.DomUtils.getElementsByTagName("p", dom);
// Find elements with custom test functions
const all = htmlparser2.DomUtils.findAll(
(el) => el.attribs?.class === "active",
dom,
);
// Get text content
htmlparser2.DomUtils.textContent(greeting); // "Hello"
For CSS selector queries, use css-select:
import { selectAll, selectOne } from "css-select";
const results = selectAll("ul#fruits > li", dom);
const first = selectOne("li.apple", dom);
Or, if you'd prefer a jQuery-like API, use cheerio.
Modifying and serializing the DOM
Use DomUtils to modify the tree, and dom-serializer (also available as DomUtils.getOuterHTML) to serialize it back to HTML:
import * as htmlparser2 from "htmlparser2";
const dom = htmlparser2.parseDocument(
`<ul><li>Apple</li><li>Orange</li></ul>`,
);
// Remove the first <li>
const items = htmlparser2.DomUtils.getElementsByTagName("li", dom);
htmlparser2.DomUtils.removeElement(items[0]);
// Serialize back to HTML
const html = htmlparser2.DomUtils.getOuterHTML(dom);
// "<ul><li>Orange</li></ul>"
Other manipulation helpers include appendChild, prependChild, append, prepend, and replaceElement -- see the domutils docs for the full API.
Parsing feeds
htmlparser2 makes it easy to parse RSS, RDF and Atom feeds, by providing a parseFeed method:
const feed = htmlparser2.parseFeed(content);
This returns an object with type, title, link, description, updated, author, and items (an array of feed entries), or null if the document isn't a recognized feed format.
The xmlMode option is enabled by default for parseFeed. If you pass custom options, make sure to include xmlMode: true.
Performance
After having some artificial benchmarks for some time, @AndreasMadsen published his htmlparser-benchmark, which benchmarks HTML parses based on real-world websites.
At the time of writing, the latest versions of all supported parsers show the following performance characteristics on GitHub Actions (sourced from here):
The most recent commit recorded on fb55/htmlparser2 was 3 months ago, based on the GitHub push timestamp. The repository has 412 forks — one of the better signals of community interest.
How many stars does fb55/htmlparser2 have?
fb55/htmlparser2 has 4.8k GitHub stars — refresh the page for the live number, or check github.com/fb55/htmlparser2. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
Is fb55/htmlparser2 open source?
Yes — fb55/htmlparser2 ships under the MIT license, which makes its source code freely readable (and, depending on license terms, forkable and reusable). Source: github.com/fb55/htmlparser2.
What else is in the Frontend space?
fb55/htmlparser2 is tracked by TopGit under the Frontend category, alongside 7 GitHub-tagged topics. Trending and Topics pages list peer repositories of comparable stars and language.
What is fb55/htmlparser2?
fb55/htmlparser2 (fb55/htmlparser2) is a TypeScript project on GitHub. From the project's own README: The fast & forgiving HTML and XML parser
What language is fb55/htmlparser2 written in?
fb55/htmlparser2 is written primarily in TypeScript. GitHub's language field is based on the largest share of bytes in the default branch.
What license does fb55/htmlparser2 use?
fb55/htmlparser2 is released under the MIT license. Always verify the LICENSE file directly on GitHub for the authoritative terms — license strings can be edited out of sync with a project's actual stance.
Where do I read more about fb55/htmlparser2?
This TopGit page is a snapshot — the READ ME tab shows the project's own README content (links stripped, images preserved). The GitHub repository at github.com/fb55/htmlparser2 is the definitive source.
Read full README in the tab above.
Want a second opinion on htmlparser2?
Ask an AI that can read this page — one click and you get its take on htmlparser2.