cizgile 0.3.0 → 1.0.0

package/dist/shared/punycode-MAFJqHdd.mjs

@@ -0,0 +1,180 @@
+//#region src/uri/punycode.ts
+const BASE = 36;
+const T_MIN = 1;
+const T_MAX = 26;
+const SKEW = 38;
+const DAMP = 700;
+const INITIAL_BIAS = 72;
+const INITIAL_N = 128;
+const DELIMITER = "-";
+const PREFIX = "xn--";
+const MAX_INT = 2147483647;
+const LABEL_SEPARATORS = /[.\u3002\uFF0E\uFF61]/;
+function adapt(delta, numPoints, firstTime) {
+	let d = firstTime ? Math.floor(delta / DAMP) : delta >> 1;
+	d += Math.floor(d / numPoints);
+	let k = 0;
+	while (d > 455) {
+		d = Math.floor(d / 35);
+		k += BASE;
+	}
+	return k + Math.floor(36 * d / (d + SKEW));
+}
+function digit(value) {
+	return String.fromCodePoint(value + (value < 26 ? 97 : 22));
+}
+function digitValue(cp) {
+	if (cp >= 48 && cp <= 57) return cp - 22;
+	if (cp >= 65 && cp <= 90) return cp - 65;
+	if (cp >= 97 && cp <= 122) return cp - 97;
+	return -1;
+}
+/** RFC 3492 Punycode encoding of one label, without the `xn--` prefix. */
+function punycodeEncode(input) {
+	const points = Array.from(input, (ch) => ch.codePointAt(0) ?? 0);
+	let out = "";
+	for (const cp of points) if (cp < 128) out += String.fromCodePoint(cp);
+	const basicCount = out.length;
+	let handled = basicCount;
+	if (basicCount > 0) out += DELIMITER;
+	let n = INITIAL_N;
+	let delta = 0;
+	let bias = INITIAL_BIAS;
+	while (handled < points.length) {
+		let m = 1114112;
+		for (const cp of points) if (cp >= n && cp < m) m = cp;
+		delta += (m - n) * (handled + 1);
+		n = m;
+		for (const cp of points) {
+			if (cp < n) delta += 1;
+			if (cp === n) {
+				let q = delta;
+				for (let k = BASE;; k += BASE) {
+					const t = k <= bias ? T_MIN : k >= bias + T_MAX ? T_MAX : k - bias;
+					if (q < t) break;
+					out += digit(t + (q - t) % (BASE - t));
+					q = Math.floor((q - t) / (BASE - t));
+				}
+				out += digit(q);
+				bias = adapt(delta, handled + 1, handled === basicCount);
+				delta = 0;
+				handled += 1;
+			}
+		}
+		delta += 1;
+		n += 1;
+	}
+	return out;
+}
+/**
+* RFC 3492 Punycode decoding of one label, without the `xn--` prefix.
+* @throws {RangeError} on malformed input.
+*/
+function punycodeDecode(input) {
+	const output = [];
+	const last = input.lastIndexOf(DELIMITER);
+	const basicEnd = last > 0 ? last : 0;
+	for (let i = 0; i < basicEnd; i++) {
+		const cp = input.codePointAt(i) ?? 0;
+		if (cp >= 128) throw new RangeError("punycodeDecode: invalid basic code point");
+		output.push(cp);
+	}
+	let n = INITIAL_N;
+	let bias = INITIAL_BIAS;
+	let i = 0;
+	let index = basicEnd > 0 ? basicEnd + 1 : 0;
+	while (index < input.length) {
+		const oldI = i;
+		let w = 1;
+		for (let k = BASE;; k += BASE) {
+			if (index >= input.length) throw new RangeError("punycodeDecode: truncated input");
+			const d = digitValue(input.codePointAt(index) ?? 0);
+			index += 1;
+			if (d < 0) throw new RangeError("punycodeDecode: invalid digit");
+			i += d * w;
+			if (i > MAX_INT) throw new RangeError("punycodeDecode: overflow");
+			const t = k <= bias ? T_MIN : k >= bias + T_MAX ? T_MAX : k - bias;
+			if (d < t) break;
+			w *= BASE - t;
+		}
+		const count = output.length + 1;
+		bias = adapt(i - oldI, count, oldI === 0);
+		n += Math.floor(i / count);
+		i %= count;
+		if (n > 1114111) throw new RangeError("punycodeDecode: code point out of range");
+		output.splice(i, 0, n);
+		i += 1;
+	}
+	return String.fromCodePoint(...output);
+}
+function isAsciiLabel(label) {
+	for (const ch of label) if ((ch.codePointAt(0) ?? 0) >= 128) return false;
+	return true;
+}
+function lowercaseCodePoints(text) {
+	let out = "";
+	for (const ch of text) out += ch.toLowerCase();
+	return out;
+}
+function mapLabel(label) {
+	return lowercaseCodePoints(label.replace(/\p{Cf}/gu, "").normalize("NFKC")).normalize("NFC");
+}
+function invalid(fn, label, reason) {
+	return /* @__PURE__ */ new RangeError(`${fn}: label ${JSON.stringify(label)} ${reason}`);
+}
+function decodeLabel(fn, label) {
+	let decoded;
+	try {
+		decoded = punycodeDecode(label.slice(4));
+	} catch {
+		throw invalid(fn, label, "is not valid Punycode");
+	}
+	if (decoded === "" || isAsciiLabel(decoded) || /[\p{C}\p{Z}]/u.test(decoded) || mapLabel(decoded) !== decoded || PREFIX + punycodeEncode(decoded) !== label) throw invalid(fn, label, "is not a valid A-label");
+	return decoded;
+}
+function checkAsciiLabel(fn, label, original) {
+	if (label.length > 63) throw invalid(fn, original, "exceeds 63 octets");
+	if (!/^[a-z0-9-]*$/.test(label)) throw invalid(fn, original, "contains characters outside letters, digits and hyphen");
+	if (label.startsWith("-") || label.endsWith("-")) throw invalid(fn, original, "may not start or end with a hyphen");
+	if (label.startsWith(PREFIX)) decodeLabel(fn, label);
+	else if (label.slice(2, 4) === "--") throw invalid(fn, original, "has hyphens in positions 3 and 4");
+	return label;
+}
+function checkDomain(fn, labels, host) {
+	if (labels.length > 1 && labels[labels.length - 1] === "") labels = labels.slice(0, -1);
+	for (const label of labels) if (label === "") throw invalid(fn, host, "contains an empty label");
+	const out = labels.join(".");
+	if (out.length > 253) throw new RangeError(`${fn}: ${JSON.stringify(host)} exceeds 253 octets`);
+	return out;
+}
+/**
+* Converts a domain to its A-label form: maps and lowercases each label the way UTS #46 does, punycodes the non-ASCII ones, and validates lengths, hyphens and existing `xn--` labels. IP literals pass through.
+* @throws {RangeError} when a label or the domain is not valid.
+*/
+function domainToAscii(host) {
+	if (host === "" || host.startsWith("[")) return host;
+	const out = checkDomain("domainToAscii", host.split(LABEL_SEPARATORS).flatMap((label) => {
+		if (isAsciiLabel(label)) return [checkAsciiLabel("domainToAscii", label.toLowerCase(), label)];
+		const mapped = mapLabel(label);
+		if (mapped.includes(".")) return domainToAscii(mapped).split(".");
+		if (isAsciiLabel(mapped)) return [checkAsciiLabel("domainToAscii", mapped, label)];
+		return [checkAsciiLabel("domainToAscii", PREFIX + punycodeEncode(mapped), label)];
+	}), host);
+	return host.endsWith(".") && out !== "" ? `${out}.` : out;
+}
+/**
+* Converts the `xn--` labels of a domain back to Unicode and lowercases the rest.
+* @throws {RangeError} when an `xn--` label does not decode to a valid U-label.
+*/
+function domainToUnicode(host) {
+	if (host === "" || host.startsWith("[")) return host;
+	const out = checkDomain("domainToUnicode", host.split(".").map((label) => {
+		const lower = label.toLowerCase();
+		if (!isAsciiLabel(lower)) return lower;
+		return lower.startsWith(PREFIX) ? decodeLabel("domainToUnicode", lower) : lower;
+	}), host);
+	return host.endsWith(".") && out !== "" ? `${out}.` : out;
+}
+
+//#endregion
+export { punycodeEncode as i, domainToUnicode as n, punycodeDecode as r, domainToAscii as t };

