entities 4.5.0 → 5.0.0

package/src/decode-codepoint.ts

@@ -0,0 +1,81 @@
+// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
+
+const decodeMap = new Map([
+    [0, 65_533],
+    // C1 Unicode control character reference replacements
+    [128, 8364],
+    [130, 8218],
+    [131, 402],
+    [132, 8222],
+    [133, 8230],
+    [134, 8224],
+    [135, 8225],
+    [136, 710],
+    [137, 8240],
+    [138, 352],
+    [139, 8249],
+    [140, 338],
+    [142, 381],
+    [145, 8216],
+    [146, 8217],
+    [147, 8220],
+    [148, 8221],
+    [149, 8226],
+    [150, 8211],
+    [151, 8212],
+    [152, 732],
+    [153, 8482],
+    [154, 353],
+    [155, 8250],
+    [156, 339],
+    [158, 382],
+    [159, 376],
+]);
+
+/**
+ * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+ */
+export const fromCodePoint =
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+    String.fromCodePoint ??
+    function (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.
+ */
+export function replaceCodePoint(codePoint: number) {
+    if (
+        (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||
+        codePoint > 0x10_ff_ff
+    ) {
+        return 0xff_fd;
+    }
+
+    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 default function decodeCodePoint(codePoint: number): string {
+    return fromCodePoint(replaceCodePoint(codePoint));
+}

package/src/decode.spec.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, vitest } from "vitest";
+import * as entities from "./decode.js";
+
+describe("Decode test", () => {
+    const testcases = [
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: "&", output: "&" },
+        { input: ":", output: ":" },
+        { input: ":", output: ":" },
+        { input: ":", output: ":" },
+        { input: ":", output: ":" },
+        { input: "&#", output: "&#" },
+        { input: "&>", output: "&>" },
+        { input: "id=770&#anchor", output: "id=770&#anchor" },
+    ];
+
+    for (const { input, output } of testcases) {
+        it(`should XML decode ${input}`, () =>
+            expect(entities.decodeXML(input)).toBe(output));
+        it(`should HTML decode ${input}`, () =>
+            expect(entities.decodeHTML(input)).toBe(output));
+    }
+
+    it("should HTML decode partial legacy entity", () => {
+        expect(entities.decodeHTMLStrict("&timesbar")).toBe("&timesbar");
+        expect(entities.decodeHTML("&timesbar")).toBe("×bar");
+    });
+
+    it("should HTML decode legacy entities according to spec", () =>
+        expect(entities.decodeHTML("?&image_uri=1&ℑ=2&image=3")).toBe(
+            "?&image_uri=1&ℑ=2&image=3",
+        ));
+
+    it("should back out of legacy entities", () =>
+        expect(entities.decodeHTML("&ampa")).toBe("&a"));
+
+    it("should not parse numeric entities in strict mode", () =>
+        expect(entities.decodeHTMLStrict("&#55")).toBe("&#55"));
+
+    it("should parse &nbsp followed by < (#852)", () =>
+        expect(entities.decodeHTML("&nbsp<")).toBe("\u00A0<"));
+
+    it("should decode trailing legacy entities", () => {
+        expect(entities.decodeHTML("&timesbar;&timesbar")).toBe("⨱×bar");
+    });
+
+    it("should decode multi-byte entities", () => {
+        expect(entities.decodeHTML("&NotGreaterFullEqual;")).toBe("≧̸");
+    });
+
+    it("should not decode legacy entities followed by text in attribute mode", () => {
+        expect(
+            entities.decodeHTML("&not", entities.DecodingMode.Attribute),
+        ).toBe("¬");
+
+        expect(
+            entities.decodeHTML("&noti", entities.DecodingMode.Attribute),
+        ).toBe("&noti");
+
+        expect(
+            entities.decodeHTML("&not=", entities.DecodingMode.Attribute),
+        ).toBe("&not=");
+
+        expect(entities.decodeHTMLAttribute("&notp")).toBe("&notp");
+        expect(entities.decodeHTMLAttribute("&notP")).toBe("&notP");
+        expect(entities.decodeHTMLAttribute("&not3")).toBe("&not3");
+    });
+});
+
+describe("EntityDecoder", () => {
+    it("should decode decimal entities", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        expect(decoder.write("&#5", 1)).toBe(-1);
+        expect(decoder.write("8;", 0)).toBe(5);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(":".charCodeAt(0), 5);
+    });
+
+    it("should decode hex entities", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        expect(decoder.write("&#x3a;", 1)).toBe(6);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(":".charCodeAt(0), 6);
+    });
+
+    it("should decode named entities", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        expect(decoder.write("&amp;", 1)).toBe(5);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith("&".charCodeAt(0), 5);
+    });
+
+    it("should decode legacy entities", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+        decoder.startEntity(entities.DecodingMode.Legacy);
+
+        expect(decoder.write("&amp", 1)).toBe(-1);
+
+        expect(callback).toHaveBeenCalledTimes(0);
+
+        expect(decoder.end()).toBe(4);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith("&".charCodeAt(0), 4);
+    });
+
+    it("should decode named entity written character by character", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        for (const c of "amp") {
+            expect(decoder.write(c, 0)).toBe(-1);
+        }
+        expect(decoder.write(";", 0)).toBe(5);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith("&".charCodeAt(0), 5);
+    });
+
+    it("should decode numeric entity written character by character", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        for (const c of "#x3a") {
+            expect(decoder.write(c, 0)).toBe(-1);
+        }
+        expect(decoder.write(";", 0)).toBe(6);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(":".charCodeAt(0), 6);
+    });
+
+    it("should decode hex entities across several chunks", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        for (const chunk of ["#x", "cf", "ff", "d"]) {
+            expect(decoder.write(chunk, 0)).toBe(-1);
+        }
+
+        expect(decoder.write(";", 0)).toBe(9);
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(0xc_ff_fd, 9);
+    });
+
+    it("should not fail if nothing is written", () => {
+        const callback = vitest.fn();
+        const decoder = new entities.EntityDecoder(
+            entities.htmlDecodeTree,
+            callback,
+        );
+
+        expect(decoder.end()).toBe(0);
+        expect(callback).toHaveBeenCalledTimes(0);
+    });
+
+    describe("errors", () => {
+        it("should produce an error for a named entity without a semicolon", () => {
+            const errorHandlers = {
+                missingSemicolonAfterCharacterReference: vitest.fn(),
+                absenceOfDigitsInNumericCharacterReference: vitest.fn(),
+                validateNumericCharacterReference: vitest.fn(),
+            };
+            const callback = vitest.fn();
+            const decoder = new entities.EntityDecoder(
+                entities.htmlDecodeTree,
+                callback,
+                errorHandlers,
+            );
+
+            decoder.startEntity(entities.DecodingMode.Legacy);
+            expect(decoder.write("&amp;", 1)).toBe(5);
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith("&".charCodeAt(0), 5);
+            expect(
+                errorHandlers.missingSemicolonAfterCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+
+            decoder.startEntity(entities.DecodingMode.Legacy);
+            expect(decoder.write("&amp", 1)).toBe(-1);
+            expect(decoder.end()).toBe(4);
+
+            expect(callback).toHaveBeenCalledTimes(2);
+            expect(callback).toHaveBeenLastCalledWith("&".charCodeAt(0), 4);
+            expect(
+                errorHandlers.missingSemicolonAfterCharacterReference,
+            ).toHaveBeenCalledTimes(1);
+        });
+
+        it("should produce an error for a numeric entity without a semicolon", () => {
+            const errorHandlers = {
+                missingSemicolonAfterCharacterReference: vitest.fn(),
+                absenceOfDigitsInNumericCharacterReference: vitest.fn(),
+                validateNumericCharacterReference: vitest.fn(),
+            };
+            const callback = vitest.fn();
+            const decoder = new entities.EntityDecoder(
+                entities.htmlDecodeTree,
+                callback,
+                errorHandlers,
+            );
+
+            decoder.startEntity(entities.DecodingMode.Legacy);
+            expect(decoder.write("&#x3a", 1)).toBe(-1);
+            expect(decoder.end()).toBe(5);
+
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith(0x3a, 5);
+            expect(
+                errorHandlers.missingSemicolonAfterCharacterReference,
+            ).toHaveBeenCalledTimes(1);
+            expect(
+                errorHandlers.absenceOfDigitsInNumericCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+            expect(
+                errorHandlers.validateNumericCharacterReference,
+            ).toHaveBeenCalledTimes(1);
+            expect(
+                errorHandlers.validateNumericCharacterReference,
+            ).toHaveBeenCalledWith(0x3a);
+        });
+
+        it("should produce an error for numeric entities without digits", () => {
+            const errorHandlers = {
+                missingSemicolonAfterCharacterReference: vitest.fn(),
+                absenceOfDigitsInNumericCharacterReference: vitest.fn(),
+                validateNumericCharacterReference: vitest.fn(),
+            };
+            const callback = vitest.fn();
+            const decoder = new entities.EntityDecoder(
+                entities.htmlDecodeTree,
+                callback,
+                errorHandlers,
+            );
+
+            decoder.startEntity(entities.DecodingMode.Legacy);
+            expect(decoder.write("&#", 1)).toBe(-1);
+            expect(decoder.end()).toBe(0);
+
+            expect(callback).toHaveBeenCalledTimes(0);
+            expect(
+                errorHandlers.missingSemicolonAfterCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+            expect(
+                errorHandlers.absenceOfDigitsInNumericCharacterReference,
+            ).toHaveBeenCalledTimes(1);
+            expect(
+                errorHandlers.absenceOfDigitsInNumericCharacterReference,
+            ).toHaveBeenCalledWith(2);
+            expect(
+                errorHandlers.validateNumericCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+        });
+
+        it("should produce an error for hex entities without digits", () => {
+            const errorHandlers = {
+                missingSemicolonAfterCharacterReference: vitest.fn(),
+                absenceOfDigitsInNumericCharacterReference: vitest.fn(),
+                validateNumericCharacterReference: vitest.fn(),
+            };
+            const callback = vitest.fn();
+            const decoder = new entities.EntityDecoder(
+                entities.htmlDecodeTree,
+                callback,
+                errorHandlers,
+            );
+
+            decoder.startEntity(entities.DecodingMode.Legacy);
+            expect(decoder.write("&#x", 1)).toBe(-1);
+            expect(decoder.end()).toBe(0);
+
+            expect(callback).toHaveBeenCalledTimes(0);
+            expect(
+                errorHandlers.missingSemicolonAfterCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+            expect(
+                errorHandlers.absenceOfDigitsInNumericCharacterReference,
+            ).toHaveBeenCalledTimes(1);
+            expect(
+                errorHandlers.validateNumericCharacterReference,
+            ).toHaveBeenCalledTimes(0);
+        });
+    });
+});