cizgile 0.1.0 → 0.2.0

package/dist/shared/locales-latin-Bm94HAeL.mjs

@@ -0,0 +1,595 @@
+//#region src/transliterate/latin.ts
+/** Latin letters with no decomposition (`ß`, `Æ`, `Ł`, `Þ`, `Ə`, ...) and the modifier letters that are dropped. */
+const latin = {
+	Æ: "AE",
+	æ: "ae",
+	Ø: "O",
+	ø: "o",
+	Ǿ: "O",
+	ǿ: "o",
+	Ð: "D",
+	ð: "d",
+	Þ: "TH",
+	þ: "th",
+	ß: "ss",
+	ẞ: "SS",
+	Œ: "OE",
+	œ: "oe",
+	Ł: "L",
+	ł: "l",
+	Đ: "D",
+	đ: "d",
+	ı: "i",
+	İ: "I",
+	Ħ: "H",
+	ħ: "h",
+	Ŧ: "T",
+	ŧ: "t",
+	Ŋ: "NG",
+	ŋ: "ng",
+	ĸ: "k",
+	ſ: "s",
+	IJ: "IJ",
+	ij: "ij",
+	Ə: "E",
+	ə: "e",
+	Ɛ: "E",
+	ɛ: "e",
+	Ɔ: "O",
+	ɔ: "o",
+	Ƶ: "Z",
+	ƶ: "z",
+	Ǥ: "G",
+	ǥ: "g",
+	Ƀ: "B",
+	ƀ: "b",
+	Ɨ: "I",
+	ɨ: "i",
+	Ʉ: "U",
+	ʉ: "u",
+	Ɍ: "R",
+	ɍ: "r",
+	Ⱥ: "A",
+	ⱥ: "a",
+	Ȼ: "C",
+	ȼ: "c",
+	Ɇ: "E",
+	ɇ: "e",
+	Ꝺ: "D",
+	ꝺ: "d",
+	Ƒ: "F",
+	ƒ: "f",
+	Ɓ: "B",
+	ɓ: "b",
+	Ɗ: "D",
+	ɗ: "d",
+	Ƙ: "K",
+	ƙ: "k",
+	Ƴ: "Y",
+	ƴ: "y",
+	Ʃ: "SH",
+	ʃ: "sh",
+	Ʒ: "ZH",
+	ʒ: "zh",
+	Ǝ: "E",
+	ǝ: "e",
+	Ɣ: "GH",
+	ɣ: "gh",
+	Ɩ: "I",
+	ɩ: "i",
+	Ʊ: "U",
+	ʊ: "u",
+	ʔ: "",
+	ʼ: "",
+	ʻ: "",
+	ʹ: "",
+	ʺ: "",
+	ʽ: "",
+	ʾ: "",
+	ʿ: "",
+	ˈ: "",
+	ˌ: ""
+};
+
+//#endregion
+//#region src/transliterate/symbols.ts
+/** Symbols spelled out in English (`&`, `©`, currency signs) or turned into separators (dashes, quotes, bullets). */
+const symbols = {
+	"&": " and ",
+	"©": " c ",
+	"®": " r ",
+	"™": " tm ",
+	"℠": " sm ",
+	"♥": " love ",
+	"❤": " love ",
+	"🦄": " unicorn ",
+	"€": " euro ",
+	"£": " pound ",
+	"¥": " yen ",
+	"¢": " cent ",
+	"₺": " lira ",
+	"₹": " rupee ",
+	"₽": " ruble ",
+	"₩": " won ",
+	"₪": " shekel ",
+	"₫": " dong ",
+	"₴": " hryvnia ",
+	"₦": " naira ",
+	"฿": " baht ",
+	"₿": " bitcoin ",
+	"₱": " peso ",
+	"₸": " tenge ",
+	"₾": " lari ",
+	"₮": " tugrik ",
+	"₼": " manat ",
+	"₡": " colon ",
+	"₲": " guarani ",
+	"₭": " kip ",
+	"₨": " rupee ",
+	"‰": " permille ",
+	"°": " deg ",
+	"№": " no ",
+	µ: " u ",
+	"×": " x ",
+	"∞": " infinity ",
+	"∑": " sum ",
+	"√": " sqrt ",
+	π: " pi ",
+	"§": " section ",
+	"¶": " paragraph ",
+	"†": " ",
+	"‡": " ",
+	"•": " ",
+	"…": " ",
+	"–": " ",
+	"—": " ",
+	"«": " ",
+	"»": " ",
+	"“": " ",
+	"”": " ",
+	"„": " ",
+	"‘": "",
+	"’": "",
+	"‚": "",
+	"‛": "",
+	"‹": " ",
+	"›": " ",
+	"¿": " ",
+	"¡": " ",
+	"′": " ",
+	"″": " "
+};
+
+//#endregion
+//#region src/transliterate/core.ts
+/** The tables every call consults last: `latin`, then `symbols`. */
+const DEFAULT_TABLES = [latin, symbols];
+const NON_ASCII = /[^\x00-\x7F]/;
+let tableIds;
+let nextTableId = 0;
+let compiledByArray;
+let compiledByKey;
+function codePointCount(text) {
+	let count = 0;
+	for (const _ of text) count += 1;
+	return count;
+}
+function tableId(table) {
+	tableIds ??= /* @__PURE__ */ new WeakMap();
+	let id = tableIds.get(table);
+	if (id === void 0) {
+		id = nextTableId;
+		nextTableId += 1;
+		tableIds.set(table, id);
+	}
+	return id;
+}
+function build(tables) {
+	const map = /* @__PURE__ */ new Map();
+	const multi = [];
+	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]);
+	}
+	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,
+		ascii: asciiKeys.length === 0 ? void 0 : new RegExp(`[${asciiKeys.map((k) => k.replace(/[\]\\^-]/g, "\\$&")).join("")}]`, "g"),
+		folded: /* @__PURE__ */ new Map()
+	};
+}
+function compileTables(tables) {
+	compiledByArray ??= /* @__PURE__ */ new WeakMap();
+	const byArray = compiledByArray.get(tables);
+	if (byArray !== void 0) return byArray;
+	compiledByKey ??= /* @__PURE__ */ new Map();
+	const key = tables.map(tableId).join(",");
+	let compiled = compiledByKey.get(key);
+	if (compiled === void 0) {
+		compiled = build(tables);
+		if (compiledByKey.size > 256) compiledByKey.clear();
+		compiledByKey.set(key, compiled);
+	}
+	compiledByArray.set(tables, compiled);
+	return compiled;
+}
+/** The table list a `transliterate` call would consult, in lookup order. */
+function resolveTables(options) {
+	const out = [];
+	if (options.locale !== void 0) {
+		out.push(options.locale.table);
+		if (options.locale.tables !== void 0) out.push(...options.locale.tables);
+	}
+	if (options.tables !== void 0) out.push(...options.tables);
+	out.push(...DEFAULT_TABLES);
+	return out;
+}
+/** The first table value for `key`, or `undefined`. */
+function lookup(tables, key) {
+	for (const table of tables) {
+		const value = table[key];
+		if (value !== void 0) return value;
+	}
+}
+/** Removes combining marks: `"é"` becomes `"e"`, `"ǿ"` becomes `"ø"`. */
+function stripMarks(input) {
+	return input.normalize("NFD").replace(/\p{M}+/gu, "").normalize("NFC");
+}
+const MARK = /^\p{M}+$/u;
+function foldPieces(ch, map) {
+	const decomposed = ch.normalize("NFD");
+	if (decomposed !== ch) {
+		let out = "";
+		let complete = true;
+		for (const piece of decomposed) {
+			const value = map.get(piece);
+			if (value === void 0) {
+				complete = false;
+				break;
+			}
+			out += value;
+		}
+		if (complete) return out;
+	}
+	const base = stripMarks(ch);
+	if (base === ch) return null;
+	const mapped = map.get(base);
+	if (mapped !== void 0) return mapped;
+	return (base.codePointAt(0) ?? 128) < 128 ? base : null;
+}
+function foldChar(ch, compiled) {
+	const cached = compiled.folded.get(ch);
+	if (cached !== void 0) return cached;
+	const value = foldPieces(ch, compiled.map);
+	if (compiled.folded.size > 8192) compiled.folded.clear();
+	compiled.folded.set(ch, value);
+	return value;
+}
+/** The transliteration core: applies `tables` to NFC text, folding marks unless told not to. */
+function fold(input, tables, dropUnknown, foldMarks = true) {
+	const compiled = "sequences" in tables ? tables : compileTables(tables);
+	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);
+	if (compiled.sequences.length > 0) {
+		for (const [key, value] of compiled.sequences) if (text.includes(key)) text = text.split(key).join(value);
+	}
+	let out = "";
+	let kept = false;
+	for (const ch of text) {
+		const direct = map.get(ch);
+		if (direct !== void 0) {
+			out += direct;
+			kept = false;
+			continue;
+		}
+		if ((ch.codePointAt(0) ?? 0) < 128) {
+			out += ch;
+			kept = false;
+			continue;
+		}
+		if (foldMarks && MARK.test(ch)) {
+			if (kept && !dropUnknown) out += ch;
+			continue;
+		}
+		const folded = foldMarks ? foldChar(ch, compiled) : null;
+		if (folded !== null) {
+			out += folded;
+			kept = false;
+			continue;
+		}
+		if (!dropUnknown) out += ch;
+		kept = !dropUnknown;
+	}
+	return out;
+}
+let compatCache;
+function compatEntries(table) {
+	compatCache ??= /* @__PURE__ */ new WeakMap();
+	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]);
+	compatCache.set(table, out);
+	return out;
+}
+/** Applies the table entries whose keys NFKC would split, so a ligature gets its table value before normalisation. */
+function applyCompat(text, tables) {
+	let out = text;
+	for (const table of tables) for (const [key, value] of compatEntries(table)) if (out.includes(key)) out = out.split(key).join(value);
+	return out;
+}
+/** Replaces non-ASCII letters with ASCII from the tables and the mark-stripping fallback. Characters no table knows are kept whole, marks included, or dropped with `unknown: "drop"`. */
+function transliterate(input, options = {}) {
+	const tables = resolveTables(options);
+	let text = input.normalize("NFC");
+	if (options.nfkc === true && NON_ASCII.test(text)) text = applyCompat(text, tables).normalize("NFKC");
+	return fold(text, tables, options.unknown === "drop");
+}
+
+//#endregion
+//#region src/transliterate/locales-latin.ts
+function turkishLowercase(input) {
+	return input.toLocaleLowerCase("tr");
+}
+/** German: `ä ö ü` become `ae oe ue`, `ß` becomes `ss`, `&` becomes `und`. */
+const de = {
+	id: "de",
+	table: {
+		Ä: "Ae",
+		ä: "ae",
+		Ö: "Oe",
+		ö: "oe",
+		Ü: "Ue",
+		ü: "ue",
+		ß: "ss",
+		ẞ: "SS",
+		"&": " und "
+	}
+};
+/** Turkish: dotted and dotless i, `ğ ş ç ö ü` stripped, `&` becomes `ve`; lowercases with the Turkish rules. */
+const tr = {
+	id: "tr",
+	table: {
+		ı: "i",
+		İ: "I",
+		Ğ: "G",
+		ğ: "g",
+		Ş: "S",
+		ş: "s",
+		Ç: "C",
+		ç: "c",
+		Ö: "O",
+		ö: "o",
+		Ü: "U",
+		ü: "u",
+		"&": " ve "
+	},
+	lowercase: turkishLowercase
+};
+/** Azerbaijani: the Turkish letters plus `ə`, `&` becomes `ve`. */
+const az = {
+	id: "az",
+	table: {
+		ı: "i",
+		İ: "I",
+		Ğ: "G",
+		ğ: "g",
+		Ş: "S",
+		ş: "s",
+		Ç: "C",
+		ç: "c",
+		Ö: "O",
+		ö: "o",
+		Ü: "U",
+		ü: "u",
+		Ə: "E",
+		ə: "e",
+		"&": " ve "
+	},
+	lowercase: turkishLowercase
+};
+/** Danish: `ø å æ` become `oe aa ae`, `&` becomes `og`. */
+const da = {
+	id: "da",
+	table: {
+		Ø: "Oe",
+		ø: "oe",
+		Å: "Aa",
+		å: "aa",
+		Æ: "Ae",
+		æ: "ae",
+		"&": " og "
+	}
+};
+/** Norwegian Bokmål: `ø å æ` become `oe aa ae`, `&` becomes `og`. */
+const nb = {
+	id: "nb",
+	table: {
+		Ø: "Oe",
+		ø: "oe",
+		Å: "Aa",
+		å: "aa",
+		Æ: "Ae",
+		æ: "ae",
+		"&": " og "
+	}
+};
+/** Swedish: `ä ö å` become `ae oe aa`, `&` becomes `och`. */
+const sv = {
+	id: "sv",
+	table: {
+		Ä: "Ae",
+		ä: "ae",
+		Ö: "Oe",
+		ö: "oe",
+		Å: "Aa",
+		å: "aa",
+		"&": " och "
+	}
+};
+/** Finnish: `ä ö å` become `ae oe aa`, `&` becomes `ja`. */
+const fi = {
+	id: "fi",
+	table: {
+		Ä: "Ae",
+		ä: "ae",
+		Ö: "Oe",
+		ö: "oe",
+		Å: "Aa",
+		å: "aa",
+		"&": " ja "
+	}
+};
+/** Hungarian: `&` becomes `es`. */
+const hu = {
+	id: "hu",
+	table: { "&": " es " }
+};
+/** Vietnamese: `đ` becomes `d`, `&` becomes `va`. */
+const vi = {
+	id: "vi",
+	table: {
+		Đ: "D",
+		đ: "d",
+		"&": " va "
+	}
+};
+/** Spanish: `ñ` becomes `n`, `&` becomes `y`. */
+const es = {
+	id: "es",
+	table: {
+		Ñ: "N",
+		ñ: "n",
+		"&": " y "
+	}
+};
+/** French: `œ æ` become `oe ae`, `&` becomes `et`. */
+const fr = {
+	id: "fr",
+	table: {
+		Œ: "Oe",
+		œ: "oe",
+		Æ: "Ae",
+		æ: "ae",
+		"&": " et "
+	}
+};
+/** Portuguese: `&` becomes `e`. */
+const pt = {
+	id: "pt",
+	table: { "&": " e " }
+};
+/** Italian: `&` becomes `e`. */
+const it = {
+	id: "it",
+	table: { "&": " e " }
+};
+/** Dutch: `ij` becomes `ij`, `&` becomes `en`. */
+const nl = {
+	id: "nl",
+	table: {
+		IJ: "IJ",
+		ij: "ij",
+		"&": " en "
+	}
+};
+/** Polish: `&` becomes `i`. */
+const pl = {
+	id: "pl",
+	table: { "&": " i " }
+};
+/** Romanian: `&` becomes `si`. */
+const ro = {
+	id: "ro",
+	table: { "&": " si " }
+};
+/** Czech: `&` becomes `a`. */
+const cs = {
+	id: "cs",
+	table: { "&": " a " }
+};
+/** Slovak: `&` becomes `a`. */
+const sk = {
+	id: "sk",
+	table: { "&": " a " }
+};
+/** Slovenian: `&` becomes `in`. */
+const sl = {
+	id: "sl",
+	table: { "&": " in " }
+};
+/** Croatian: `&` becomes `i`. */
+const hr = {
+	id: "hr",
+	table: { "&": " i " }
+};
+/** Icelandic: `þ ð` become `th d`, `&` becomes `og`. */
+const is = {
+	id: "is",
+	table: {
+		Þ: "Th",
+		þ: "th",
+		Ð: "D",
+		ð: "d",
+		"&": " og "
+	}
+};
+/** Estonian: `&` becomes `ja`. */
+const et = {
+	id: "et",
+	table: { "&": " ja " }
+};
+/** Latvian: `&` becomes `un`. */
+const lv = {
+	id: "lv",
+	table: { "&": " un " }
+};
+/** Lithuanian: `&` becomes `ir`. */
+const lt = {
+	id: "lt",
+	table: { "&": " ir " }
+};
+/** Catalan: the punt volat in `l·l` is dropped, `&` becomes `i`. */
+const ca = {
+	id: "ca",
+	table: {
+		"·": "",
+		"&": " i "
+	}
+};
+/** The Latin-script locales by id; these ship with the main entry. */
+const latinLocales = {
+	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
+};
+
+//#endregion
+export { fold as A, sl as C, DEFAULT_TABLES as D, vi as E, symbols as F, latin as I, resolveTables as M, stripMarks as N, applyCompat as O, transliterate as P, sk as S, tr as T, nb as _, de as a, pt as b, fi as c, hu as d, is as f, lv as g, lt as h, da as i, lookup as j, compileTables as k, fr as l, latinLocales as m, ca as n, es as o, it as p, cs as r, et as s, az as t, hr as u, nl as v, sv as w, ro as x, pl as y };