@zowe/cli 8.36.0 → 8.37.0

package/node_modules/{htmlparser2 → sanitize-html}/node_modules/entities/src/index.ts

@@ -1,4 +1,4 @@
-import { DecodingMode, decodeHTML, decodeXML } from "./decode.js";
+import { type DecodingMode, decodeHTML, decodeXML } from "./decode.js";
 import { encodeHTML, encodeNonAsciiHTML } from "./encode.js";
 import {
     encodeXML,
@@ -15,6 +15,9 @@ export enum EntityLevel {
     HTML = 1,
 }
 
+/**
+ * Encoding strategy used by `encode`.
+ */
 export enum EncodingMode {
     /**
      * The output is UTF-8 encoded. Only characters that need escaping within
@@ -44,6 +47,9 @@ export enum EncodingMode {
     Text,
 }
 
+/**
+ * Options for `decode`.
+ */
 export interface DecodingOptions {
     /**
      * The level of entities to support.
@@ -54,11 +60,8 @@ export interface DecodingOptions {
      * Decoding mode. If `Legacy`, will support legacy entities not terminated
      * with a semicolon (`;`).
      *
-     * Always `Strict` for XML. For HTML, set this to `true` if you are parsing
-     * an attribute value.
-     *
-     * The deprecated `decodeStrict` function defaults this to `Strict`.
-     *
+     * Always `Strict` for XML. For HTML, set this to
+     * {@link DecodingMode.Attribute} if you are parsing an attribute value.
      * @default {@link DecodingMode.Legacy}
      */
     mode?: DecodingMode | undefined;
@@ -66,7 +69,6 @@ export interface DecodingOptions {
 
 /**
  * Decodes a string with entities.
- *
  * @param input String to decode.
  * @param options Decoding options.
  */
@@ -84,24 +86,6 @@ export function decode(
     return decodeXML(input);
 }
 
-/**
- * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
- *
- * @param input String to decode.
- * @param options Decoding options.
- * @deprecated Use `decode` with the `mode` set to `Strict`.
- */
-export function decodeStrict(
-    input: string,
-    options: DecodingOptions | EntityLevel = EntityLevel.XML,
-): string {
-    const normalizedOptions =
-        typeof options === "number" ? { level: options } : options;
-    normalizedOptions.mode ??= DecodingMode.Strict;
-
-    return decode(input, normalizedOptions);
-}
-
 /**
  * Options for `encode`.
  */
@@ -120,7 +104,6 @@ export interface EncodingOptions {
 
 /**
  * Encodes a string with entities.
- *
  * @param input String to encode.
  * @param options Encoding options.
  */
@@ -142,16 +125,14 @@ export function encode(
             return escapeText(input);
         }
         case EncodingMode.ASCII: {
-            return level === EntityLevel.HTML
-                ? encodeNonAsciiHTML(input)
-                : encodeXML(input);
+            return (
+                level === EntityLevel.HTML ? encodeNonAsciiHTML : encodeXML
+            )(input);
         }
         // biome-ignore lint/complexity/noUselessSwitchCase: we get an error for the switch not being exhaustive
-        case EncodingMode.Extensive: // eslint-disable-line unicorn/no-useless-switch-case
+        case EncodingMode.Extensive:
         default: {
-            return level === EntityLevel.HTML
-                ? encodeHTML(input)
-                : encodeXML(input);
+            return (level === EntityLevel.HTML ? encodeHTML : encodeXML)(input);
         }
     }
 }
@@ -159,13 +140,8 @@ export function encode(
 export {
     DecodingMode,
     decodeHTML,
-    // Legacy aliases (deprecated)
-    decodeHTML as decodeHTML4,
-    decodeHTML as decodeHTML5,
     decodeHTMLAttribute,
     decodeHTMLStrict,
-    decodeHTMLStrict as decodeHTML4Strict,
-    decodeHTMLStrict as decodeHTML5Strict,
     decodeXML,
     decodeXML as decodeXMLStrict,
     EntityDecoder,
@@ -173,9 +149,6 @@ export {
 
 export {
     encodeHTML,
-    // Legacy aliases (deprecated)
-    encodeHTML as encodeHTML4,
-    encodeHTML as encodeHTML5,
     encodeNonAsciiHTML,
 } from "./encode.js";
 export {

package/node_modules/sanitize-html/node_modules/entities/src/internal/bin-trie-flags.ts

@@ -0,0 +1,47 @@
+/**
+ * Bit flags & masks for the binary trie encoding used for entity decoding.
+ *
+ * The trie is a flat `Uint16Array`. Every node starts with one header word:
+ *
+ *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.
+ *                         0 = no value; 1 = value inline in bits 12..0;
+ *                         2/3 = value in the 1/2 words after the header.
+ *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required ("strict"
+ *                         entity; `;` is never stored as a branch).
+ *                         If VALUE_LENGTH == 0: this node is a compact run.
+ *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).
+ *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first
+ *                         run char (see below).
+ *
+ * Branch data follows the header and any value words. Its shape is selected
+ * by (JUMP_TABLE, BRANCH_LENGTH) in the header:
+ *
+ *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.
+ *                  No branch words; the child node follows immediately.
+ *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =
+ *                  table length. One word per covered char: 0 = no branch,
+ *                  otherwise the child's offset from the END of the table,
+ *                  +1 (so 0 stays the no-branch sentinel).
+ *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.
+ *                  ceil(n/2) words of sorted keys packed two per word
+ *                  (low byte first), then n pointer words storing the
+ *                  child's offset from the END of the branch data.
+ *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run
+ *                  length (3..63), JUMP_TABLE = first char; remaining run
+ *                  chars packed two per word after the header. The target
+ *                  node follows the packed words immediately.
+ *
+ * Pointers are end-relative (rather than relative to the pointer's own
+ * position) because that makes the common "child encoded right after the
+ * branch data" case a small constant, which compresses far better. Offsets
+ * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the
+ * decoder masks navigation results with `& 0xff_ff` to match.
+ */
+export const enum BinTrieFlags {
+    VALUE_LENGTH = 0b1100_0000_0000_0000,
+    FLAG13 = 0b0010_0000_0000_0000,
+    BRANCH_LENGTH = 0b0001_1111_1000_0000,
+    JUMP_TABLE = 0b0000_0000_0111_1111,
+    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */
+    VALUE_MASK = 0b0001_1111_1111_1111,
+}

package/node_modules/sanitize-html/node_modules/entities/src/internal/decode-shared.ts

@@ -0,0 +1,209 @@
+/*
+ * Inverse of the encoder's SAFE alphabet (0x21..0x7E minus 0x22, 0x24, 0x5C),
+ * precomputed once at module load. Entries for excluded chars stay 0 but
+ * are never read.
+ */
+const BASE91_INVERSE = /* #__PURE__ */ (() => {
+    const table = new Uint8Array(127);
+    let code = 0;
+    for (let char = 0x21; char <= 0x7e; char++) {
+        if (char !== 0x22 && char !== 0x24 && char !== 0x5c) {
+            table[char] = code++;
+        }
+    }
+    return table;
+})();
+
+/**
+ * Decode a dictionary-encoded trie string back into its Uint16Array.
+ *
+ * Stream layout (consumed in this order):
+ *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.
+ *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.
+ *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,
+ *      each a pair of slot codes that resolve to earlier slots.
+ *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.
+ *   5. data — slot codes, each expanding to one or more uint16 values.
+ *
+ * Codes use a 91-char base (printable ASCII minus `"`, `$`, `\`):
+ *   - char1 < dictSize  → 1-char code, slot = char1
+ *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2
+ *
+ * Slot index → token kind:
+ *   [0, A)                  dict1 atoms     (1-char codes)
+ *   [A, dictSize)           dict1 ngrams    (1-char codes)
+ *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)
+ *   [dictSize+D, end)       dict2 ngrams    (2-char codes)
+ *
+ * Both atom dicts decode before any ngram, and dict2 ngrams decode before
+ * dict1 ngrams. So every ngram entry references slots whose contents are
+ * already filled — no forward references to handle.
+ *
+ * This runs on library import. Flat typed arrays store each slot as either
+ * a plain value (`single`, covering every atom) or a range in a shared
+ * `pool` (ngrams).
+ * @param input Packed trie string.
+ * @param resultLength Expected number of uint16 values in the output.
+ * @param atomCount Total number of distinct uint16 values in the trie.
+ * @param dict1AtomCount Atoms in the 1-char range (`A` above).
+ * @param ngramCount Total number of ngram entries (dict1 + dict2).
+ * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`
+ *   first-byte values are 2-char codes.
+ */
+export function decodeTrieDict(
+    input: string,
+    resultLength: number,
+    atomCount: number,
+    dict1AtomCount: number,
+    ngramCount: number,
+    dictSize: number,
+): Uint16Array {
+    const base = 91;
+    const inputLength = input.length;
+    // For 2-char codes, slot = char1 * base - twoCharBias + char2.
+    const twoCharBias = dictSize * (base - 1);
+
+    let pos = 0;
+
+    /** Read one slot code at `pos` and return its slot index, advancing pos. */
+    const readSlotCode = (): number => {
+        const c1 = BASE91_INVERSE[input.charCodeAt(pos++)];
+        return c1 < dictSize
+            ? c1
+            : c1 * base - twoCharBias + BASE91_INVERSE[input.charCodeAt(pos++)];
+    };
+
+    const dict2AtomCount = atomCount - dict1AtomCount;
+    const slotCount = atomCount + ngramCount;
+
+    /*
+     * Per-slot contents: atoms (always a single value) live directly in
+     * `single`; ngram slots hold -1 there and expand to
+     * `pool[start[slot] .. start[slot] + length[slot])`.
+     */
+    const single = new Int32Array(slotCount);
+    single.fill(-1, dict1AtomCount, dictSize);
+    single.fill(-1, dictSize + dict2AtomCount, slotCount);
+    const start = new Int32Array(slotCount);
+    const length = new Int32Array(slotCount);
+
+    /**
+     * Decode `count` ascending uint16 values from a delta+RLE stream into
+     * `single[off..off+count)`.
+     *
+     *   code < 89   → delta = code
+     *   code == 89  → run-length: next char encodes runLength-2; emit `runLength` consecutive +1 values
+     *   code == 90, next < 90  → escape: delta = 89 + next * BASE + after-next
+     *   code == 90, next == 90 → double-escape: extra char for very large deltas
+     * @param count
+     * @param off
+     */
+    function decodeDelta(count: number, off: number): void {
+        let previous = 0;
+        let slot = off;
+        const end = off + count;
+        while (slot < end) {
+            const code = BASE91_INVERSE[input.charCodeAt(pos++)];
+            if (code < 89) {
+                previous += code;
+                single[slot++] = previous;
+            } else if (code === 89) {
+                let runLength = BASE91_INVERSE[input.charCodeAt(pos++)] + 2;
+                while (runLength--) single[slot++] = ++previous;
+            } else {
+                const next = BASE91_INVERSE[input.charCodeAt(pos++)];
+                previous +=
+                    89 +
+                    // eslint-disable-next-line unicorn/prefer-minimal-ternary -- branches read a different number of side-effecting input bytes
+                    (next < 90
+                        ? next * base + BASE91_INVERSE[input.charCodeAt(pos++)]
+                        : BASE91_INVERSE[input.charCodeAt(pos++)] * 8281 +
+                          BASE91_INVERSE[input.charCodeAt(pos++)] * base +
+                          BASE91_INVERSE[input.charCodeAt(pos++)]);
+                single[slot++] = previous;
+            }
+        }
+    }
+
+    // Streams 1 & 2: atoms decoded into their slot ranges.
+    decodeDelta(dict1AtomCount, 0);
+    decodeDelta(dict2AtomCount, dictSize);
+
+    /*
+     * Streams 3 & 4 are read in two passes: first collect every ngram's two
+     * references and derive its expanded length (each ref resolves to an earlier
+     * slot, so lengths are already known), which sizes the shared pool.
+     * Pool ranges are handed out in decode order, so the second pass fills
+     * the pool contiguously with a single write cursor.
+     */
+    const references = new Int32Array(ngramCount * 2);
+    let poolSize = 0;
+    let ngramIndex = 0;
+
+    /**
+     * Read `count` ngram entries (each = 2 slot-code references) for the slots
+     * starting at `startSlot`, recording references and assigning pool ranges.
+     * @param count
+     * @param startSlot
+     */
+    function readNgramReferences(count: number, startSlot: number): void {
+        for (let index = 0; index < count; index++) {
+            const slot = startSlot + index;
+            const a = readSlotCode();
+            const b = readSlotCode();
+            references[ngramIndex * 2] = a;
+            references[ngramIndex * 2 + 1] = b;
+            ngramIndex += 1;
+            start[slot] = poolSize;
+            const entryLength =
+                (single[a] < 0 ? length[a] : 1) +
+                (single[b] < 0 ? length[b] : 1);
+            length[slot] = entryLength;
+            poolSize += entryLength;
+        }
+    }
+    readNgramReferences(
+        ngramCount - dictSize + dict1AtomCount,
+        dictSize + dict2AtomCount,
+    );
+    readNgramReferences(dictSize - dict1AtomCount, dict1AtomCount);
+
+    // Second pass: concatenate each ngram's two halves into the pool.
+    const pool = new Uint16Array(poolSize);
+    let write = 0;
+    for (let index = 0; index < ngramIndex; index++) {
+        for (let half = 0; half < 2; half++) {
+            const source = references[index * 2 + half];
+            const value = single[source];
+            if (value < 0) {
+                let read = start[source];
+                const readEnd = read + length[source];
+                while (read < readEnd) pool[write++] = pool[read++];
+            } else {
+                pool[write++] = value;
+            }
+        }
+    }
+
+    // Stream 5: data. Each code expands to its slot's stored values.
+    const out = new Uint16Array(resultLength);
+    let outIndex = 0;
+    while (pos < inputLength) {
+        let slot = BASE91_INVERSE[input.charCodeAt(pos++)];
+        if (slot >= dictSize) {
+            slot =
+                slot * base -
+                twoCharBias +
+                BASE91_INVERSE[input.charCodeAt(pos++)];
+        }
+        const value = single[slot];
+        if (value < 0) {
+            let read = start[slot];
+            const readEnd = read + length[slot];
+            while (read < readEnd) out[outIndex++] = pool[read++];
+        } else {
+            out[outIndex++] = value;
+        }
+    }
+    return out;
+}

package/node_modules/sanitize-html/node_modules/htmlparser2/README.md

@@ -0,0 +1,257 @@
+# htmlparser2
+
+[![NPM version](https://img.shields.io/npm/v/htmlparser2.svg)](https://npmjs.org/package/htmlparser2)
+[![Downloads](https://img.shields.io/npm/dm/htmlparser2.svg)](https://npmjs.org/package/htmlparser2)
+[![Node.js CI](https://github.com/fb55/htmlparser2/actions/workflows/nodejs-test.yml/badge.svg)](https://github.com/fb55/htmlparser2/actions/workflows/nodejs-test.yml)
+[![Coverage](https://img.shields.io/coveralls/fb55/htmlparser2.svg)](https://coveralls.io/r/fb55/htmlparser2)
+
+The fast & forgiving HTML/XML parser.
+
+_htmlparser2 is [the fastest HTML parser](#performance), and takes some shortcuts to get there. If you need strict HTML spec compliance, have a look at [parse5](https://github.com/inikulin/parse5)._
+
+## Installation
+
+    npm install htmlparser2
+
+A live demo of `htmlparser2` is available [on AST Explorer](https://astexplorer.net/#/2AmVrGuGVJ).
+
+## Ecosystem
+
+| Name                                                          | Description                                             |
+| ------------------------------------------------------------- | ------------------------------------------------------- |
+| [htmlparser2](https://github.com/fb55/htmlparser2)            | Fast & forgiving HTML/XML parser                        |
+| [domhandler](https://github.com/fb55/domhandler)              | Handler for htmlparser2 that turns documents into a DOM |
+| [domutils](https://github.com/fb55/domutils)                  | Utilities for working with domhandler's DOM             |
+| [css-select](https://github.com/fb55/css-select)              | CSS selector engine, compatible with domhandler's DOM   |
+| [cheerio](https://github.com/cheeriojs/cheerio)               | The jQuery API for domhandler's DOM                     |
+| [dom-serializer](https://github.com/cheeriojs/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](#getting-a-dom) below.
+
+```js
+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();
+```
+
+Output (with multiple text events combined):
+
+```
+--> Xyz
+JS! Hooray!
+--> const foo = '<<bar>>';
+That's it?!
+```
+
+### Parser events
+
+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. `&amp;` -> `&`).                                                                                                              |
+| `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:
+
+```js
+import { WritableStream } from "htmlparser2/WritableStream";
+
+const parserStream = new WritableStream({
+    ontext(text) {
+        console.log("Streaming:", text);
+    },
+});
+
+const htmlStream = fs.createReadStream("./my-file.html");
+htmlStream.pipe(parserStream).on("finish", () => console.log("done"));
+```
+
+## Getting a DOM
+
+The `parseDocument` helper parses a string and returns a DOM tree (a [`Document`](https://github.com/fb55/domhandler) node).
+
+```js
+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](https://github.com/fb55/domhandler):
+
+```js
+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`](https://github.com/fb55/domutils) module (re-exported on the main `htmlparser2` export) provides helpers for finding nodes:
+
+```js
+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`](https://github.com/fb55/css-select):
+
+```js
+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`](https://github.com/cheeriojs/cheerio).
+
+### Modifying and serializing the DOM
+
+Use `DomUtils` to modify the tree, and [`dom-serializer`](https://github.com/cheeriojs/dom-serializer) (also available as `DomUtils.getOuterHTML`) to serialize it back to HTML:
+
+```js
+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](https://github.com/fb55/domutils) for the full API.
+
+## Parsing feeds
+
+`htmlparser2` makes it easy to parse RSS, RDF and Atom feeds, by providing a `parseFeed` method:
+
+```javascript
+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`](https://github.com/AndreasMadsen/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](https://github.com/AndreasMadsen/htmlparser-benchmark/blob/e78cd8fc6c2adac08deedd4f274c33537451186b/stats.txt)):
+
+```
+htmlparser2        : 2.17215 ms/file ± 3.81587
+node-html-parser   : 2.35983 ms/file ± 1.54487
+html5parser        : 2.43468 ms/file ± 2.81501
+neutron-html5parser: 2.61356 ms/file ± 1.70324
+htmlparser2-dom    : 3.09034 ms/file ± 4.77033
+html-dom-parser    : 3.56804 ms/file ± 5.15621
+libxmljs           : 4.07490 ms/file ± 2.99869
+htmljs-parser      : 6.15812 ms/file ± 7.52497
+parse5             : 9.70406 ms/file ± 6.74872
+htmlparser         : 15.0596 ms/file ± 89.0826
+html-parser        : 28.6282 ms/file ± 22.6652
+saxes              : 45.7921 ms/file ± 128.691
+html5              : 120.844 ms/file ± 153.944
+```
+
+## Security contact information
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.