entities 7.0.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "entities",
-    "version": "7.0.0",
+    "version": "8.0.0",
     "description": "Encode & decode XML and HTML entities with ease & speed",
     "keywords": [
         "html entities",
@@ -22,92 +22,62 @@
     "type": "module",
     "exports": {
         ".": {
-            "import": {
-                "types": "./dist/esm/index.d.ts",
-                "default": "./dist/esm/index.js"
-            },
-            "require": {
-                "types": "./dist/commonjs/index.d.ts",
-                "default": "./dist/commonjs/index.js"
-            }
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
         },
         "./decode": {
-            "import": {
-                "types": "./dist/esm/decode.d.ts",
-                "default": "./dist/esm/decode.js"
-            },
-            "require": {
-                "types": "./dist/commonjs/decode.d.ts",
-                "default": "./dist/commonjs/decode.js"
-            }
+            "types": "./dist/decode.d.ts",
+            "default": "./dist/decode.js"
         },
         "./escape": {
-            "import": {
-                "types": "./dist/esm/escape.d.ts",
-                "default": "./dist/esm/escape.js"
-            },
-            "require": {
-                "types": "./dist/commonjs/escape.d.ts",
-                "default": "./dist/commonjs/escape.js"
-            }
+            "types": "./dist/escape.d.ts",
+            "default": "./dist/escape.js"
         }
     },
-    "main": "./dist/commonjs/index.js",
-    "module": "./dist/esm/index.js",
-    "types": "./dist/commonjs/index.d.ts",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "files": [
-        "decode.js",
-        "decode.d.ts",
-        "escape.js",
-        "escape.d.ts",
         "dist",
-        "src"
+        "src",
+        "!**/*.spec.ts"
     ],
     "scripts": {
+        "benchmark": "node --import=tsx scripts/benchmark.ts",
+        "build": "tsc",
         "build:docs": "typedoc --hideGenerator src/index.ts",
         "build:encode-trie": "node --import=tsx scripts/write-encode-map.ts",
         "build:trie": "node --import=tsx scripts/write-decode-map.ts",
         "format": "npm run format:es && npm run format:biome",
-        "format:es": "npm run lint:es -- --fix",
         "format:biome": "biome check --fix .",
+        "format:es": "npm run lint:es -- --fix",
         "lint": "npm run lint:es && npm run lint:ts && npm run lint:biome",
-        "lint:es": "eslint . --ignore-path .gitignore",
         "lint:biome": "biome check .",
+        "lint:es": "eslint .",
         "lint:ts": "tsc --noEmit",
-        "prepublishOnly": "tshy",
+        "prepublishOnly": "npm run build",
         "test": "npm run test:vi && npm run lint",
         "test:vi": "vitest run"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.2.3",
-        "@types/node": "^24.3.1",
-        "@typescript-eslint/eslint-plugin": "^8.42.0",
-        "@typescript-eslint/parser": "^8.33.1",
-        "@vitest/coverage-v8": "^3.2.4",
-        "eslint": "^8.57.1",
+        "@biomejs/biome": "^2.4.7",
+        "@eslint/compat": "^2.0.3",
+        "@feedic/eslint-config": "^0.3.1",
+        "@types/he": "^1.2.3",
+        "@types/node": "^25.5.0",
+        "eslint": "^10.0.3",
         "eslint-config-biome": "^2.1.3",
-        "eslint-plugin-n": "^17.21.3",
-        "eslint-plugin-unicorn": "^56.0.1",
-        "tshy": "^3.0.2",
-        "tsx": "^4.20.5",
-        "typedoc": "^0.28.12",
-        "typescript": "^5.9.2",
-        "vitest": "^3.2.4"
+        "globals": "^17.4.0",
+        "he": "^1.2.0",
+        "html-entities": "^2.6.0",
+        "parse-entities": "^4.0.2",
+        "tinybench": "^6.0.0",
+        "tsx": "^4.21.0",
+        "typedoc": "^0.28.17",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.57.1",
+        "vitest": "^4.0.17"
     },
     "engines": {
-        "node": ">=0.12"
-    },
-    "tshy": {
-        "exclude": [
-            "**/*.spec.ts",
-            "**/__fixtures__/*",
-            "**/__tests__/*",
-            "**/__snapshots__/*"
-        ],
-        "exports": {
-            ".": "./src/index.ts",
-            "./decode": "./src/decode.ts",
-            "./escape": "./src/escape.ts"
-        }
+        "node": ">=20.19.0"
     }
 }

