cizgile 0.2.0 → 1.0.0

package/dist/shared/{locales-latin-Bm94HAeL.mjs → registry-D787niCh.mjs}

@@ -79,6 +79,24 @@ const latin = {
 	ɩ: "i",
 	Ʊ: "U",
 	ʊ: "u",
+	Ƿ: "W",
+	ƿ: "w",
+	Ȝ: "Gh",
+	ȝ: "gh",
+	Ʌ: "V",
+	ʌ: "v",
+	Ƣ: "Gh",
+	ƣ: "gh",
+	Ȣ: "Ou",
+	ȣ: "ou",
+	Ʈ: "T",
+	ʈ: "t",
+	Ɲ: "N",
+	ɲ: "n",
+	Ƨ: "S",
+	ƨ: "s",
+	Ɂ: "",
+	ɂ: "",
 	ʔ: "",
 	ʼ: "",
 	ʻ: "",
@@ -164,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;
@@ -187,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()
 	};
@@ -275,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);
 	}
@@ -313,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;
 }
@@ -348,6 +372,9 @@ const de = {
 		ü: "ue",
 		ß: "ss",
 		ẞ: "SS",
+		"%": " prozent ",
+		$: " dollar ",
+		"£": " pfund ",
 		"&": " und "
 	}
 };
@@ -367,6 +394,9 @@ const tr = {
 		ö: "o",
 		Ü: "U",
 		ü: "u",
+		"%": " yuzde ",
+		$: " dolar ",
+		"£": " sterlin ",
 		"&": " ve "
 	},
 	lowercase: turkishLowercase
@@ -389,6 +419,9 @@ const az = {
 		ü: "u",
 		Ə: "E",
 		ə: "e",
+		"%": " faiz ",
+		$: " dollar ",
+		"£": " funt ",
 		"&": " ve "
 	},
 	lowercase: turkishLowercase
@@ -403,6 +436,9 @@ const da = {
 		å: "aa",
 		Æ: "Ae",
 		æ: "ae",
+		"%": " procent ",
+		$: " dollar ",
+		"£": " pund ",
 		"&": " og "
 	}
 };
@@ -416,6 +452,9 @@ const nb = {
 		å: "aa",
 		Æ: "Ae",
 		æ: "ae",
+		"%": " prosent ",
+		$: " dollar ",
+		"£": " pund ",
 		"&": " og "
 	}
 };
@@ -429,6 +468,9 @@ const sv = {
 		ö: "oe",
 		Å: "Aa",
 		å: "aa",
+		"%": " procent ",
+		$: " dollar ",
+		"£": " pund ",
 		"&": " och "
 	}
 };