package/dist/shared/{registry-_m94akct.mjs → registry-D787niCh.mjs}

@@ -182,6 +182,8 @@ const symbols = {
 //#region src/transliterate/core.ts
 /** The tables every call consults last: `latin`, then `symbols`. */
 const DEFAULT_TABLES = [latin, symbols];
+/** A table key that starts with this character is a rule: the rest is a regular expression source (flags `gu`) and the value its replacement, `$1` groups allowed. Rules run in table order, before the sequences and the character lookup; the scripts that reorder or contextualise letters (Thai, Lao, Khmer, Myanmar) use them. */
+const RULE_PREFIX = "
";
 const NON_ASCII = /[^\x00-\x7F]/;
 let tableIds;
 let nextTableId = 0;
@@ -205,17 +207,20 @@ function tableId(table) {
 function build(tables) {
 	const map = /* @__PURE__ */ new Map();
 	const multi = [];
+	const rules = [];
 	for (const table of tables) for (const key of Object.keys(table)) {
 		if (map.has(key)) continue;
 		const value = table[key] ?? "";
 		map.set(key, value);
-		if (codePointCount(key) > 1) multi.push([key, value]);
+		if (key.startsWith("
")) rules.push([new RegExp(key.slice(1), "gu"), value]);
+		else if (codePointCount(key) > 1) multi.push([key, value]);
 	}
 	multi.sort((a, b) => b[0].length - a[0].length);
 	const asciiKeys = [...map.keys()].filter((key) => key.length === 1 && (key.codePointAt(0) ?? 0) < 128);
 	return {
 		map,
 		sequences: multi,
+		rules,
 		ascii: asciiKeys.length === 0 ? void 0 : new RegExp(`[${asciiKeys.map((k) => k.replace(/[\]\\^-]/g, "\\$&")).join("")}]`, "g"),
 		folded: /* @__PURE__ */ new Map()
 	};
@@ -293,6 +298,7 @@ function fold(input, tables, dropUnknown, foldMarks = true) {
 	const map = compiled.map;
 	let text = input;
 	if (!NON_ASCII.test(text)) return compiled.ascii === void 0 ? text : text.replace(compiled.ascii, (m) => map.get(m) ?? m);
+	for (const [pattern, to] of compiled.rules) text = text.replace(pattern, to);
 	if (compiled.sequences.length > 0) {
 		for (const [key, value] of compiled.sequences) if (text.includes(key)) text = text.split(key).join(value);
 	}
@@ -331,7 +337,7 @@ function compatEntries(table) {
 	const cached = compatCache.get(table);
 	if (cached !== void 0) return cached;
 	const out = [];
-	for (const [key, value] of Object.entries(table)) if (key.normalize("NFKC") !== key) out.push([key, value]);
+	for (const [key, value] of Object.entries(table)) if (key.normalize("NFKC") !== key && !key.startsWith("
")) out.push([key, value]);
 	compatCache.set(table, out);
 	return out;
 }

package/dist/shared/{types-B3EVWvDh.d.mts → types-D5P1JMcX.d.mts}

@@ -16,8 +16,8 @@ interface Locale {
 type LatinLocaleId = "az" | "ca" | "cs" | "da" | "de" | "es" | "et" | "fi" | "fr" | "hr" | "hu" | "is" | "it" | "lt" | "lv" | "nb" | "nl" | "pl" | "pt" | "ro" | "sk" | "sl" | "sv" | "tr" | "vi";
 /** Locales that carry the Cyrillic table; import the objects from `cizgile/transliterate`. */
 type CyrillicLocaleId = "be" | "bg" | "kk" | "mk" | "ru" | "sr" | "uk";
-/** Locales that carry the Greek, Hebrew, kana or Hangul table; import the objects from `cizgile/transliterate`. */
-type OtherLocaleId = "bn" | "el" | "gu" | "he" | "hi" | "ja" | "kn" | "ko" | "ml" | "or" | "pa" | "ta" | "te";
+/** Locales that carry a Greek, Hebrew, Indic, Southeast Asian, kana or Hangul table; import the objects from `cizgile/transliterate`. */
+type OtherLocaleId = "bn" | "el" | "gu" | "he" | "hi" | "ja" | "km" | "kn" | "ko" | "lo" | "ml" | "my" | "or" | "pa" | "si" | "ta" | "te" | "th";
 /** Every id in the `locales` registry. */
 type LocaleId = LatinLocaleId | CyrillicLocaleId | OtherLocaleId;
 //#endregion

package/dist/transliterate.d.mts

@@ -1,4 +1,4 @@
-import { a as OtherLocaleId, i as LocaleId, n as LatinLocaleId, o as TransliterationTable, r as Locale, t as CyrillicLocaleId } from "./shared/types-B3EVWvDh.mjs";
+import { a as OtherLocaleId, i as LocaleId, n as LatinLocaleId, o as TransliterationTable, r as Locale, t as CyrillicLocaleId } from "./shared/types-D5P1JMcX.mjs";
 //#region src/transliterate/core.d.ts
 /** Options for `transliterate`. */
 interface TransliterateOptions {
@@ -17,6 +17,7 @@ type Sequences = ReadonlyArray<readonly [string, string]>;
 interface CompiledTables {
   readonly map: ReadonlyMap<string, string>;
   readonly sequences: Sequences;
+  readonly rules: ReadonlyArray<readonly [RegExp, string]>;
   readonly ascii: RegExp | undefined;
   readonly folded: Map<string, string | null>;
 }
@@ -94,14 +95,30 @@ export declare const gurmukhi: TransliterationTable;
 /** Kannada to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
 export declare const kannada: TransliterationTable;
 //#endregion
+//#region src/transliterate/khmer.d.ts
+/** Khmer to Latin in a simple UNGEGN-style scheme: consonants keep one value each, subscript consonants (after the coeng) follow their base, and the vowel signs read as the `a` series (`ក ខ ច ដ ត ប ស ហ អ`...) or the `o` series (`គ ង ជ ទ ន ព ម យ រ ល វ`...) of the base consonant, so `ា` is `a` after `ក` and `ea` after `គ`. A bare consonant after a vowel is read as a final, otherwise it takes its inherent `a` or `o`. There is no dictionary or word segmentation, so `ភ្នំពេញ` is `phnumpenh` and `កម្ពុជា` is `kampuchea`. */
+export declare const khmer: TransliterationTable;
+//#endregion
+//#region src/transliterate/lao.d.ts
+/** Lao to Latin in a simple BGN/PCGN-style scheme, without tone marks: the vowels written before the consonant (`ເ ແ ໂ ໃ ໄ`) are moved after it, a consonant is read as initial or final from its neighbours, and a bare consonant takes `a` or, before the final, `o`. Words are not segmented and there is no dictionary, so `ວຽງຈັນ` is `viangchan` and `ລາວ` is `lao`. */
+export declare const lao: TransliterationTable;
+//#endregion
 //#region src/transliterate/malayalam.d.ts
 /** Malayalam to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
 export declare const malayalam: TransliterationTable;
 //#endregion
+//#region src/transliterate/myanmar.d.ts
+/** Myanmar (Burmese) to Latin in a simple BGN/MLC-style scheme without tone marks: consonants carry an inherent `a` unless a vowel sign, the asat or a stacked consonant follows, the medials read `y`, `w` and `h` (`မြန်မာ` is `myanma`, `ရန်ကုန်` is `yankun`). Aspirates are `hs`, `ht`, `hp`; no sound change between syllables is applied. */
+export declare const myanmar: TransliterationTable;
+//#endregion
 //#region src/transliterate/oriya.d.ts
 /** Oriya to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
 export declare const oriya: TransliterationTable;
 //#endregion
+//#region src/transliterate/sinhala.d.ts
+/** Sinhala to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, the al-lakuna (virama) removes it, no vowel length is marked and no schwa deletion is applied, so `කොළඹ` is `kolamba`. */
+export declare const sinhala: TransliterationTable;
+//#endregion
 //#region src/transliterate/tamil.d.ts
 /** Tamil to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
 export declare const tamil: TransliterationTable;
@@ -110,6 +127,10 @@ export declare const tamil: TransliterationTable;
 /** Telugu to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
 export declare const telugu: TransliterationTable;
 //#endregion
+//#region src/transliterate/thai.d.ts
+/** Thai to Latin after the Royal Thai General System of Transcription, without tone marks and vowel length. The vowels written before the consonant (`เ แ โ ใ ไ`) are moved after it, a consonant is read as initial or final from its neighbours (`ก` is `k` either way, `จ` is `ch` and `t`, `ร` is `r` and `n`), and a bare consonant takes `a` or, before the final, `o`. Words are not segmented and no dictionary is used, so irregular spellings follow those rules: `ไทย` is `thai`, `กรุงเทพ` is `krungthep`. */
+export declare const thai: TransliterationTable;
+//#endregion
 //#region src/transliterate/dhivehi.d.ts
 /** Thaana (Dhivehi) to Latin, the sindresorhus/transliterate values. */
 export declare const dhivehi: TransliterationTable;
@@ -183,6 +204,16 @@ export declare const te: Locale;
 export declare const kn: Locale;
 /** Malayalam: the malayalam table, `&` becomes `um`. */
 export declare const ml: Locale;
+/** Thai: the thai table, `&` becomes `lae`. */
+export declare const th: Locale;
+/** Lao: the lao table, `&` becomes `lae`. */
+export declare const lo: Locale;
+/** Khmer: the khmer table, `&` becomes `ning`. */
+export declare const km: Locale;
+/** Burmese: the myanmar table, `&` becomes `hnin`. */
+export declare const my: Locale;
+/** Sinhala: the sinhala table, `&` becomes `saha`. */
+export declare const si: Locale;
 /** The locales that carry a non-Latin, non-Cyrillic script table, by id. */
 export declare const otherLocales: Readonly<Record<OtherLocaleId, Locale>>;
 //#endregion