package/readme.md

@@ -10,7 +10,7 @@ Encode & decode HTML & XML entities with ease & speed.
   [`commonmark`](https://github.com/commonmark/commonmark.js) use it to process
   HTML entities.
 - ⚡️ Fast: `entities` is the fastest library for decoding HTML entities (as of
-  April 2022); see [performance](#performance).
+  September 2025); see [performance](#performance).
 - 🎛 Configurable: Get an output tailored for your needs. You are fine with
   UTF8? That'll save you some bytes. Prefer to only have ASCII characters? We
   can do that as well!
@@ -24,7 +24,7 @@ Encode & decode HTML & XML entities with ease & speed.
 ### …use `entities`
 
 ```javascript
-const entities = require("entities");
+import * as entities from "entities";
 
 // Encoding
 entities.escapeUTF8("& ü"); // "& ü"
@@ -38,15 +38,36 @@ entities.decodeHTML("asdf & ÿ ü '"); // "asdf & ÿ ü '"
 
 ## Performance
 
-This is how `entities` compares to other libraries on a very basic benchmark
-(see `scripts/benchmark.ts`, for 10,000,000 iterations; **lower is better**):
+Benchmarked in September 2025 with Node v24.6.0 on Apple M2 using `tinybench`.
+Higher ops/s is better; `avg (μs)` is the mean time per operation.
+See `scripts/benchmark.ts` to reproduce.
 
-| Library        | Version | `decode` perf | `encode` perf | `escape` perf |
-| -------------- | ------- | ------------- | ------------- | ------------- |
-| entities       | `3.0.1` | 1.418s        | 6.786s        | 2.196s        |
-| html-entities  | `2.3.2` | 2.530s        | 6.829s        | 2.415s        |
-| he             | `1.2.0` | 5.800s        | 24.237s       | 3.624s        |
-| parse-entities | `3.0.0` | 9.660s        | N/A           | N/A           |
+### Decoding
+
+| Library        | Version | ops/s     | avg (μs) | ±%   | slower |
+| -------------- | ------- | --------- | -------- | ---- | ------ |
+| entities       | 7.0.0   | 5,838,416 | 175.57   | 0.06 | —      |
+| html-entities  | 2.6.0   | 2,919,637 | 347.77   | 0.33 | 50.0%  |
+| he             | 1.2.0   | 2,318,438 | 446.48   | 0.70 | 60.3%  |
+| parse-entities | 4.0.2   |   852,855 | 1,199.51 | 0.36 | 85.4%  |
+
+### Encoding
+
+| Library        | Version | ops/s     | avg (μs) | ±%   | slower |
+| -------------- | ------- | --------- | -------- | ---- | ------ |
+| entities       | 7.0.0   | 2,770,115 | 368.09   | 0.11 | —      |
+| html-entities  | 2.6.0   | 1,491,963 | 679.96   | 0.58 | 46.2%  |
+| he             | 1.2.0   |   481,278 | 2,118.25 | 0.61 | 82.6%  |
+
+### Escaping
+
+| Library        | Version | ops/s     | avg (μs) | ±%   | slower |
+| -------------- | ------- | --------- | -------- | ---- | ------ |
+| entities       | 7.0.0   | 4,616,468 | 223.84   | 0.17 | —      |
+| he             | 1.2.0   | 3,659,301 | 280.76   | 0.58 | 20.7%  |
+| html-entities  | 2.6.0   | 3,555,301 | 296.63   | 0.84 | 23.0%  |
+
+Note: Micro-benchmarks may vary across machines and Node versions.
 
 ---
 
@@ -68,8 +89,8 @@ This is helpful for decoding entities in legacy environments.
 
 > Why should I use `entities` instead of alternative modules?
 
-As of April 2022, `entities` is a bit faster than other modules. Still, this is
-not a very differentiated space and other modules can catch up.
+As of September 2025, `entities` is faster than other modules. Still, this is
+not a differentiated space and other modules can catch up.
 
 **More importantly**, you might already have `entities` in your dependency graph
 (as a dependency of eg. `cheerio`, or `htmlparser2`), and including it directly
@@ -78,10 +99,9 @@ libraries, so have a look through your `node_modules` directory!
 
 > Does `entities` support tree shaking?
 
-Yes! `entities` ships as both a CommonJS and a ES module. Note that for best
-results, you should not use the `encode` and `decode` functions, as they wrap
-around a number of other functions, all of which will remain in the bundle.
-Instead, use the functions that you need directly.
+Yes! Note that for best results, you should not use the `encode` and `decode`
+functions, as they wrap around a number of other functions, all of which will
+remain in the bundle. Instead, use the functions that you need directly.
 
 ---
 
@@ -109,14 +129,3 @@ License: BSD-2-Clause
 To report a security vulnerability, please use the
 [Tidelift security contact](https://tidelift.com/security). Tidelift will
 coordinate the fix and disclosure.
-
-## `entities` for enterprise
-
-Available as part of the Tidelift Subscription
-
-The maintainers of `entities` and thousands of other packages are working with
-Tidelift to deliver commercial support and maintenance for the open source
-dependencies you use to build your applications. Save time, reduce risk, and
-improve code health, while paying the maintainers of the exact dependencies you
-use.
-[Learn more.](https://tidelift.com/subscription/pkg/npm-entities?utm_source=npm-entities&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

package/src/decode-codepoint.ts

@@ -32,31 +32,11 @@ const decodeMap = new Map([
     [159, 376],
 ]);
 
-/**
- * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
- */
-export const fromCodePoint: (...codePoints: number[]) => string =
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
-    String.fromCodePoint ??
-    ((codePoint: number): string => {
-        let output = "";
-
-        if (codePoint > 0xff_ff) {
-            codePoint -= 0x1_00_00;
-            output += String.fromCharCode(
-                ((codePoint >>> 10) & 0x3_ff) | 0xd8_00,
-            );
-            codePoint = 0xdc_00 | (codePoint & 0x3_ff);
-        }
-
-        output += String.fromCharCode(codePoint);
-        return output;
-    });
-
 /**
  * Replace the given code point with a replacement character if it is a
  * surrogate or is outside the valid range. Otherwise return the code
  * point unchanged.
+ * @param codePoint Unicode code point to convert.
  */
 export function replaceCodePoint(codePoint: number): number {
     if (
@@ -68,14 +48,3 @@ export function replaceCodePoint(codePoint: number): number {
 
     return decodeMap.get(codePoint) ?? codePoint;
 }
-
-/**
- * Replace the code point if relevant, then convert it to a string.
- *
- * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.
- * @param codePoint The code point to decode.
- * @returns The decoded code point.
- */
-export function decodeCodePoint(codePoint: number): string {
-    return fromCodePoint(replaceCodePoint(codePoint));
-}

package/src/decode.ts

@@ -1,4 +1,4 @@
-import { fromCodePoint, replaceCodePoint } from "./decode-codepoint.js";
+import { replaceCodePoint } from "./decode-codepoint.js";
 import { htmlDecodeTree } from "./generated/decode-data-html.js";
 import { xmlDecodeTree } from "./generated/decode-data-xml.js";
 import { BinTrieFlags } from "./internal/bin-trie-flags.js";
@@ -45,6 +45,7 @@ function isAsciiAlphaNumeric(code: number): boolean {
  *
  * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
  * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+ * @param code Code point to decode.
  */
 function isEntityInAttributeInvalidEnd(code: number): boolean {
     return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
@@ -58,6 +59,9 @@ const enum EntityDecoderState {
     NamedEntity,
 }
 
+/**
+ * Decoding mode for named entities.
+ */
 export enum DecodingMode {
     /** Entities in text nodes that can end with any character. */
     Legacy = 0,
@@ -91,7 +95,6 @@ export class EntityDecoder {
          *
          * For multi-byte named entities, this will be called multiple times,
          * with the second codepoint, and the same `consumed` value.
-         *
          * @param codepoint The decoded codepoint.
          * @param consumed The number of bytes consumed by the decoder.
          */
@@ -118,8 +121,13 @@ export class EntityDecoder {
     private excess = 1;
     /** The mode in which the decoder is operating. */
     private decodeMode = DecodingMode.Strict;
+    /** The number of characters that have been consumed in the current run. */
+    private runConsumed = 0;
 
-    /** Resets the instance to make it reusable. */
+    /**
+     * Resets the instance to make it reusable.
+     * @param decodeMode Entity decoding mode to use.
+     */
     startEntity(decodeMode: DecodingMode): void {
         this.decodeMode = decodeMode;
         this.state = EntityDecoderState.EntityStart;
@@ -127,6 +135,7 @@ export class EntityDecoder {
         this.treeIndex = 0;
         this.excess = 1;
         this.consumed = 1;
+        this.runConsumed = 0;
     }
 
     /**
@@ -135,7 +144,6 @@ export class EntityDecoder {
      *
      * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
      * entity is incomplete, and resume when the next string is written.
-     *
      * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
@@ -174,7 +182,6 @@ export class EntityDecoder {
      * Switches between the numeric decimal and hexadecimal states.
      *
      * Equivalent to the `Numeric character reference state` in the HTML spec.
-     *
      * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
@@ -198,7 +205,6 @@ export class EntityDecoder {
      * Parses a hexadecimal numeric entity.
      *
      * Equivalent to the `Hexademical character reference state` in the HTML spec.
-     *
      * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
@@ -226,7 +232,6 @@ export class EntityDecoder {
      * Parses a decimal numeric entity.
      *
      * Equivalent to the `Decimal character reference state` in the HTML spec.
-     *
      * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
@@ -250,7 +255,6 @@ export class EntityDecoder {
      *
      * Implements the logic from the `Hexademical character reference start
      * state` and `Numeric character reference end state` in the HTML spec.
-     *
      * @param lastCp The last code point of the entity. Used to see if the
      *               entity was terminated with a semicolon.
      * @param expectedLength The minimum number of characters that should be
@@ -291,7 +295,6 @@ export class EntityDecoder {
      * Parses a named entity.
      *
      * Equivalent to the `Named character reference state` in the HTML spec.
-     *
      * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
@@ -307,43 +310,49 @@ export class EntityDecoder {
             if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
                 const runLength =
                     (current & BinTrieFlags.BRANCH_LENGTH) >> 7; /* 2..63 */
-                const firstChar = current & BinTrieFlags.JUMP_TABLE;
-                // Fast-fail if we don't have enough remaining input for the full run (incomplete entity)
-                if (offset + runLength > input.length) return -1;
-                // Verify first char
-                if (input.charCodeAt(offset) !== firstChar) {
-                    return this.result === 0
-                        ? 0
-                        : this.emitNotTerminatedNamedEntity();
+
+                // If we are starting a run, check the first char.
+                if (this.runConsumed === 0) {
+                    const firstChar = current & BinTrieFlags.JUMP_TABLE;
+                    if (input.charCodeAt(offset) !== firstChar) {
+                        return this.result === 0
+                            ? 0
+                            : this.emitNotTerminatedNamedEntity();
+                    }
+                    offset++;
+                    this.excess++;
+                    this.runConsumed++;
                 }
-                offset++;
-                this.excess++;
-                // Remaining characters after the first
-                const remaining = runLength - 1;
-                // Iterate over packed 2-char words
-                for (let runPos = 1; runPos < runLength; runPos += 2) {
+
+                // Check remaining characters in the run.
+                while (this.runConsumed < runLength) {
+                    if (offset >= input.length) {
+                        return -1;
+                    }
+
+                    const charIndexInPacked = this.runConsumed - 1;
                     const packedWord =
-                        decodeTree[this.treeIndex + 1 + ((runPos - 1) >> 1)];
-                    const low = packedWord & 0xff;
-                    if (input.charCodeAt(offset) !== low) {
+                        decodeTree[
+                            this.treeIndex + 1 + (charIndexInPacked >> 1)
+                        ];
+                    const expectedChar =
+                        charIndexInPacked % 2 === 0
+                            ? packedWord & 0xff
+                            : (packedWord >> 8) & 0xff;
+
+                    if (input.charCodeAt(offset) !== expectedChar) {
+                        this.runConsumed = 0;
                         return this.result === 0
                             ? 0
                             : this.emitNotTerminatedNamedEntity();
                     }
                     offset++;
                     this.excess++;
-                    const high = (packedWord >> 8) & 0xff;
-                    if (runPos + 1 < runLength) {
-                        if (input.charCodeAt(offset) !== high) {
-                            return this.result === 0
-                                ? 0
-                                : this.emitNotTerminatedNamedEntity();
-                        }
-                        offset++;
-                        this.excess++;
-                    }
+                    this.runConsumed++;
                 }
-                this.treeIndex += 1 + ((remaining + 1) >> 1);
+
+                this.runConsumed = 0;
+                this.treeIndex += 1 + (runLength >> 1);
                 current = decodeTree[this.treeIndex];
                 valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
             }
@@ -424,7 +433,6 @@ export class EntityDecoder {
 
     /**
      * Emit a named entity that was not terminated with a semicolon.
-     *
      * @returns The number of characters consumed.
      */
     private emitNotTerminatedNamedEntity(): number {
@@ -441,11 +449,9 @@ export class EntityDecoder {
 
     /**
      * Emit a named entity.
-     *
      * @param result The index of the entity in the decode tree.
      * @param valueLength The number of bytes in the entity.
      * @param consumed The number of characters consumed.
-     *
      * @returns The number of characters consumed.
      */
     private emitNamedEntityData(
@@ -474,7 +480,6 @@ export class EntityDecoder {
      * Signal to the parser that the end of the input was reached.
      *
      * Remaining data will be emitted and relevant errors will be produced.
-     *
      * @returns The number of characters consumed.
      */
     end(): number {
@@ -510,7 +515,6 @@ export class EntityDecoder {
 
 /**
  * Creates a function that decodes entities in a string.
- *
  * @param decodeTree The decode tree.
  * @returns A function that decodes entities in a string.
  */
@@ -518,7 +522,7 @@ function getDecoder(decodeTree: Uint16Array) {
     let returnValue = "";
     const decoder = new EntityDecoder(
         decodeTree,
-        (data) => (returnValue += fromCodePoint(data)),
+        (data) => (returnValue += String.fromCodePoint(data)),
     );
 
     return function decodeWithTrie(
@@ -561,10 +565,9 @@ function getDecoder(decodeTree: Uint16Array) {
 /**
  * Determines the branch of the current node that is taken given the current
  * character. This function is used to traverse the trie.
- *
  * @param decodeTree The trie.
  * @param current The current node.
- * @param nodeIdx The index right after the current node and its value.
+ * @param nodeIndex Index immediately after the current node header.
  * @param char The current character.
  * @returns The index of the next node, or -1 if no branch is taken.
  */
@@ -624,7 +627,6 @@ const xmlDecoder = /* #__PURE__ */ getDecoder(xmlDecodeTree);
 
 /**
  * Decodes an HTML string.
- *
  * @param htmlString The string to decode.
  * @param mode The decoding mode.
  * @returns The decoded string.
@@ -638,7 +640,6 @@ export function decodeHTML(
 
 /**
  * Decodes an HTML string in an attribute.
- *
  * @param htmlAttribute The string to decode.
  * @returns The decoded string.
  */
@@ -648,7 +649,6 @@ export function decodeHTMLAttribute(htmlAttribute: string): string {
 
 /**
  * Decodes an HTML string, requiring all entities to be terminated by a semicolon.
- *
  * @param htmlString The string to decode.
  * @returns The decoded string.
  */
@@ -658,7 +658,6 @@ export function decodeHTMLStrict(htmlString: string): string {
 
 /**
  * Decodes an XML string, requiring all entities to be terminated by a semicolon.
- *
  * @param xmlString The string to decode.
  * @returns The decoded string.
  */
@@ -666,11 +665,7 @@ export function decodeXML(xmlString: string): string {
     return xmlDecoder(xmlString, DecodingMode.Strict);
 }
 
-export {
-    decodeCodePoint,
-    fromCodePoint,
-    replaceCodePoint,
-} from "./decode-codepoint.js";
+export { replaceCodePoint } from "./decode-codepoint.js";
 // Re-export for use by eg. htmlparser2
 export { htmlDecodeTree } from "./generated/decode-data-html.js";
 export { xmlDecodeTree } from "./generated/decode-data-xml.js";

package/src/encode.ts

@@ -23,6 +23,7 @@ const XML_BITSET = /* #__PURE__ */ new Uint32Array([0, XML_BITSET_VALUE, 0, 0]);
  *
  * If a character has no equivalent entity, a numeric hexadecimal reference
  * (eg. `ü`) will be used.
+ * @param input Input string to encode or decode.
  */
 export function encodeHTML(input: string): string {
     return encodeHTMLTrieRe(HTML_BITSET, input);
@@ -34,6 +35,7 @@ export function encodeHTML(input: string): string {
  *
  * If a character has no equivalent entity, a numeric hexadecimal reference
  * (eg. `ü`) will be used.
+ * @param input Input string to encode or decode.
  */
 export function encodeNonAsciiHTML(input: string): string {
     return encodeHTMLTrieRe(XML_BITSET, input);

package/src/escape.ts

@@ -7,18 +7,22 @@ const xmlCodeMap = new Map([
 ]);
 
 // For compatibility with node < 4, we wrap `codePointAt`
+/**
+ * Read a code point at a given index.
+ * @param input Input string to encode or decode.
+ * @param index Current read position in the input string.
+ */
 export const getCodePoint: (c: string, index: number) => number =
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    String.prototype.codePointAt == null
-        ? (c: string, index: number): number =>
+    typeof String.prototype.codePointAt === "function"
+        ? (input: string, index: number): number => input.codePointAt(index)!
+        : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          (c: string, index: number): number =>
               (c.charCodeAt(index) & 0xfc_00) === 0xd8_00
                   ? (c.charCodeAt(index) - 0xd8_00) * 0x4_00 +
                     c.charCodeAt(index + 1) -
                     0xdc_00 +
                     0x1_00_00
-                  : c.charCodeAt(index)
-        : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-          (input: string, index: number): number => input.codePointAt(index)!;
+                  : c.charCodeAt(index);
 
 /**
  * Bitset for ASCII characters that need to be escaped in XML.
@@ -31,6 +35,7 @@ export const XML_BITSET_VALUE = 0x50_00_00_c4; // 32..63 -> 34 ("),38 (&),39 (')
  *
  * If a character has no equivalent entity, a numeric hexadecimal reference
  * (eg. `&#xfc;`) will be used.
+ * @param input Input string to encode or decode.
  */
 export function encodeXML(input: string): string {
     let out: string | undefined;
@@ -76,7 +81,6 @@ export function encodeXML(input: string): string {
  *
  * Have a look at `escapeUTF8` if you want a more concise output at the expense
  * of reduced transportability.
- *
  * @param data String to escape.
  */
 export const escape: typeof encodeXML = encodeXML;
@@ -84,10 +88,8 @@ export const escape: typeof encodeXML = encodeXML;
 /**
  * Creates a function that escapes all characters matched by the given regular
  * expression using the given map of characters to escape to their entities.
- *
  * @param regex Regular expression to match characters to escape.
  * @param map Map of characters to escape to their entities.
- *
  * @returns Function that escapes all characters matched by the given regular
  * expression using the given map of characters to escape to their entities.
  */
@@ -120,7 +122,6 @@ function getEscaper(
  * Encodes all characters not valid in XML documents using XML entities.
  *
  * Note that the output will be character-set dependent.
- *
  * @param data String to escape.
  */
 export const escapeUTF8: (data: string) => string = /* #__PURE__ */ getEscaper(
@@ -131,7 +132,6 @@ export const escapeUTF8: (data: string) => string = /* #__PURE__ */ getEscaper(
 /**
  * Encodes all characters that have to be escaped in HTML attributes,
  * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
- *
  * @param data String to escape.
  */
 export const escapeAttribute: (data: string) => string =
@@ -147,7 +147,6 @@ export const escapeAttribute: (data: string) => string =
 /**
  * Encodes all characters that have to be escaped in HTML text,
  * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
- *
  * @param data String to escape.
  */
 export const escapeText: (data: string) => string = /* #__PURE__ */ getEscaper(