urlpurify 2.2.0 → 2.3.0

package/dist/unwraps/xiaoyuzhou.mjs

@@ -1,7 +1,7 @@
 import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
 import { getPathTarget } from "../pathTarget.mjs";
 // src/unwraps/xiaoyuzhou.ts
-const prefixRegex = /^\/track\/[0-9a-f]{24}\/[0-9a-f]{24}\/(?=media\.xyzcdn\.net\/)/;
+const prefixRegex = /^\/track\/[0-9a-f]{24}\/[0-9a-f]{24}\/(?=media\.xyzcdn\.net\/)/i;
 const unwrapXiaoyuzhou = (url) => {
 	if (!isHostOf(url, "dts-api.xiaoyuzhoufm.com")) return;
 	return getPathTarget(url, prefixRegex);

package/dist/unwraps/ximalaya.mjs

@@ -1,3 +1,4 @@
+import { parseUrl } from "../node_modules/trousse/dist/urls.mjs";
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/ximalaya.ts
 const filePathRegex = /^\/\/[^/]+$/;
@@ -10,8 +11,7 @@ const unwrapXimalaya = (url) => {
 	if (!filePathRegex.test(url.pathname)) return;
 	const target = extractTarget(url);
 	if (!target) return;
-	try {
-		if (targetHostRegex.test(new URL(target).hostname)) return target;
-	} catch {}
+	const targetHost = parseUrl(target)?.hostname;
+	if (targetHost && targetHostRegex.test(targetHost)) return target;
 };
 export { unwrapXimalaya };

package/dist/unwraps/xingShare.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapXingShare: UrlUnwrapper;

package/dist/unwraps/xingShare.mjs

@@ -0,0 +1,16 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { isHostOf, parseUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { getParamTarget, getParamValues } from "../utils.mjs";
+// src/unwraps/xingShare.ts
+const hosts = ["www.xing.com", "xing.com"];
+const sharePathRegex = /^\/(?:spi\/shares\/new|social_plugins\/share(?:\/new)?|social\/share\/spi)\/?$/i;
+const appPathRegex = /^\/app\/user\/?$/i;
+const unwrapXingShare = (url) => {
+	if (!isHostOf(url, hosts)) return;
+	if (isAnyOf(url.pathname, sharePathRegex)) return getParamTarget(url, "url");
+	if (!isAnyOf(url.pathname, appPathRegex)) return;
+	const query = parseUrl(url.href.replace(url.search, () => url.search.replaceAll(";", "&")));
+	if (!query || getParamValues(query, "op").at(0) !== "share") return;
+	return getParamTarget(query, "url");
+};
+export { unwrapXingShare };

package/dist/unwraps/yahooBookmarks.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapYahooBookmarks: UrlUnwrapper;

package/dist/unwraps/yahooBookmarks.mjs

@@ -0,0 +1,38 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { createParamExtractor, getParamTarget } from "../utils.mjs";
+// src/unwraps/yahooBookmarks.ts
+const submitPathRegex = /^\/submit\/?$/i;
+const unwrapBookmarklet = createParamExtractor({
+	hosts: [
+		"bookmarks.yahoo.com",
+		"myweb2.search.yahoo.com",
+		"myweb.yahoo.com"
+	],
+	path: "/myresults/bookmarklet",
+	params: ["u"]
+});
+const unwrapToolbar = createParamExtractor({
+	hosts: "bookmarks.yahoo.com",
+	path: "/toolbar/savebm",
+	params: ["u"]
+});
+const unwrapBuzz = createParamExtractor({
+	hosts: [
+		"buzz.yahoo.com",
+		"fr.buzz.yahoo.com",
+		"uk.buzz.yahoo.com"
+	],
+	path: "/buzz",
+	params: ["targetUrl", "guid"]
+});
+const unwrapBuzzSubmit = (url) => {
+	if (!isHostOf(url, "buzz.yahoo.com") || !isAnyOf(url.pathname, submitPathRegex)) return;
+	const submitUrl = getParamTarget(url, "submitUrl");
+	if (submitUrl && isHttpUrl(submitUrl)) return submitUrl;
+	return getParamTarget(url, "u");
+};
+const unwrapYahooBookmarks = (url) => {
+	return unwrapBookmarklet(url) ?? unwrapToolbar(url) ?? unwrapBuzz(url) ?? unwrapBuzzSubmit(url);
+};
+export { unwrapYahooBookmarks };

package/dist/unwraps/yahooJapan.mjs

@@ -1,7 +1,6 @@
-import { isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
-import { decodeBase64Url } from "../utils.mjs";
+import { decodeBase64Url, isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
 // src/unwraps/yahooJapan.ts
-const pathRegex = /^(?:\/[^/]+)*\/RU=([\w-]+)(?:\/R[A-Z]=[^/]*)*(?:;.*)?$/;
+const pathRegex = /^(?:\/[^/]+)*\/RU=([\w-]+)(?:\/R[A-Z]=[^/]*)*(?:;.*)?$/i;
 const paddingRegex = /-+$/;
 const unwrapYahooJapan = (url) => {
 	if (!isHostOf(url, "rdsig.yahoo.co.jp")) return;

package/dist/unwraps/yahooJapanAmpViewer.mjs

@@ -1,7 +1,7 @@
 import { decodePercent, isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
 // src/unwraps/yahooJapanAmpViewer.ts
-const httpsPathRegex = /^\/amp\/s\/(.+)$/;
-const httpPathRegex = /^\/amp\/(?!s\/)(.+)$/;
+const httpsPathRegex = /^\/amp\/s\/(.+)$/i;
+const httpPathRegex = /^\/amp\/(?!s\/)(.+)$/i;
 const unwrapYahooJapanAmpViewer = (url) => {
 	if (!isHostOf(url, "search.yahoo.co.jp")) return;
 	const httpsMatch = httpsPathRegex.exec(url.pathname);

package/dist/unwraps/yahooMailImage.mjs

@@ -1,7 +1,8 @@
 import { decodePercent, getQueryParamValues, isHostOf } from "../node_modules/trousse/dist/urls.mjs";
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
 // src/unwraps/yahooMailImage.ts
 const unwrapYahooMailImage = (url) => {
-	if (!isHostOf(url, "ecp.yusercontent.com") || url.pathname !== "/mail") return;
+	if (!isHostOf(url, "ecp.yusercontent.com") || !isAnyOf(url.pathname, "/mail")) return;
 	const value = getQueryParamValues(url, "url", { decodeValues: false }).at(-1);
 	if (!value) return;
 	return decodePercent(value);

package/dist/unwraps/yahooSearch.mjs

@@ -6,8 +6,8 @@ const hosts = [
 	"ri.search.yahoo.com",
 	"chicagotribune.search.yahoo.com"
 ];
-const yahooPathRegex = /^(?:\/[^/]+)*\/RU=([^/]+)\/RK=/;
-const unencodedTargetRegex = /^(?:\/[^/]+)*\/RU=(https?:\/\/.+?)\/RK=/;
+const yahooPathRegex = /^(?:\/[^/]+)*\/RU=([^/]+)\/RK=/i;
+const unencodedTargetRegex = /^(?:\/[^/]+)*\/RU=(https?:\/\/.+?)\/RK=/i;
 const unwrapYahooSearch = (url) => {
 	if (!isHostOf(url, hosts)) return;
 	const match = url.pathname.match(yahooPathRegex);

package/dist/unwraps/yamm.mjs

@@ -1,8 +1,9 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
 import { getParamTarget } from "../utils.mjs";
 // src/unwraps/yamm.ts
 const hostRegex = /^(?:[a-z0-9-]+-dot-)?yamm-track\.appspot\.com$/;
 const unwrapYamm = (url) => {
-	if (!hostRegex.test(url.hostname) || url.pathname !== "/Redirect") return;
+	if (!hostRegex.test(url.hostname) || !isAnyOf(url.pathname, "/Redirect")) return;
 	return getParamTarget(url, "link", -1);
 };
 export { unwrapYamm };

package/dist/unwraps/yandexMail.mjs

@@ -1,9 +1,10 @@
-import { isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
-import { decodeBase64Url, getParamValues } from "../utils.mjs";
+import { decodeBase64Url, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { getParamValues } from "../utils.mjs";
 // src/unwraps/yandexMail.ts
 const hostRegex = /^mail\.yandex\.(?:com\.tr|[a-z]{2,3})$/;
 const unwrapYandexMail = (url) => {
-	if (!hostRegex.test(url.hostname) || url.pathname !== "/re.jsx") return;
+	if (!hostRegex.test(url.hostname) || !isAnyOf(url.pathname, "/re.jsx")) return;
 	const value = getParamValues(url, "l").at(0);
 	if (!value) return;
 	const decoded = decodeBase64Url(value);

package/dist/unwraps/yandexTranslate.mjs

@@ -1,6 +1,6 @@
 import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
 // src/unwraps/yandexTranslate.ts
-const proxyPathRegex = /^\/proxy_u\/[^/]+\/(?:(?<scheme>https?)\/)?(?<target>.+)$/;
+const proxyPathRegex = /^\/proxy_u\/[^/]+\/(?:(?<scheme>https?)\/)?(?<target>.+)$/i;
 const unwrapYandexTranslate = (url) => {
 	if (!isHostOf(url, "translated.turbopages.org")) return;
 	const match = url.pathname.match(proxyPathRegex);

package/dist/unwraps/yandexTurbo.mjs

@@ -1,10 +1,10 @@
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/yandexTurbo.ts
 const turbopagesHostRegex = /\.turbopages\.org$/;
-const turbopagesPathRegex = /^\/[^/]+\/s\/(.+)$/;
-const hostInPathRegex = /^\/turbo\/([^/]+)\/s\/(.+)$/;
-const yandexSlashSFirstRegex = /^\/turbo\/s\/([^/]+)\/(.*)$/;
-const turbopagesSlashSFirstRegex = /^\/s\/([^/]+)\/(.*)$/;
+const turbopagesPathRegex = /^\/[^/]+\/s\/(.+)$/i;
+const hostInPathRegex = /^\/turbo\/([^/]+)\/s\/(.+)$/i;
+const yandexSlashSFirstRegex = /^\/turbo\/s\/([^/]+)\/(.*)$/i;
+const turbopagesSlashSFirstRegex = /^\/s\/([^/]+)\/(.*)$/i;
 const dashRegex = /-/g;
 const yandexHostRegex = /^(?:www\.)?yandex\.(?:com\.tr|[a-z]{2,3})$/;
 const extractTurboTarget = createParamExtractor({

package/dist/unwraps/yesware.mjs

@@ -1,8 +1,8 @@
 import { isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/yesware.ts
-const trackPathRegex = /^\/tt\/[\da-f]{40}\/[\da-f]{32}\/[\da-f]{32}\/(.+)$/;
-const linkPathRegex = /^\/tl\/[\da-f]{40}\/[\da-f]{32}\/[\da-f]{32}$/;
+const trackPathRegex = /^\/tt\/[\da-f]{40}\/[\da-f]{32}\/[\da-f]{32}\/(.+)$/i;
+const linkPathRegex = /^\/tl\/[\da-f]{40}\/[\da-f]{32}\/[\da-f]{32}$/i;
 const extractLinkTarget = createParamExtractor({
 	hosts: "t.yesware.com",
 	params: ["ytl"]

package/dist/unwraps/yourMembership.mjs

@@ -1,10 +1,11 @@
-import { decodePercent, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { decodePercent, getQueryParam, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
 import { getParamValues } from "../utils.mjs";
 // src/unwraps/yourMembership.ts
 const ymlinkRegex = /^\d+$/;
 const encodedSchemeRegex = /^https?%3A/i;
 const unwrapYourMembership = (url) => {
-	if (url.pathname !== "/link.asp" || !ymlinkRegex.test(url.searchParams.get("ymlink") ?? "")) return;
+	if (!isAnyOf(url.pathname, "/link.asp") || !ymlinkRegex.test(getQueryParam(url, "ymlink") ?? "")) return;
 	let target = getParamValues(url, "finalurl").at(0);
 	if (target && encodedSchemeRegex.test(target)) target = decodePercent(target);
 	if (target && isHttpUrl(target)) return target;

package/dist/unwraps/zencastr.mjs

@@ -1,7 +1,7 @@
 import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
 import { getPathTarget } from "../pathTarget.mjs";
 // src/unwraps/zencastr.ts
-const redirectPrefixRegex = /^\/r\//;
+const redirectPrefixRegex = /^\/r\//i;
 const unwrapZencastr = (url) => {
 	if (!isHostOf(url, ["r.zencastr.com", "r.zen.ai"])) return;
 	return getPathTarget(url, redirectPrefixRegex);

package/dist/unwraps/zix.mjs

@@ -1,6 +1,6 @@
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/zix.ts
-const linkPathRegex = /^\/u\/[0-9a-f]{8}\/[A-Za-z0-9_-]+$/;
+const linkPathRegex = /^\/u\/[0-9a-f]{8}\/[A-Za-z0-9_-]+$/i;
 const extractTarget = createParamExtractor({
 	hosts: "link.zixcentral.com",
 	params: ["u"]

package/dist/unwraps/zscalerIsolation.mjs

@@ -1,6 +1,6 @@
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/zscalerIsolation.ts
-const sessionPathRegex = /^\/profile\/[0-9a-f-]{36}\/zia-session\/$/;
+const sessionPathRegex = /^\/profile\/[0-9a-f-]{36}\/zia-session\/$/i;
 const extractTarget = createParamExtractor({
 	hosts: /^[0-9a-f]{8}\.isolation\.zscaler\.com$/,
 	params: ["original_url"]

package/dist/utils.mjs

@@ -1,5 +1,5 @@
-import { isAnyOf } from "./node_modules/trousse/dist/matching.mjs";
 import { decodePercent, getQueryParamValues, isHostOf, isHostOrSubdomainOf } from "./node_modules/trousse/dist/urls.mjs";
+import { isAnyOf } from "./node_modules/trousse/dist/matching.mjs";
 // src/utils.ts
 const encodedSchemeRegex = /^https?%3A/i;
 const decodeEncodedScheme = (value) => {
@@ -7,20 +7,15 @@ const decodeEncodedScheme = (value) => {
 	return decodePercent(value);
 };
 const unencodedTargetRegex = /^https?:\/\//i;
+const decodeParamValue = (raw) => {
+	if (!unencodedTargetRegex.test(raw)) return decodePercent(raw.replaceAll("+", " "));
+	return decodePercent(raw);
+};
 const getParamValues = (url, name) => {
-	const values = [];
-	const raws = getQueryParamValues(url, name, {
+	return getQueryParamValues(url, name, {
 		decodeValues: false,
 		preserveEmptyValues: true
-	});
-	for (const raw of raws) {
-		if (!unencodedTargetRegex.test(raw)) {
-			values.push(decodePercent(raw.replaceAll("+", " ")));
-			continue;
-		}
-		values.push(decodePercent(raw));
-	}
-	return values;
+	}).map(decodeParamValue);
 };
 const getParamTarget = (url, name, index = 0) => {
 	const value = getParamValues(url, name).at(index);
@@ -35,43 +30,15 @@ const createParamExtractor = (config) => {
 	};
 	return (url) => {
 		if (!isHostMatch(url)) return;
-		if (config.path && url.pathname !== config.path) return;
+		if (config.path && !isAnyOf(url.pathname, config.path)) return;
 		for (const param of config.params) {
 			const value = getParamValues(url, param).at(0);
 			if (value) return decodeEncodedScheme(value);
 		}
 	};
 };
-const decodeBase64Binary = (value) => {
-	try {
-		return atob(value);
-	} catch {}
-};
-const decodeBase64 = (value) => {
-	const binary = decodeBase64Binary(value);
-	if (binary === void 0) return;
-	let encoded = "";
-	for (let index = 0; index < binary.length; index++) {
-		const byte = binary.charCodeAt(index);
-		if (byte < 128 && binary[index] !== "%") {
-			encoded += binary[index];
-			continue;
-		}
-		encoded += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-	}
-	return decodePercent(encoded);
-};
-const toBase64 = (base64Url) => {
-	return base64Url.replace(/-/g, "+").replace(/_/g, "/");
-};
-const decodeBase64Url = (value) => {
-	return decodeBase64(toBase64(value));
-};
-const decodeBase64UrlBinary = (value) => {
-	return decodeBase64Binary(toBase64(value));
-};
 const utf8Encoder = new TextEncoder();
 const getUtf8ByteLength = (value) => {
 	return utf8Encoder.encode(value).length;
 };
-export { createParamExtractor, decodeBase64, decodeBase64Binary, decodeBase64Url, decodeBase64UrlBinary, decodeEncodedScheme, getParamTarget, getParamValues, getUtf8ByteLength };
+export { createParamExtractor, decodeEncodedScheme, decodeParamValue, getParamTarget, getParamValues, getUtf8ByteLength };

package/package.json

@@ -41,9 +41,9 @@
   },
   "devDependencies": {
     "@types/bun": "^1.4.4",
-    "kvalita": "^1.30.0",
-    "trousse": "^3.2.0",
-    "tsdown": "0.23.4"
+    "kvalita": "^1.39.0",
+    "trousse": "^3.15.0",
+    "tsdown": "0.23.7"
   },
-  "version": "2.2.0"
+  "version": "2.3.0"
 }

package/dist/node_modules/entities/dist/internal/bin-trie-flags.mjs

@@ -1,50 +0,0 @@
-// node_modules/entities/dist/internal/bin-trie-flags.js
-/**
-* 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.
-*/
-var BinTrieFlags;
-(function(BinTrieFlags) {
-	BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
-	BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
-	BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
-	BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
-	/** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */
-	BinTrieFlags[BinTrieFlags["VALUE_MASK"] = 8191] = "VALUE_MASK";
-})(BinTrieFlags || (BinTrieFlags = {}));
-export { BinTrieFlags };

package/dist/node_modules/entities/dist/internal/decode-shared.mjs

@@ -1,143 +0,0 @@
-// node_modules/entities/dist/internal/decode-shared.js
-const BASE91_INVERSE = /* #__PURE__ */ (() => {
-	const table = /* @__PURE__ */ new Uint8Array(127);
-	let code = 0;
-	for (let char = 33; char <= 126; char++) if (char !== 34 && char !== 36 && char !== 92) 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.
-*/
-function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCount, dictSize) {
-	const base = 91;
-	const inputLength = input.length;
-	const twoCharBias = dictSize * 90;
-	let pos = 0;
-	/** Read one slot code at `pos` and return its slot index, advancing pos. */
-	const readSlotCode = () => {
-		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;
-	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, off) {
-		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 + (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;
-			}
-		}
-	}
-	decodeDelta(dict1AtomCount, 0);
-	decodeDelta(dict2AtomCount, dictSize);
-	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, startSlot) {
-		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);
-	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;
-	}
-	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;
-}
-export { decodeTrieDict };