cizgile 0.1.0 → 0.2.0

package/dist/shared/percent-DG-pZhJI.mjs

@@ -0,0 +1,268 @@
+//#region src/uri/charset.ts
+function inChars(chars, cp) {
+	return cp < 128 && chars.indexOf(String.fromCodePoint(cp)) !== -1;
+}
+function table(predicate) {
+	const out = /* @__PURE__ */ new Uint8Array(128);
+	for (let cp = 0; cp < 128; cp++) if (predicate(cp)) out[cp] = 1;
+	return out;
+}
+/** RFC 3986 `ALPHA`. */
+function isAlpha(cp) {
+	return cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122;
+}
+/** RFC 3986 `DIGIT`. */
+function isDigit(cp) {
+	return cp >= 48 && cp <= 57;
+}
+/** RFC 3986 `HEXDIG`, either case. */
+function isHexDigit(cp) {
+	return isDigit(cp) || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+}
+/** Whether `text` is a valid RFC 3986 `scheme`: a letter followed by letters, digits, `+`, `-` or `.`. */
+function isScheme(text) {
+	return /^[A-Za-z][A-Za-z0-9+.-]*$/.test(text);
+}
+const UNRESERVED = /* @__PURE__ */ table((cp) => isAlpha(cp) || isDigit(cp) || inChars("-._~", cp));
+const GEN_DELIMS = /* @__PURE__ */ table((cp) => inChars(":/?#[]@", cp));
+const SUB_DELIMS = /* @__PURE__ */ table((cp) => inChars("!$&'()*+,;=", cp));
+const PCHAR = /* @__PURE__ */ table((cp) => UNRESERVED[cp] === 1 || SUB_DELIMS[cp] === 1 || cp === 58 || cp === 64);
+const SEGMENT_NZ_NC = /* @__PURE__ */ table((cp) => UNRESERVED[cp] === 1 || SUB_DELIMS[cp] === 1 || cp === 64);
+const QUERY = /* @__PURE__ */ table((cp) => PCHAR[cp] === 1 || cp === 47 || cp === 63);
+/** RFC 3986 section 2.3 `unreserved`: letters, digits, `- . _ ~`. */
+function isUnreserved(cp) {
+	return cp < 128 && UNRESERVED[cp] === 1;
+}
+/** RFC 3986 section 2.2 `gen-delims`: `: / ? # [ ] @`. */
+function isGenDelim(cp) {
+	return cp < 128 && GEN_DELIMS[cp] === 1;
+}
+/** RFC 3986 section 2.2 `sub-delims`: `! $ & ' ( ) * + , ; =`. */
+function isSubDelim(cp) {
+	return cp < 128 && SUB_DELIMS[cp] === 1;
+}
+/** RFC 3986 section 2.2 `reserved`: `gen-delims` or `sub-delims`. */
+function isReserved(cp) {
+	return isGenDelim(cp) || isSubDelim(cp);
+}
+/** RFC 3986 section 3.3 `pchar` less `pct-encoded`: `unreserved`, `sub-delims`, `:` or `@`. */
+function isPchar(cp) {
+	return cp < 128 && PCHAR[cp] === 1;
+}
+/** RFC 3986 section 3.3 `segment-nz-nc` character: `pchar` without the colon. */
+function isSegmentNzNc(cp) {
+	return cp < 128 && SEGMENT_NZ_NC[cp] === 1;
+}
+/** A character allowed unencoded in a `query` or `fragment`: `pchar`, `/` or `?`. */
+function isQueryChar(cp) {
+	return cp < 128 && QUERY[cp] === 1;
+}
+function isWhatwgC0Safe(cp) {
+	return cp >= 32 && cp <= 126;
+}
+function isWhatwgFragmentSafe(cp) {
+	return cp >= 33 && cp <= 126 && !inChars("\"<>`", cp);
+}
+function isWhatwgQuerySafe(cp) {
+	return cp >= 33 && cp <= 126 && !inChars("\"#<>", cp);
+}
+function isWhatwgSpecialQuerySafe(cp) {
+	return isWhatwgQuerySafe(cp) && cp !== 39;
+}
+function isWhatwgPathSafe(cp) {
+	return isWhatwgQuerySafe(cp) && !inChars("?^`{}", cp);
+}
+function isWhatwgUserinfoSafe(cp) {
+	return isWhatwgPathSafe(cp) && !inChars("/:;=@[\\]|", cp);
+}
+function isWhatwgComponentSafe(cp) {
+	return isWhatwgUserinfoSafe(cp) && !inChars("$&+,", cp);
+}
+function isFormSafe(cp) {
+	return isAlpha(cp) || isDigit(cp) || inChars("*-._", cp);
+}
+const SETS = {
+	unreserved: isUnreserved,
+	pchar: isPchar,
+	"segment-nz-nc": isSegmentNzNc,
+	path: (cp) => isPchar(cp) || cp === 47,
+	query: isQueryChar,
+	fragment: isQueryChar,
+	userinfo: (cp) => isUnreserved(cp) || isSubDelim(cp) || cp === 58,
+	"whatwg-c0-control": isWhatwgC0Safe,
+	"whatwg-fragment": isWhatwgFragmentSafe,
+	"whatwg-query": isWhatwgQuerySafe,
+	"whatwg-special-query": isWhatwgSpecialQuerySafe,
+	"whatwg-path": isWhatwgPathSafe,
+	"whatwg-userinfo": isWhatwgUserinfoSafe,
+	"whatwg-component": isWhatwgComponentSafe,
+	form: isFormSafe
+};
+/** The predicate behind a named keep-set, or the predicate itself. */
+function resolveEncodeSet(set) {
+	return typeof set === "function" ? set : SETS[set];
+}
+let tablePredicates;
+function keepPredicate(set) {
+	if (typeof set === "function") return set;
+	tablePredicates ??= /* @__PURE__ */ new Map();
+	let out = tablePredicates.get(set);
+	if (out === void 0) {
+		const safe = table(SETS[set]);
+		out = (cp) => cp < 128 && safe[cp] === 1;
+		tablePredicates.set(set, out);
+	}
+	return out;
+}
+
+//#endregion
+//#region src/uri/utf8.ts
+const HEX = "0123456789ABCDEF";
+const HEX_BYTES = [];
+for (let byte = 0; byte < 256; byte++) HEX_BYTES.push("%" + HEX[byte >> 4] + HEX[byte & 15]);
+const NIBBLES = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+for (let i = 0; i < 16; i++) {
+	NIBBLES[HEX.codePointAt(i) ?? 0] = i;
+	NIBBLES[HEX.toLowerCase().codePointAt(i) ?? 0] = i;
+}
+function hexByte(byte) {
+	return HEX_BYTES[byte] ?? "";
+}
+function encodeUtf8(codePoint) {
+	const cp = codePoint >= 55296 && codePoint <= 57343 ? 65533 : codePoint;
+	if (cp < 128) return hexByte(cp);
+	if (cp < 2048) return hexByte(192 | cp >> 6) + hexByte(128 | cp & 63);
+	if (cp < 65536) return hexByte(224 | cp >> 12) + hexByte(128 | cp >> 6 & 63) + hexByte(128 | cp & 63);
+	return hexByte(240 | cp >> 18) + hexByte(128 | cp >> 12 & 63) + hexByte(128 | cp >> 6 & 63) + hexByte(128 | cp & 63);
+}
+function isContinuation(byte) {
+	return byte !== void 0 && (byte & 192) === 128;
+}
+function readUtf8(bytes, index) {
+	const b0 = bytes[index];
+	if (b0 === void 0) return void 0;
+	if (b0 < 128) return {
+		codePoint: b0,
+		length: 1
+	};
+	const b1 = bytes[index + 1];
+	if (b0 >= 194 && b0 <= 223) {
+		if (!isContinuation(b1)) return void 0;
+		return {
+			codePoint: (b0 & 31) << 6 | b1 & 63,
+			length: 2
+		};
+	}
+	const b2 = bytes[index + 2];
+	if (b0 >= 224 && b0 <= 239) {
+		if (!isContinuation(b1) || !isContinuation(b2)) return void 0;
+		if (b0 === 224 && b1 < 160) return void 0;
+		if (b0 === 237 && b1 > 159) return void 0;
+		return {
+			codePoint: (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63,
+			length: 3
+		};
+	}
+	const b3 = bytes[index + 3];
+	if (b0 >= 240 && b0 <= 244) {
+		if (!isContinuation(b1) || !isContinuation(b2) || !isContinuation(b3)) return void 0;
+		if (b0 === 240 && b1 < 144) return void 0;
+		if (b0 === 244 && b1 > 143) return void 0;
+		return {
+			codePoint: (b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63,
+			length: 4
+		};
+	}
+}
+function nibble(code) {
+	return code !== void 0 && code < 128 ? NIBBLES[code] ?? -1 : -1;
+}
+function readHexByte(input, index) {
+	if (input.codePointAt(index) !== 37) return -1;
+	const hi = nibble(input.codePointAt(index + 1));
+	const lo = nibble(input.codePointAt(index + 2));
+	return hi < 0 || lo < 0 ? -1 : hi * 16 + lo;
+}
+
+//#endregion
+//#region src/uri/percent.ts
+/** Percent-encodes `input` as UTF-8 with uppercase hex, leaving the characters `keep` names untouched; `"form"` also turns spaces into `+`. */
+function percentEncode(input, keep = "unreserved") {
+	const keepFn = keepPredicate(keep);
+	const plusForSpace = keep === "form";
+	const length = input.length;
+	let i = 0;
+	while (i < length) {
+		const code = input.codePointAt(i) ?? 0;
+		if (code >= 128 || !keepFn(code)) break;
+		i += 1;
+	}
+	if (i === length) return input;
+	let out = input.slice(0, i);
+	for (const ch of input.slice(i)) {
+		const cp = ch.codePointAt(0) ?? 0;
+		if (cp < 128 && keepFn(cp)) out += ch;
+		else if (plusForSpace && cp === 32) out += "+";
+		else out += encodeUtf8(cp);
+	}
+	return out;
+}
+function decodeBytes(bytes) {
+	let out = "";
+	let i = 0;
+	while (i < bytes.length) {
+		const char = readUtf8(bytes, i);
+		if (char === void 0) {
+			out += "�";
+			i += 1;
+		} else {
+			out += String.fromCodePoint(char.codePoint);
+			i += char.length;
+		}
+	}
+	return out;
+}
+/** Decodes every `%XX` sequence as UTF-8; malformed bytes become U+FFFD and lone `%` is kept. */
+function percentDecode(input, options = {}) {
+	if (!input.includes("%") && !(options.plusAsSpace === true && input.includes("+"))) return input;
+	let out = "";
+	let i = 0;
+	const bytes = [];
+	while (i < input.length) {
+		const byte = readHexByte(input, i);
+		if (byte !== -1) {
+			bytes.push(byte);
+			i += 3;
+			continue;
+		}
+		if (bytes.length > 0) {
+			out += decodeBytes(bytes);
+			bytes.length = 0;
+		}
+		const ch = input.charAt(i);
+		out += options.plusAsSpace && ch === "+" ? " " : ch;
+		i += 1;
+	}
+	if (bytes.length > 0) out += decodeBytes(bytes);
+	return out;
+}
+/** RFC 3986 section 6.2.2.2: decodes percent-encoded `unreserved` characters and uppercases the hex of the rest. */
+function normalizePercentEncoding(input) {
+	if (!input.includes("%")) return input;
+	let out = "";
+	let i = 0;
+	while (i < input.length) {
+		const byte = readHexByte(input, i);
+		if (byte === -1) {
+			out += input.charAt(i);
+			i += 1;
+		} else {
+			out += isUnreserved(byte) ? String.fromCodePoint(byte) : hexByte(byte);
+			i += 3;
+		}
+	}
+	return out;
+}
+
+//#endregion
+export { isUnreserved as _, readHexByte as a, isDigit as c, isPchar as d, isQueryChar as f, isSubDelim as g, isSegmentNzNc as h, encodeUtf8 as i, isGenDelim as l, isScheme as m, percentDecode as n, readUtf8 as o, isReserved as p, percentEncode as r, isAlpha as s, normalizePercentEncoding as t, isHexDigit as u, resolveEncodeSet as v };

package/dist/shared/types-DbyhfPRc.d.mts

@@ -0,0 +1,24 @@
+//#region src/transliterate/types.d.ts
+/** Maps a character or character sequence to its ASCII spelling. */
+type TransliterationTable = Readonly<Record<string, string>>;
+/** Language rules: a table applied first, the script tables the language needs, and optionally its own lowercasing. */
+interface Locale {
+  /** BCP 47 language tag such as `"de"` or `"de-CH"`. */
+  readonly id: string;
+  /** Letter and symbol replacements specific to the language, applied before every other table. */
+  readonly table: TransliterationTable;
+  /** Script tables the language is written in, such as `cyrillic` for Russian. */
+  readonly tables?: readonly TransliterationTable[];
+  /** Language-aware lowercasing for unicode slugs, such as the Turkish dotted and dotless i. */
+  readonly lowercase?: (input: string) => string;
+}
+/** Locale ids `slugify` accepts as strings; their tables ship with the main entry. */
+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";
+/** Every id in the `locales` registry. */
+type LocaleId = LatinLocaleId | CyrillicLocaleId | OtherLocaleId;
+//#endregion
+export { OtherLocaleId as a, LocaleId as i, LatinLocaleId as n, TransliterationTable as o, Locale as r, CyrillicLocaleId as t };

package/dist/transliterate.d.mts

@@ -1,85 +1,199 @@
-import { a as TransliterationTable, i as LocaleId, n as LatinLocaleId, r as Locale, t as CyrillicLocaleId } from "./shared/types-C1iMvUXh.mjs";
-//#region src/transliterate/arabic.d.ts
-export declare const arabic: TransliterationTable;
-export declare const persian: TransliterationTable;
-export declare const urdu: TransliterationTable;
-export declare const pashto: TransliterationTable;
-//#endregion
-//#region src/transliterate/armenian.d.ts
-export declare const armenian: TransliterationTable;
-//#endregion
+import { a as OtherLocaleId, i as LocaleId, n as LatinLocaleId, o as TransliterationTable, r as Locale, t as CyrillicLocaleId } from "./shared/types-DbyhfPRc.mjs";
 //#region src/transliterate/core.d.ts
+/** Options for `transliterate`. */
 interface TransliterateOptions {
+  /** Language rules consulted before the tables. */
   readonly locale?: Locale;
+  /** Extra script tables, consulted before the Latin and symbol defaults. */
   readonly tables?: readonly TransliterationTable[];
+  /** What happens to characters no table covers; `"keep"` by default. */
   readonly unknown?: "keep" | "drop";
+  /** Folds compatibility characters first (ligatures, superscripts, circled digits), as `slugify` does; `false` by default. */
+  readonly nfkc?: boolean;
 }
+/** The tables every call consults last: `latin`, then `symbols`. */
 export declare const DEFAULT_TABLES: readonly TransliterationTable[];
+type Sequences = ReadonlyArray<readonly [string, string]>;
+interface CompiledTables {
+  readonly map: ReadonlyMap<string, string>;
+  readonly sequences: Sequences;
+  readonly ascii: RegExp | undefined;
+  readonly folded: Map<string, string | null>;
+}
+/** The table list a `transliterate` call would consult, in lookup order. */
 export declare function resolveTables(options: TransliterateOptions): readonly TransliterationTable[];
+/** The first table value for `key`, or `undefined`. */
 export declare function lookup(tables: readonly TransliterationTable[], key: string): string | undefined;
+/** Removes combining marks: `"é"` becomes `"e"`, `"ǿ"` becomes `"ø"`. */
 export declare function stripMarks(input: string): string;
-export declare function fold(input: string, tables: readonly TransliterationTable[], dropUnknown: boolean, foldMarks?: boolean): string;
+/** The transliteration core: applies `tables` to NFC text, folding marks unless told not to. */
+export declare function fold(input: string, tables: readonly TransliterationTable[] | CompiledTables, dropUnknown: boolean, foldMarks?: boolean): string;
+/** 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"`. */
 export declare function transliterate(input: string, options?: TransliterateOptions): string;
 //#endregion
+//#region src/transliterate/arabic.d.ts
+/** Arabic letters to Latin; short vowels are marks and fall away. */
+export declare const arabic: TransliterationTable;
+/** Persian letters that differ from Arabic: `پ چ ژ گ` and the Persian yeh and kaf. */
+export declare const persian: TransliterationTable;
+/** Urdu letters that differ from Arabic: `ٹ ڈ ڑ ں ے`. */
+export declare const urdu: TransliterationTable;
+/** Pashto letters that differ from Arabic: `ټ ډ ړ ږ ښ ڼ`. */
+export declare const pashto: TransliterationTable;
+//#endregion
+//#region src/transliterate/armenian.d.ts
+/** Armenian to Latin; `ե` and `ո` take their word-initial spelling on the capital. */
+export declare const armenian: TransliterationTable;
+//#endregion
 //#region src/transliterate/cyrillic.d.ts
+/** Cyrillic to Latin, the simov/slugify values, covering Russian, Kazakh, Belarusian and the other national alphabets. */
 export declare const cyrillic: TransliterationTable;
+/** Ukrainian refinements: `г` is `h`, `и` is `y`, `є ї й ю я` take their word-initial spelling on the capital. */
 export declare const cyrillicUk: TransliterationTable;
+/** Bulgarian refinements: `щ` is `sht`, `ъ` is `a`. */
 export declare const cyrillicBg: TransliterationTable;
+/** Macedonian refinements: `ѓ ќ ѕ џ љ њ`. */
 export declare const cyrillicMk: TransliterationTable;
+/** Serbian refinements: `ђ ћ џ љ њ`, `х` is `h`. */
 export declare const cyrillicSr: TransliterationTable;
 //#endregion
 //#region src/transliterate/define.d.ts
+/** What `defineLocale` may change; every field is optional. */
 interface LocaleOverrides {
+  /** Replaces the base id, such as `"de-CH"`. */
   readonly id?: string;
+  /** Merged over the base table; later keys win. */
   readonly table?: TransliterationTable;
+  /** Replaces the base script tables. */
   readonly tables?: readonly TransliterationTable[];
+  /** Replaces the base lowercasing function. */
   readonly lowercase?: (input: string) => string;
 }
+/** One table from many; later tables win. Returns a new object. */
 export declare function mergeTables(...tables: readonly TransliterationTable[]): 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/dhivehi.d.ts
+/** Thaana (Dhivehi) to Latin, the sindresorhus/transliterate values. */
 export declare const dhivehi: TransliterationTable;
 //#endregion
 //#region src/transliterate/georgian.d.ts
+/** Georgian Mkhedruli to Latin. */
 export declare const georgian: TransliterationTable;
 //#endregion
 //#region src/transliterate/greek.d.ts
+/** Modern Greek to Latin: `η` and `ι` are `i`, `β` is `v`, `θ` is `th`. */
 export declare const greek: TransliterationTable;
 //#endregion
+//#region src/transliterate/hangul.d.ts
+/** Hangul jamo to Revised Romanization, jamo by jamo; precomposed syllables reach it through NFD, with no sound-change rules across syllables. */
+export declare const hangul: TransliterationTable;
+//#endregion
+//#region src/transliterate/hebrew.d.ts
+/** Hebrew consonants to Latin, final forms and Yiddish ligatures included; vowel points fall away. */
+export declare const hebrew: TransliterationTable;
+//#endregion
+//#region src/transliterate/kana.d.ts
+/** Hiragana and katakana to Hepburn, digraphs and foreign-sound combinations included; the long-vowel mark and sokuon are dropped, kanji is left alone. */
+export declare const kana: TransliterationTable;
+//#endregion
 //#region src/transliterate/latin.d.ts
+/** Latin letters with no decomposition (`ß`, `Æ`, `Ł`, `Þ`, `Ə`, ...) and the modifier letters that are dropped. */
 export declare const latin: TransliterationTable;
 //#endregion
 //#region src/transliterate/locales-cyrillic.d.ts
+/** Russian: the Cyrillic table, `&` becomes `i`. */
 export declare const ru: Locale;
+/** Ukrainian: the Ukrainian overlay on the Cyrillic table, `&` becomes `ta`. */
 export declare const uk: Locale;
+/** Bulgarian: the Bulgarian overlay on the Cyrillic table, `&` becomes `i`. */
 export declare const bg: Locale;
+/** Macedonian: the Macedonian overlay on the Cyrillic table, `&` becomes `i`. */
 export declare const mk: Locale;
+/** Serbian: the Serbian overlay on the Cyrillic table, Latin `đ` becomes `dj`, `&` becomes `i`. */
 export declare const sr: Locale;
+/** Kazakh: the Cyrillic table, `&` becomes `zhane`. */
+export declare const kk: Locale;
+/** Belarusian: the Cyrillic table, `&` becomes `i`. */
+export declare const be: Locale;
+/** The Cyrillic-script locales by id. */
 export declare const cyrillicLocales: Readonly<Record<CyrillicLocaleId, Locale>>;
 //#endregion
+//#region src/transliterate/locales-other.d.ts
+/** Greek: the Greek table, `&` becomes `kai`. */
+export declare const el: 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. */
+export declare const otherLocales: Readonly<Record<OtherLocaleId, Locale>>;
+//#endregion
 //#region src/transliterate/locales-latin.d.ts
+/** German: `ä ö ü` become `ae oe ue`, `ß` becomes `ss`, `&` becomes `und`. */
 export declare const de: Locale;
+/** Turkish: dotted and dotless i, `ğ ş ç ö ü` stripped, `&` becomes `ve`; lowercases with the Turkish rules. */
 export declare const tr: Locale;
+/** Azerbaijani: the Turkish letters plus `ə`, `&` becomes `ve`. */
 export declare const az: Locale;
+/** Danish: `ø å æ` become `oe aa ae`, `&` becomes `og`. */
 export declare const da: Locale;
+/** Norwegian Bokmål: `ø å æ` become `oe aa ae`, `&` becomes `og`. */
 export declare const nb: Locale;
+/** Swedish: `ä ö å` become `ae oe aa`, `&` becomes `och`. */
 export declare const sv: Locale;
+/** Finnish: `ä ö å` become `ae oe aa`, `&` becomes `ja`. */
 export declare const fi: Locale;
+/** Hungarian: `&` becomes `es`. */
 export declare const hu: Locale;
+/** Vietnamese: `đ` becomes `d`, `&` becomes `va`. */
 export declare const vi: Locale;
+/** Spanish: `ñ` becomes `n`, `&` becomes `y`. */
 export declare const es: Locale;
+/** French: `œ æ` become `oe ae`, `&` becomes `et`. */
 export declare const fr: Locale;
+/** Portuguese: `&` becomes `e`. */
 export declare const pt: Locale;
+/** Italian: `&` becomes `e`. */
 export declare const it: Locale;
+/** Dutch: `ij` becomes `ij`, `&` becomes `en`. */
 export declare const nl: Locale;
+/** Polish: `&` becomes `i`. */
+export declare const pl: Locale;
+/** Romanian: `&` becomes `si`. */
+export declare const ro: Locale;
+/** Czech: `&` becomes `a`. */
+export declare const cs: Locale;
+/** Slovak: `&` becomes `a`. */
+export declare const sk: Locale;
+/** Slovenian: `&` becomes `in`. */
+export declare const sl: Locale;
+/** Croatian: `&` becomes `i`. */
+export declare const hr: Locale;
+/** Icelandic: `þ ð` become `th d`, `&` becomes `og`. */
+export declare const is: Locale;
+/** Estonian: `&` becomes `ja`. */
+export declare const et: Locale;
+/** Latvian: `&` becomes `un`. */
+export declare const lv: Locale;
+/** Lithuanian: `&` becomes `ir`. */
+export declare const lt: Locale;
+/** Catalan: the punt volat in `l·l` is dropped, `&` becomes `i`. */
+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/symbols.d.ts
+/** Symbols spelled out in English (`&`, `©`, currency signs) or turned into separators (dashes, quotes, bullets). */
 export declare const symbols: TransliterationTable;
 //#endregion
 //#region src/transliterate.d.ts
+/** Every script table; pass as `tables` when the input language is unknown. */
 export declare const allScripts: readonly TransliterationTable[];
+/** Every locale object by id. */
 export declare const locales: Readonly<Record<LocaleId, Locale>>;
 //#endregion
-export type { CyrillicLocaleId, LatinLocaleId, Locale, LocaleId, LocaleOverrides, TransliterateOptions, TransliterationTable };
+export type { CyrillicLocaleId, LatinLocaleId, Locale, LocaleId, LocaleOverrides, OtherLocaleId, TransliterateOptions, TransliterationTable };