@@ -442,13 +484,21 @@ const fi = {
 		ö: "oe",
 		Å: "Aa",
 		å: "aa",
+		"%": " prosenttia ",
+		$: " dollari ",
+		"£": " punta ",
 		"&": " ja "
 	}
 };
 /** Hungarian: `&` becomes `es`. */
 const hu = {
 	id: "hu",
-	table: { "&": " es " }
+	table: {
+		"%": " szazalek ",
+		$: " dollar ",
+		"£": " font ",
+		"&": " es "
+	}
 };
 /** Vietnamese: `đ` becomes `d`, `&` becomes `va`. */
 const vi = {
@@ -456,6 +506,9 @@ const vi = {
 	table: {
 		Đ: "D",
 		đ: "d",
+		"%": " phan tram ",
+		$: " do la ",
+		"£": " bang ",
 		"&": " va "
 	}
 };
@@ -465,6 +518,9 @@ const es = {
 	table: {
 		Ñ: "N",
 		ñ: "n",
+		"%": " por ciento ",
+		$: " dolar ",
+		"£": " libra ",
 		"&": " y "
 	}
 };
@@ -476,18 +532,31 @@ const fr = {
 		œ: "oe",
 		Æ: "Ae",
 		æ: "ae",
+		"%": " pour cent ",
+		$: " dollar ",
+		"£": " livre ",
 		"&": " et "
 	}
 };
 /** Portuguese: `&` becomes `e`. */
 const pt = {
 	id: "pt",
-	table: { "&": " e " }
+	table: {
+		"%": " por cento ",
+		$: " dolar ",
+		"£": " libra ",
+		"&": " e "
+	}
 };
 /** Italian: `&` becomes `e`. */
 const it = {
 	id: "it",
-	table: { "&": " e " }
+	table: {
+		"%": " per cento ",
+		$: " dollaro ",
+		"£": " sterlina ",
+		"&": " e "
+	}
 };
 /** Dutch: `ij` becomes `ij`, `&` becomes `en`. */
 const nl = {
@@ -495,38 +564,71 @@ const nl = {
 	table: {
 		IJ: "IJ",
 		ij: "ij",
+		"%": " procent ",
+		$: " dollar ",
+		"£": " pond ",
 		"&": " en "
 	}
 };
 /** Polish: `&` becomes `i`. */
 const pl = {
 	id: "pl",
-	table: { "&": " i " }
+	table: {
+		"%": " procent ",
+		$: " dolar ",
+		"£": " funt ",
+		"&": " i "
+	}
 };
 /** Romanian: `&` becomes `si`. */
 const ro = {
 	id: "ro",
-	table: { "&": " si " }
+	table: {
+		"%": " la suta ",
+		$: " dolar ",
+		"£": " lira ",
+		"&": " si "
+	}
 };
 /** Czech: `&` becomes `a`. */
 const cs = {
 	id: "cs",
-	table: { "&": " a " }
+	table: {
+		"%": " procent ",
+		$: " dolar ",
+		"£": " libra ",
+		"&": " a "
+	}
 };
 /** Slovak: `&` becomes `a`. */
 const sk = {
 	id: "sk",
-	table: { "&": " a " }
+	table: {
+		"%": " percent ",
+		$: " dolar ",
+		"£": " libra ",
+		"&": " a "
+	}
 };
 /** Slovenian: `&` becomes `in`. */
 const sl = {
 	id: "sl",
-	table: { "&": " in " }
+	table: {
+		"%": " odstotkov ",
+		$: " dolar ",
+		"£": " funt ",
+		"&": " in "
+	}
 };
 /** Croatian: `&` becomes `i`. */
 const hr = {
 	id: "hr",
-	table: { "&": " i " }
+	table: {
+		"%": " posto ",
+		$: " dolar ",
+		"£": " funta ",
+		"&": " i "
+	}
 };
 /** Icelandic: `þ ð` become `th d`, `&` becomes `og`. */
 const is = {
@@ -536,29 +638,50 @@ const is = {
 		þ: "th",
 		Ð: "D",
 		ð: "d",
+		"%": " prosent ",
+		$: " dollari ",
+		"£": " pund ",
 		"&": " og "
 	}
 };
 /** Estonian: `&` becomes `ja`. */
 const et = {
 	id: "et",
-	table: { "&": " ja " }
+	table: {
+		"%": " protsenti ",
+		$: " dollar ",
+		"£": " nael ",
+		"&": " ja "
+	}
 };
 /** Latvian: `&` becomes `un`. */
 const lv = {
 	id: "lv",
-	table: { "&": " un " }
+	table: {
+		"%": " procenti ",
+		$: " dolars ",
+		"£": " marcina ",
+		"&": " un "
+	}
 };
 /** Lithuanian: `&` becomes `ir`. */
 const lt = {
 	id: "lt",
-	table: { "&": " ir " }
+	table: {
+		"%": " procentai ",
+		$: " doleris ",
+		"£": " svaras ",
+		"&": " ir "
+	}
 };
 /** Catalan: the punt volat in `l·l` is dropped, `&` becomes `i`. */
 const ca = {
 	id: "ca",
 	table: {
 		"·": "",
+		"%": " per cent ",
+		$: " dolar ",
+		"£": " lliura ",
 		"&": " i "
 	}
 };
@@ -592,4 +715,28 @@ const latinLocales = {
 };
 
 //#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 };
+//#region src/transliterate/registry.ts
+const registered = /* @__PURE__ */ new Map();
+let version = 0;
+/** A counter that changes whenever the registry does, so cached option resolutions can tell they are stale. */
+function registryVersion() {
+	return version;
+}
+/** Makes `slugify` accept each locale's `id` as a string, for locales whose tables do not ship with the main entry (`registerLocale(ru, uk)`). Later registrations win. */
+function registerLocale(...locales) {
+	for (const locale of locales) registered.set(locale.id, locale);
+	version += 1;
+}
+/** Removes a locale registered with `registerLocale`; the built-in Latin ids cannot be removed. */
+function unregisterLocale(id) {
+	const removed = registered.delete(id);
+	if (removed) version += 1;
+	return removed;
+}
+/** The locale registered under `id`, if any. */
+function registeredLocale(id) {
+	return registered.get(id);
+}
+
+//#endregion
+export { vi as A, latin as B, pl as C, sl as D, sk as E, lookup as F, resolveTables as I, stripMarks as L, applyCompat as M, compileTables as N, sv as O, fold as P, transliterate as R, nl as S, ro as T, it as _, az as a, lv as b, da as c, et as d, fi as f, is as g, hu as h, unregisterLocale as i, DEFAULT_TABLES as j, tr as k, de as l, hr as m, registeredLocale as n, ca as o, fr as p, registryVersion as r, cs as s, registerLocale as t, es as u, latinLocales as v, pt as w, nb as x, lt as y, symbols as z };

package/dist/shared/{types-DbyhfPRc.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 = "el" | "he" | "ja" | "ko";
+/** 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-DbyhfPRc.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>;
 }
@@ -74,6 +75,62 @@ export declare function mergeTables(...tables: readonly TransliterationTable[]):
 /** A new locale from `base` with `overrides` merged in; neither object is mutated. */
 export declare function defineLocale(base: Locale, overrides?: LocaleOverrides): Locale;
 //#endregion
+//#region src/transliterate/devanagari.d.ts
+/** Devanagari (Hindi, Marathi, Nepali) to Latin without diacritics: consonants carry their inherent `a` unless a vowel sign or virama follows; vowel length is not marked and no schwa deletion is applied, so `भारत` is `bharata`. */
+export declare const devanagari: TransliterationTable;
+//#endregion
+//#region src/transliterate/bengali.d.ts
+/** Bengali to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
+export declare const bengali: TransliterationTable;
+//#endregion
+//#region src/transliterate/gujarati.d.ts
+/** Gujarati to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
+export declare const gujarati: TransliterationTable;
+//#endregion
+//#region src/transliterate/gurmukhi.d.ts
+/** Gurmukhi to Latin without diacritics, syllable by syllable like the Devanagari table: inherent `a`, no vowel length, no schwa deletion. */
+export declare const gurmukhi: TransliterationTable;
+//#endregion
+//#region src/transliterate/kannada.d.ts
+/** 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;
+//#endregion
+//#region src/transliterate/telugu.d.ts
+/** 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;
@@ -123,13 +180,41 @@ export declare const cyrillicLocales: Readonly<Record<CyrillicLocaleId, Locale>>
 //#region src/transliterate/locales-other.d.ts
 /** Greek: the Greek table, `&` becomes `kai`. */
 export declare const el: Locale;
+/** Hindi: the Devanagari table, `&` becomes `aur`. */
+export declare const hi: Locale;
 /** Hebrew: the Hebrew table, `&` becomes `ve`. */
 export declare const he: Locale;
 /** Japanese: the kana table, `&` becomes `to`; kanji is left alone. */
 export declare const ja: Locale;
 /** Korean: the Hangul table, `&` becomes `mit`. */
 export declare const ko: Locale;
-/** The Greek, Hebrew, Japanese and Korean locales by id. */
+/** Bengali: the bengali table, `&` becomes `ebong`. */
+export declare const bn: Locale;
+/** Punjabi: the gurmukhi table, `&` becomes `ate`. */
+export declare const pa: Locale;
+/** Gujarati: the gujarati table, `&` becomes `ane`. */
+export declare const gu: Locale;
+/** Odia: the oriya table, `&` becomes `o`. */
+export declare const or: Locale;
+/** Tamil: the tamil table, `&` becomes `matrum`. */
+export declare const ta: Locale;
+/** Telugu: the telugu table, `&` becomes `mariyu`. */
+export declare const te: Locale;
+/** Kannada: the kannada table, `&` becomes `mattu`. */
+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
 //#region src/transliterate/locales-latin.d.ts
@@ -186,6 +271,14 @@ export declare const ca: Locale;
 /** The Latin-script locales by id; these ship with the main entry. */
 export declare const latinLocales: Readonly<Record<LatinLocaleId, Locale>>;
 //#endregion
+//#region src/transliterate/registry.d.ts
+/** Makes `slugify` accept each locale's `id` as a string, for locales whose tables do not ship with the main entry (`registerLocale(ru, uk)`). Later registrations win. */
+export declare function registerLocale(...locales: readonly Locale[]): void;
+/** Removes a locale registered with `registerLocale`; the built-in Latin ids cannot be removed. */
+export declare function unregisterLocale(id: string): boolean;
+/** The locale registered under `id`, if any. */
+export declare function registeredLocale(id: string): Locale | undefined;
+//#endregion
 //#region src/transliterate/symbols.d.ts
 /** Symbols spelled out in English (`&`, `©`, currency signs) or turned into separators (dashes, quotes, bullets). */
 export declare const symbols: TransliterationTable;