@mavogel/cdk-vscode-server 0.0.123 → 0.0.124

package/node_modules/node-html-parser/node_modules/entities/src/index.ts

@@ -0,0 +1,160 @@
+import { type DecodingMode, decodeHTML, decodeXML } from "./decode.js";
+import { encodeHTML, encodeNonAsciiHTML } from "./encode.js";
+import {
+    encodeXML,
+    escapeAttribute,
+    escapeText,
+    escapeUTF8,
+} from "./escape.js";
+
+/** The level of entities to support. */
+export enum EntityLevel {
+    /** Support only XML entities. */
+    XML = 0,
+    /** Support HTML entities, which are a superset of XML entities. */
+    HTML = 1,
+}
+
+/**
+ * Encoding strategy used by `encode`.
+ */
+export enum EncodingMode {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * XML will be escaped.
+     */
+    UTF8,
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    ASCII,
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    Extensive,
+    /**
+     * Encode all characters that have to be escaped in HTML attributes,
+     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+     */
+    Attribute,
+    /**
+     * Encode all characters that have to be escaped in HTML text,
+     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+     */
+    Text,
+}
+
+/**
+ * Options for `decode`.
+ */
+export interface DecodingOptions {
+    /**
+     * The level of entities to support.
+     * @default {@link EntityLevel.XML}
+     */
+    level?: EntityLevel;
+    /**
+     * Decoding mode. If `Legacy`, will support legacy entities not terminated
+     * with a semicolon (`;`).
+     *
+     * 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;
+}
+
+/**
+ * Decodes a string with entities.
+ * @param input String to decode.
+ * @param options Decoding options.
+ */
+export function decode(
+    input: string,
+    options: DecodingOptions | EntityLevel = EntityLevel.XML,
+): string {
+    const level = typeof options === "number" ? options : options.level;
+
+    if (level === EntityLevel.HTML) {
+        const mode = typeof options === "object" ? options.mode : undefined;
+        return decodeHTML(input, mode);
+    }
+
+    return decodeXML(input);
+}
+
+/**
+ * Options for `encode`.
+ */
+export interface EncodingOptions {
+    /**
+     * The level of entities to support.
+     * @default {@link EntityLevel.XML}
+     */
+    level?: EntityLevel;
+    /**
+     * Output format.
+     * @default {@link EncodingMode.Extensive}
+     */
+    mode?: EncodingMode;
+}
+
+/**
+ * Encodes a string with entities.
+ * @param input String to encode.
+ * @param options Encoding options.
+ */
+export function encode(
+    input: string,
+    options: EncodingOptions | EntityLevel = EntityLevel.XML,
+): string {
+    const { mode = EncodingMode.Extensive, level = EntityLevel.XML } =
+        typeof options === "number" ? { level: options } : options;
+
+    switch (mode) {
+        case EncodingMode.UTF8: {
+            return escapeUTF8(input);
+        }
+        case EncodingMode.Attribute: {
+            return escapeAttribute(input);
+        }
+        case EncodingMode.Text: {
+            return escapeText(input);
+        }
+        case EncodingMode.ASCII: {
+            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:
+        default: {
+            return (level === EntityLevel.HTML ? encodeHTML : encodeXML)(input);
+        }
+    }
+}
+
+export {
+    DecodingMode,
+    decodeHTML,
+    decodeHTMLAttribute,
+    decodeHTMLStrict,
+    decodeXML,
+    decodeXML as decodeXMLStrict,
+    EntityDecoder,
+} from "./decode.js";
+
+export {
+    encodeHTML,
+    encodeNonAsciiHTML,
+} from "./encode.js";
+export {
+    encodeXML,
+    escape,
+    escapeAttribute,
+    escapeText,
+    escapeUTF8,
+} from "./escape.js";

package/node_modules/node-html-parser/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/node-html-parser/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/node-html-parser/package.json

@@ -1,31 +1,37 @@
 {
 	"name": "node-html-parser",
-	"version": "7.1.0",
+	"version": "9.0.4",
 	"description": "A very fast HTML parser, generating a simplified DOM, with basic element query support.",
-	"main": "dist/index.js",
+	"main": "dist/index.cjs",
 	"types": "dist/index.d.ts",
+	"module": "dist/index.mjs",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.cjs"
+		}
+	},
 	"scripts": {
-		"compile": "tsc",
-		"build": "npm run lint && npm run clean && npm run compile:cjs && npm run compile:amd",
-		"compile:cjs": "tsc -m commonjs",
-		"watch": "npx tsc -m commonjs --watch --preserveWatchOutput",
-		"compile:amd": "tsc -t es5 -m amd -d false --outFile ./dist/main.js",
+		"compile": "tsdown && tsc --emitDeclarationOnly --outDir dist",
+		"build": "bun run compile",
+		"watch": "tsdown --watch",
 		"lint": "eslint ./src/*.ts ./src/**/*.ts",
 		"---------------": "",
-		"pretest": "cd ./test/ && yarn install && cd ..",
-		"test": "yarn run test:target",
-		"test:src": "cross-env TEST_TARGET=src yarn run test",
-		"test:dist": "cross-env TEST_TARGET=dist yarn run test",
+		"pretest": "cd ./test && bun install && cd ..",
+		"test": "bun run test:dist",
+		"test:src": "cross-env TEST_TARGET=src mocha --recursive \"./test/tests\" --require ts-node/register --require blanket --require should --require spec",
+		"test:dist": "cross-env TEST_TARGET=dist mocha --recursive \"./test/tests\" --require blanket --require should --require spec",
 		"benchmark": "node ./test/benchmark/compare.mjs",
 		"---------------  ": "",
 		"clean": "npx rimraf ./dist/",
-		"clean:global": "yarn run clean && npx rimraf yarn.lock test/yarn.lock test/node_modules node_modules",
-		"reset": "yarn run clean:global && yarn install && yarn build",
+		"clean:global": "bun run clean && rm -rf test/node_modules node_modules",
+		"reset": "bun run clean:global && bun install && bun run build",
 		"--------------- ": "",
-		"test:target": "mocha --recursive \"./test/tests\"",
-		"test:ci": "cd test && yarn install && cd .. && cross-env TEST_TARGET=dist yarn run test:target",
-		"posttest": "yarn run benchmark",
-		"prepare": "npm run build",
+		"test:target": "cross-env TEST_TARGET=dist mocha --recursive \"./test/tests\" --require blanket --require should --require spec",
+		"test:ci": "cd test && bun install && cd .. && cross-env TEST_TARGET=dist bun run test:target",
+		"posttest": "bun run benchmark",
+		"prepare": "bun run compile",
 		"release": "standard-version && git push --follow-tags origin main"
 	},
 	"keywords": [
@@ -51,35 +57,32 @@
 	},
 	"dependencies": {
 		"css-select": "^5.1.0",
-		"he": "1.2.0"
+		"entities": "^8.0.0"
 	},
 	"devDependencies": {
-		"@types/entities": "latest",
-		"@types/he": "latest",
 		"@types/node": "latest",
 		"@typescript-eslint/eslint-plugin": "latest",
-		"@typescript-eslint/eslint-plugin-tslint": "latest",
 		"@typescript-eslint/parser": "latest",
 		"blanket": "latest",
 		"boolbase": "^1.0.0",
-		"cheerio": "^1.0.0-rc.12",
+		"cheerio": "^1.2.0",
 		"cross-env": "^7.0.3",
 		"eslint": "^8.23.1",
 		"eslint-config-prettier": "latest",
 		"eslint-plugin-import": "latest",
 		"high5": "^1.0.0",
-		"html-dom-parser": "^3.1.2",
+		"html-dom-parser": "^8.0.0",
 		"html-parser": "^0.11.0",
-		"html5parser": "^2.0.2",
-		"htmljs-parser": "^5.1.4",
+		"html5parser": "^3.0.0",
+		"htmljs-parser": "^5.10.2",
 		"htmlparser": "^1.7.7",
 		"htmlparser-benchmark": "^1.1.3",
 		"htmlparser2": "^8.0.1",
-		"mocha": "latest",
+		"mocha": "^11.7.6",
 		"mocha-each": "^2.0.1",
 		"neutron-html5parser": "^0.2.0",
 		"np": "latest",
-		"parse5": "^7.1.1",
+		"parse5": "^8.0.1",
 		"rimraf": "^3.0.2",
 		"saxes": "^6.0.0",
 		"should": "latest",
@@ -87,8 +90,9 @@
 		"standard-version": "^9.5.0",
 		"travis-cov": "latest",
 		"ts-node": "^10.9.1",
-		"typescript": "latest",
-		"yarn": "^1.22.22"
+		"tsdown": "^0.22.3",
+		"@typescript/native": "npm:typescript@^7.0.2",
+		"typescript": "npm:@typescript/typescript6@^6.0.2"
 	},
 	"config": {
 		"blanket": {
@@ -112,5 +116,6 @@
 		"url": "https://github.com/taoqf/node-fast-html-parser/issues"
 	},
 	"homepage": "https://github.com/taoqf/node-fast-html-parser",
-	"sideEffects": false
+	"sideEffects": false,
+	"packageManager": "bun@1.3.14"
 }

package/package.json

@@ -63,7 +63,7 @@
     "@stylistic/eslint-plugin": "^2",
     "@types/aws-lambda": "^8.10.164",
     "@types/jest": "^30.0.0",
-    "@types/jsdom": "^28.0.3",
+    "@types/jsdom": "^30.0.0",
     "@types/node": "^24",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
@@ -95,7 +95,7 @@
     "@mavogel/mvc-projen": "^0.0.50",
     "cdk-nag": "^3.0.1",
     "constructs": "^10.5.1",
-    "node-html-parser": "^7.1.0"
+    "node-html-parser": "^9.0.0"
   },
   "bundledDependencies": [
     "node-html-parser"
@@ -122,7 +122,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.123",
+  "version": "0.0.124",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/node_modules/he/LICENSE-MIT.txt

@@ -1,20 +0,0 @@
-Copyright Mathias Bynens <https://mathiasbynens.be/>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.