lotin-kirill 0.1.4 → 1.0.0

package/README.md

@@ -7,7 +7,7 @@
 [![](https://img.shields.io/bundlephobia/minzip/lotin-kirill)](https://bundlephobia.com/result?p=lotin-kirill)
 [![](https://img.shields.io/npm/l/lotin-kirill)](https://npmjs.com/lotin-kirill)
 
-Transliterator for Uzbek words with high accuracy (from latin alphabet to cyrillic and vice versa). Used at [transliterator.uz](https://transliterator.uz/)
+Transliterator for Uzbek text with high accuracy, between the 1995 and 2026 Latin alphabets and Cyrillic. Used at [transliterator.uz](https://transliterator.uz/)
 
 ### [O‘zbek tilida o‘qish](https://github.com/diyorbek/lotin-kirill/blob/master/README_UZ.md)
 
@@ -28,131 +28,100 @@ yarn add lotin-kirill
 UNPKG
 
 ```html
-<script src="https://unpkg.com/lotin-kirill/dist-umd/index.min.js"></script>
+<script src="https://unpkg.com/lotin-kirill/dist/index.umd.js"></script>
 ```
 
 ## Usage
 
-Initialize the engine:
-
 ```js
-import Transliterator from 'lotin-kirill';
-
-const transliterator = new Transliterator();
-```
+import { createTransliterator } from 'lotin-kirill';
 
-When using UNPKG distribution:
+const transliterator = createTransliterator();
 
-```html
-<script src="https://unpkg.com/lotin-kirill/dist-umd/index.min.js"></script>
-<script>
-  const Transliterator = lotinKirill.default;
-  const transliterator = new Transliterator();
-</script>
+transliterator.transliterate('Salom', { from: 'latin1995', to: 'cyrillic' }); // -> 'Салом'
+transliterator.transliterate('Тошкент', { from: 'cyrillic', to: 'latin2026' }); // -> 'Toşkent'
 ```
 
-### Single word transliteration:
+The alphabets:
 
-`toLatin(word: string): string`
+| Name        | Alphabet                                                      |
+| ----------- | ------------------------------------------------------------- |
+| `latin1995` | the Latin alphabet in use since 1995 (`sh`, `ch`, `o‘`, `g‘`) |
+| `latin2026` | the 2026 Latin alphabet (`ş`, `ç`, `ö`, `ğ`)                  |
+| `cyrillic`  | Cyrillic                                                      |
 
-`toCyrillic(word: string): string`
+Any direction works, for example `{ from: 'latin2026', to: 'cyrillic' }`.
 
-Example
+CommonJS:
 
 ```js
-const latinWord = transliterator.toLatin('мотивация');
-console.log(latinWord); // -> 'motivatsiya'
-
-const cyrillicWord = transliterator.toCyrillic("e'lon");
-console.log(cyrillicWord); // -> 'эълон'
+const { createTransliterator } = require('lotin-kirill');
 ```
 
-### Text (multiple words) transliteration:
-
-`textToLatin(text: string): string`
-
-`textToCyrillic(text: string): string`
-
-Example
+When using UNPKG distribution:
 
-```js
-const latinText = transliterator.textToLatin('Жуда узун кириллча текст.');
-console.log(latinText); // -> 'Juda uzun kirillcha tekst.'
+```html
+<script src="https://unpkg.com/lotin-kirill/dist/index.umd.js"></script>
+<script>
+  const transliterator = lotinKirill.createTransliterator();
 
-const cyrillicText = transliterator.textToCyrillic('Juda uzun lotincha tekst.');
-console.log(cyrillicText); // -> 'Жуда узун лотинча текст.'
+  transliterator.transliterate('Salom', { from: 'latin1995', to: 'cyrillic' }); // -> 'Салом'
+</script>
 ```
 
 ### Exceptional words
 
-You can initialize the transliterator object with an exceptional words list:
+Some words, mostly loanwords, don't follow the rules. Create a transliterator with a list of them. Each word gives its spelling in at least two alphabets:
 
 ```js
-import Transliterator from 'lotin-kirill';
+import { createTransliterator } from 'lotin-kirill';
 
-const transliterator = new Transliterator([
-  // [latinWord, cyrillicWord]
-  ['oktabr', 'октябрь'],
-  ['Google', 'Google'],
-]);
+const transliterator = createTransliterator({
+  exceptions: [
+    { latin1995: 'oktabr', cyrillic: 'октябрь' },
+    { latin1995: 'Chrome', cyrillic: 'Chrome', latin2026: 'Chrome' },
+  ],
+});
 
-const cyrillicWord = transliterator.toCyrillic('oktabr');
-console.log(cyrillicWord); // -> 'октябрь' (not 'октабр')
+transliterator.transliterate('oktabr', { from: 'latin1995', to: 'cyrillic' }); // -> 'октябрь' (not 'октабр')
 ```
 
-One exceptional pair is enough for both cyrilllic and latin transliterations.
+One entry works in both directions:
 
 ```js
-// This also works
-const latinWord = transliterator.toLatin('октябрь');
-console.log(latinWord); // -> 'oktabr' (not 'oktyabr')
+transliterator.transliterate('октябрь', { from: 'cyrillic', to: 'latin1995' }); // -> 'oktabr' (not 'oktyabr')
 ```
 
-If exceptional pair is a pair of same words, the word is not transliterated.
+A word spelled the same in two alphabets isn't transliterated between them:
 
 ```js
-const cyrillicWord = transliterator.toCyrillic('Google');
-console.log(cyrillicWord); // -> 'Google'
+transliterator.transliterate('Chrome', { from: 'latin1995', to: 'latin2026' }); // -> 'Chrome' (not 'Çrome')
 ```
 
-Exceptional words with sufixes are also detected.
+Exceptional words with suffixes are also detected.
 
-**Variants of a word with prefixes should be added as separate exceptionals!**
+**Variants of a word with prefixes should be added as separate exceptions!**
 
 ```js
-// This also works
-const latinWord = transliterator.toLatin('октябрда');
-console.log(latinWord); // -> 'oktabrda' (not 'oktyabrda')
+transliterator.transliterate('октябрда', { from: 'cyrillic', to: 'latin1995' }); // -> 'oktabrda' (not 'oktyabrda')
 ```
 
-You can extend the exceptionals list after the initialization of the transliterator.
+You can add exceptions later, or remove all of them:
 
 ```js
-transliterator.extendExceptionals([['nol', 'ноль']]);
+transliterator.addExceptions([{ latin1995: 'nol', cyrillic: 'ноль' }]);
+transliterator.clearExceptions();
 ```
 
-Or purge all of the exceptionals added to transliterator.
-
-```js
-transliterator.purgeExceptionals();
-```
-
-### Pure transliterator functions
-
-There are pure transliterator functions which operate only on basic transliteration rules. These functions don't look up words in exceptionals list.
-
-`cyrillicToLatin(word: string): string`
-
-`latinToCyrillic(word: string): string`
-
-```js
-import Transliterator, { cyrillicToLatin, latinToCyrillic } from 'lotin-kirill';
-
-const transliterator = new Transliterator([['oktabr', 'октябрь']]);
-
-console.log(transliterator.toLatin('октябрь')); // -> 'oktabr'
-console.log(cyrillicToLatin('октябрь')); // -> 'oktyabr'
-
-console.log(transliterator.toCyrillic('oktabr')); // -> 'октябрь'
-console.log(latinToCyrillic('oktabr')); // -> 'октабр'
-```
+### Migrating from 0.x
+
+| 0.x                                              | 1.0                                                                                    |
+| ------------------------------------------------ | -------------------------------------------------------------------------------------- |
+| `new Transliterator([['oktabr', 'октябрь']])`    | `createTransliterator({ exceptions: [{ latin1995: 'oktabr', cyrillic: 'октябрь' }] })` |
+| `t.toCyrillic(text)`, `t.textToCyrillic(text)`   | `t.transliterate(text, { from: 'latin1995', to: 'cyrillic' })`                         |
+| `t.toLatin(text)`, `t.textToLatin(text)`         | `t.transliterate(text, { from: 'cyrillic', to: 'latin1995' })`                         |
+| `t.toCyrillic(['…', '…'])`                       | `words.map((word) => t.transliterate(word, { from, to }))`                             |
+| `t.extendExceptionals(pairs)`                    | `t.addExceptions(words)`                                                               |
+| `t.purgeExceptionals()`                          | `t.clearExceptions()`                                                                  |
+| `latinToCyrillic(word)`, `cyrillicToLatin(word)` | `createTransliterator().transliterate(word, { from, to })`                             |
+| `lotinKirill.default` (UNPKG)                    | `lotinKirill.createTransliterator`                                                     |

package/dist/engine/casing.d.ts

@@ -0,0 +1,6 @@
+import type { Entry } from './lexicon';
+export declare function lower(s: string): string;
+/** Put the original capitals back on the lowercase replacement for `word[start..end)`. */
+export declare function restoreLetterCase(replacement: string, word: string, start: number, end: number): string;
+/** Put the original capitals back on an exception: as written, lower, UPPER or Capitalized. */
+export declare function restoreWordCase(entry: Entry, source: string): string;

package/dist/engine/index.d.ts

@@ -0,0 +1,2 @@
+export { chain, Transliteration } from './transliteration';
+export * from './types';

package/dist/engine/lexicon.d.ts

@@ -0,0 +1,15 @@
+import type { Pair } from './types';
+export interface Entry {
+    key: string;
+    target: string;
+    lower: string;
+}
+export declare class Lexicon {
+    private words;
+    private stems;
+    private longestStem;
+    add(kind: 'words' | 'stems', prepared: string, [key, target]: Pair): void;
+    /** The whole word, or else the longest stem it starts with. */
+    find(word: string): [Entry, number] | undefined;
+    clear(): void;
+}

package/dist/engine/transliteration.d.ts

@@ -0,0 +1,24 @@
+import type { Definition, Exceptions } from './types';
+export declare class Transliteration {
+    private normalize;
+    private letters;
+    private longestLetter;
+    private rules;
+    private skip;
+    private word;
+    private isWord;
+    private wordExceptions;
+    private tokenExceptions;
+    constructor(definition: Definition);
+    addExceptions({ words, stems }: Exceptions): void;
+    clearExceptions(): void;
+    transliterate(text: string): string;
+    private transliterateToken;
+    private transliterateWords;
+    private transliterateWord;
+    /** Where rules match: position → [length, replacement]. The first rule wins. */
+    private matchRules;
+    private prepare;
+}
+/** Run several transliterations one after another, e.g. through a hub script. */
+export declare function chain(...steps: Array<(text: string) => string>): (text: string) => string;

package/dist/engine/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A context rule: [pattern, replacement].
+ * Patterns are matched against the lowercased original word, so lookbehind and
+ * lookahead always see the source text, never a half-transliterated one.
+ * `^` and `$` are the edges of the word.
+ */
+export type Rule = [RegExp, string | ((match: RegExpExecArray) => string)];
+/** [source, target] */
+export type Pair = [string, string];
+export interface Exceptions {
+    /** Must match the whole word. */
+    words?: Pair[];
+    /** Match the beginning of a word; the rest is transliterated as usual. */
+    stems?: Pair[];
+}
+export interface Definition extends Exceptions {
+    /** Letters and letter groups, lowercase. The longest match wins; a later duplicate overrides. */
+    letters: Pair[];
+    /** Checked before `letters`; the first rule that matches at a position wins. */
+    rules?: Rule[];
+    /** Tokens to leave as they are, e.g. Roman numerals or URLs. */
+    skip?: Array<RegExp | ((token: string) => boolean)>;
+    /** What a word is. Default: letters, combining marks and apostrophes. */
+    word?: RegExp;
+    /** Clean-up of the lowercased word before matching. Must keep the length. */
+    normalize?: (word: string) => string;
+}

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));let c=require("anchorme");c=s(c,1);var l=e=>e.toLowerCase()!==e.toUpperCase(),u=e=>e!==void 0&&e!==e.toLowerCase(),d=e=>e!==void 0&&l(e);function f(e){let t=0;for(;t<e.length&&!l(e[t]);)t++;return e.slice(0,t)+e.slice(t,t+1).toUpperCase()+e.slice(t+1).toLowerCase()}function p(e){let t=e.toLowerCase();return t.length===e.length?t:Array.from(e,e=>{let t=e.toLowerCase();return t.length===e.length?t:e}).join(``)}function m(e,t,n,r){if(!e)return e;let i=t.slice(n,r),a=Array.from(i).filter(l);if(!a.length)return u(t[r]??t[n-1])?e.toUpperCase():e;if(!a.some(u))return e;if(i.length>1&&i.length===e.length)return Array.from(e,(e,t)=>u(i[t])?e.toUpperCase():e).join(``);if(i.length>1)return a.every(u)?e.toUpperCase():u(a[0])?f(e):e;if(Array.from(e).filter(l).length<2)return e.toUpperCase();let o=t[r];return d(o)?u(o)?e.toUpperCase():f(e):d(t[n-1])?e.toUpperCase():f(e)}function h(e,t){if(t===e.key)return e.target;let n=Array.from(t).filter(l);return n.length&&n.every(u)?e.lower.toUpperCase():u(n[0])?f(e.lower):e.lower}var g=class{words=new Map;stems=new Map;longestStem=0;add(e,t,[n,r]){let i=this[e];i.has(t)||(i.set(t,{key:n,target:r,lower:r.toLowerCase()}),e===`stems`&&(this.longestStem=Math.max(this.longestStem,t.length)))}find(e){let t=this.words.get(e);if(t)return[t,e.length];for(let t=Math.min(e.length,this.longestStem);t>0;t--){let n=this.stems.get(e.slice(0,t));if(n)return[n,t]}}clear(){this.words.clear(),this.stems.clear(),this.longestStem=0}},_=/[\p{L}\p{M}ʻʼ’'`‘´]+/u,v=class{normalize;letters;longestLetter;rules;skip;word;isWord;wordExceptions=new g;tokenExceptions=new g;constructor(e){let t=e.word??_,n=(e,t=``)=>e.flags.replace(/[gy]/g,``)+t;this.normalize=e.normalize??(e=>e),this.letters=new Map(e.letters.map(([e,t])=>[this.prepare(e),t])),this.longestLetter=Math.max(0,...Array.from(this.letters.keys(),e=>e.length)),this.rules=(e.rules??[]).map(([e,t])=>[new RegExp(e.source,n(e,`g`)),t]),this.skip=(e.skip??[]).map(e=>{if(typeof e==`function`)return e;let t=new RegExp(e.source,n(e));return e=>t.test(e)}),this.word=new RegExp(t.source,n(t,`g`)),this.isWord=RegExp(`^(?:${t.source})$`,n(t)),this.addExceptions(e)}addExceptions({words:e=[],stems:t=[]}){for(let[n,r]of[[`words`,e],[`stems`,t]])for(let e of r){let t=this.prepare(e[0]);(this.isWord.test(t)?this.wordExceptions:this.tokenExceptions).add(n,t,e)}}clearExceptions(){this.wordExceptions.clear(),this.tokenExceptions.clear()}transliterate(e){return e.replace(/\S+/g,e=>this.transliterateToken(e))}transliterateToken(e){if(this.skip.some(t=>t(e)))return e;let t=this.tokenExceptions.find(this.prepare(e));if(t){let[n,r]=t;return h(n,e.slice(0,r))+this.transliterateWords(e.slice(r))}return this.transliterateWords(e)}transliterateWords(e){return e.replace(this.word,e=>this.transliterateWord(e))}transliterateWord(e){let t=this.prepare(e),n=``,r=0,i=this.wordExceptions.find(t);if(i){let[t,a]=i;n=h(t,e.slice(0,a)),r=a}let a=this.matchRules(t,r);for(;r<t.length;){let i=0,o,s=a?.get(r);if(s)[i,o]=s;else for(i=Math.min(this.longestLetter,t.length-r);i>0&&(o=this.letters.get(t.slice(r,r+i)),o===void 0);i--);o===void 0?n+=e[r++]:(n+=m(o,e,r,r+i),r+=i)}return n}matchRules(e,t){let n;for(let[r,i]of this.rules){r.lastIndex=t;for(let t=r.exec(e);t;t=r.exec(e))t[0]&&!n?.has(t.index)&&(n||=new Map,n.set(t.index,[t[0].length,typeof i==`function`?i(t):i])),r.lastIndex=t.index+1}return n}prepare(e){let t=this.normalize(p(e));if(t.length!==e.length)throw Error(`normalize() must not change the length of a word`);return t}};function y(...e){return t=>e.reduce((e,t)=>t(e),t)}var b=`list`in c.default?c.default:c.default.default,x=/[.:@/]/;function S(e){return x.test(e)&&b.list(e).length>0}var C=/^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})(\.|\))?$/,w=e=>e.replace(/[ʻʼ’'`‘´]/g,`ʼ`),T=e=>w(e).replace(/([og])ʼ/gi,`$1‘`),E=`аоэеиуўёюя`,D={letters:[[`a`,`а`],[`b`,`б`],[`d`,`д`],[`e`,`е`],[`f`,`ф`],[`g`,`г`],[`h`,`ҳ`],[`i`,`и`],[`j`,`ж`],[`k`,`к`],[`l`,`л`],[`m`,`м`],[`n`,`н`],[`o`,`о`],[`p`,`п`],[`q`,`қ`],[`r`,`р`],[`s`,`с`],[`t`,`т`],[`u`,`у`],[`v`,`в`],[`x`,`х`],[`y`,`й`],[`z`,`з`],[`sh`,`ш`],[`ch`,`ч`],[`oʼ`,`ў`],[`gʼ`,`ғ`],[`ye`,`е`],[`yo`,`ё`],[`yu`,`ю`],[`ya`,`я`],[`ʼ`,`ъ`],[`ee`,`еэ`],[`yee`,`еэ`],[`yoʼ`,`йў`]],rules:[[/^e/,`э`],[/ts(?=i(on|ya))/,`ц`],[/(?<=s)ʼ(?=h)/,``]],normalize:w,skip:[C,S]},O={letters:[[`а`,`a`],[`б`,`b`],[`в`,`v`],[`г`,`g`],[`д`,`d`],[`е`,`e`],[`ё`,`yo`],[`ж`,`j`],[`з`,`z`],[`и`,`i`],[`й`,`y`],[`к`,`k`],[`л`,`l`],[`м`,`m`],[`н`,`n`],[`о`,`o`],[`п`,`p`],[`р`,`r`],[`с`,`s`],[`т`,`t`],[`у`,`u`],[`ф`,`f`],[`х`,`x`],[`ц`,`s`],[`ч`,`ch`],[`ш`,`sh`],[`ъ`,`ʼ`],[`ь`,``],[`э`,`e`],[`ю`,`yu`],[`я`,`ya`],[`ў`,`o‘`],[`қ`,`q`],[`ғ`,`g‘`],[`ҳ`,`h`]],rules:[[/^е/,`ye`],[/е{3,}/,e=>`e`.repeat(e[0].length)],[RegExp(`(?<=[${E}ьъ])е`),`ye`],[/(?<=[ўғ])ъ|ъ(?=е)/,``],[/(?<=ь)о/,`yo`],[RegExp(`(?<=[${E}aeiou])ц`),`ts`],[/(?<=с)ҳ/,`ʼh`]],skip:[C,S]},k={letters:[[`sh`,`ş`],[`ch`,`ç`],[`oʼ`,`ö`],[`gʼ`,`ğ`]],rules:[[/(?<=s)ʼ(?=h)/,``]],normalize:w,skip:[C,S]},A={letters:[[`ş`,`sh`],[`ç`,`ch`],[`ö`,`o‘`],[`ğ`,`g‘`]],rules:[[/(?<=s)h/,`ʼh`]],skip:[C,S]},j=[`latin1995`,`latin2026`,`cyrillic`];function M({exceptions:e=[]}={}){let t={latin1995ToCyrillic:new v(D),cyrillicToLatin1995:new v(O),latin1995ToLatin2026:new v(k),latin2026ToLatin1995:new v(A)},n=e=>t.latin1995ToCyrillic.transliterate(e),r=e=>t.cyrillicToLatin1995.transliterate(e),i=e=>t.latin1995ToLatin2026.transliterate(e),a=e=>t.latin2026ToLatin1995.transliterate(e),o=e=>e,s={latin1995:{latin1995:o,latin2026:i,cyrillic:n},latin2026:{latin1995:a,latin2026:o,cyrillic:y(a,n)},cyrillic:{latin1995:r,latin2026:y(r,i),cyrillic:o}},c={transliterate(e,{from:t,to:n}){for(let e of[t,n])if(!j.includes(e))throw Error(`Unknown alphabet: ${e}`);return s[t][n](e)},addExceptions(e){for(let n of e){let{cyrillic:e,latin2026:r}=n;if([n.latin1995,e,r].filter(Boolean).length<2)throw Error(`Invalid exceptional word ${JSON.stringify(n)}`);let i=n.latin1995||a(r),o=T(i);if(e){let n=e.replace(/ь$/i,``);t.latin1995ToCyrillic.addExceptions({words:[[i,e]],stems:[[i,n]]}),t.cyrillicToLatin1995.addExceptions({words:[[e,o]],stems:[[e,o],[n,o]]})}r&&(t.latin1995ToLatin2026.addExceptions({stems:[[i,r]]}),t.latin2026ToLatin1995.addExceptions({stems:[[r,o]]}))}},clearExceptions(){for(let e of Object.values(t))e.clearExceptions()}};return c.addExceptions(e),c}exports.createTransliterator=M;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { Alphabet, Direction, ExceptionalWord, Transliterator, TransliteratorOptions, } from './uzbek';
+export { createTransliterator } from './uzbek';

package/dist/index.js

@@ -0,0 +1,308 @@
+import e from "anchorme";
+// src/engine/casing.ts
+var t = (e) => e.toLowerCase() !== e.toUpperCase(), n = (e) => e !== void 0 && e !== e.toLowerCase(), r = (e) => e !== void 0 && t(e);
+function i(e) {
+	let n = 0;
+	for (; n < e.length && !t(e[n]);) n++;
+	return e.slice(0, n) + e.slice(n, n + 1).toUpperCase() + e.slice(n + 1).toLowerCase();
+}
+function a(e) {
+	let t = e.toLowerCase();
+	return t.length === e.length ? t : Array.from(e, (e) => {
+		let t = e.toLowerCase();
+		return t.length === e.length ? t : e;
+	}).join("");
+}
+function o(e, a, o, s) {
+	if (!e) return e;
+	let c = a.slice(o, s), l = Array.from(c).filter(t);
+	if (!l.length) return n(a[s] ?? a[o - 1]) ? e.toUpperCase() : e;
+	if (!l.some(n)) return e;
+	if (c.length > 1 && c.length === e.length) return Array.from(e, (e, t) => n(c[t]) ? e.toUpperCase() : e).join("");
+	if (c.length > 1) return l.every(n) ? e.toUpperCase() : n(l[0]) ? i(e) : e;
+	if (Array.from(e).filter(t).length < 2) return e.toUpperCase();
+	let u = a[s];
+	return r(u) ? n(u) ? e.toUpperCase() : i(e) : r(a[o - 1]) ? e.toUpperCase() : i(e);
+}
+function s(e, r) {
+	if (r === e.key) return e.target;
+	let a = Array.from(r).filter(t);
+	return a.length && a.every(n) ? e.lower.toUpperCase() : n(a[0]) ? i(e.lower) : e.lower;
+}
+// src/engine/lexicon.ts
+var c = class {
+	words = /* @__PURE__ */ new Map();
+	stems = /* @__PURE__ */ new Map();
+	longestStem = 0;
+	add(e, t, [n, r]) {
+		let i = this[e];
+		i.has(t) || (i.set(t, {
+			key: n,
+			target: r,
+			lower: r.toLowerCase()
+		}), e === "stems" && (this.longestStem = Math.max(this.longestStem, t.length)));
+	}
+	find(e) {
+		let t = this.words.get(e);
+		if (t) return [t, e.length];
+		for (let t = Math.min(e.length, this.longestStem); t > 0; t--) {
+			let n = this.stems.get(e.slice(0, t));
+			if (n) return [n, t];
+		}
+	}
+	clear() {
+		this.words.clear(), this.stems.clear(), this.longestStem = 0;
+	}
+}, l = /[\p{L}\p{M}ʻʼ’'`‘´]+/u, u = class {
+	normalize;
+	letters;
+	longestLetter;
+	rules;
+	skip;
+	word;
+	isWord;
+	wordExceptions = new c();
+	tokenExceptions = new c();
+	constructor(e) {
+		let t = e.word ?? l, n = (e, t = "") => e.flags.replace(/[gy]/g, "") + t;
+		this.normalize = e.normalize ?? ((e) => e), this.letters = new Map(e.letters.map(([e, t]) => [this.prepare(e), t])), this.longestLetter = Math.max(0, ...Array.from(this.letters.keys(), (e) => e.length)), this.rules = (e.rules ?? []).map(([e, t]) => [new RegExp(e.source, n(e, "g")), t]), this.skip = (e.skip ?? []).map((e) => {
+			if (typeof e == "function") return e;
+			let t = new RegExp(e.source, n(e));
+			return (e) => t.test(e);
+		}), this.word = new RegExp(t.source, n(t, "g")), this.isWord = RegExp(`^(?:${t.source})$`, n(t)), this.addExceptions(e);
+	}
+	addExceptions({ words: e = [], stems: t = [] }) {
+		for (let [n, r] of [["words", e], ["stems", t]]) for (let e of r) {
+			let t = this.prepare(e[0]);
+			(this.isWord.test(t) ? this.wordExceptions : this.tokenExceptions).add(n, t, e);
+		}
+	}
+	clearExceptions() {
+		this.wordExceptions.clear(), this.tokenExceptions.clear();
+	}
+	transliterate(e) {
+		return e.replace(/\S+/g, (e) => this.transliterateToken(e));
+	}
+	transliterateToken(e) {
+		if (this.skip.some((t) => t(e))) return e;
+		let t = this.tokenExceptions.find(this.prepare(e));
+		if (t) {
+			let [n, r] = t;
+			return s(n, e.slice(0, r)) + this.transliterateWords(e.slice(r));
+		}
+		return this.transliterateWords(e);
+	}
+	transliterateWords(e) {
+		return e.replace(this.word, (e) => this.transliterateWord(e));
+	}
+	transliterateWord(e) {
+		let t = this.prepare(e), n = "", r = 0, i = this.wordExceptions.find(t);
+		if (i) {
+			let [t, a] = i;
+			n = s(t, e.slice(0, a)), r = a;
+		}
+		let a = this.matchRules(t, r);
+		for (; r < t.length;) {
+			let i = 0, s, c = a?.get(r);
+			if (c) [i, s] = c;
+			else for (i = Math.min(this.longestLetter, t.length - r); i > 0 && (s = this.letters.get(t.slice(r, r + i)), s === void 0); i--);
+			s === void 0 ? n += e[r++] : (n += o(s, e, r, r + i), r += i);
+		}
+		return n;
+	}
+	matchRules(e, t) {
+		let n;
+		for (let [r, i] of this.rules) {
+			r.lastIndex = t;
+			for (let t = r.exec(e); t; t = r.exec(e)) t[0] && !n?.has(t.index) && (n ||= /* @__PURE__ */ new Map(), n.set(t.index, [t[0].length, typeof i == "function" ? i(t) : i])), r.lastIndex = t.index + 1;
+		}
+		return n;
+	}
+	prepare(e) {
+		let t = this.normalize(a(e));
+		if (t.length !== e.length) throw Error("normalize() must not change the length of a word");
+		return t;
+	}
+};
+function d(...e) {
+	return (t) => e.reduce((e, t) => t(e), t);
+}
+// src/skip.ts
+var f = "list" in e ? e : e.default, p = /[.:@/]/;
+function m(e) {
+	return p.test(e) && f.list(e).length > 0;
+}
+var h = /^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})(\.|\))?$/, g = (e) => e.replace(/[ʻʼ’'`‘´]/g, "ʼ"), _ = (e) => g(e).replace(/([og])ʼ/gi, "$1‘"), v = "аоэеиуўёюя", y = {
+	letters: [
+		["a", "а"],
+		["b", "б"],
+		["d", "д"],
+		["e", "е"],
+		["f", "ф"],
+		["g", "г"],
+		["h", "ҳ"],
+		["i", "и"],
+		["j", "ж"],
+		["k", "к"],
+		["l", "л"],
+		["m", "м"],
+		["n", "н"],
+		["o", "о"],
+		["p", "п"],
+		["q", "қ"],
+		["r", "р"],
+		["s", "с"],
+		["t", "т"],
+		["u", "у"],
+		["v", "в"],
+		["x", "х"],
+		["y", "й"],
+		["z", "з"],
+		["sh", "ш"],
+		["ch", "ч"],
+		["oʼ", "ў"],
+		["gʼ", "ғ"],
+		["ye", "е"],
+		["yo", "ё"],
+		["yu", "ю"],
+		["ya", "я"],
+		["ʼ", "ъ"],
+		["ee", "еэ"],
+		["yee", "еэ"],
+		["yoʼ", "йў"]
+	],
+	rules: [
+		[/^e/, "э"],
+		[/ts(?=i(on|ya))/, "ц"],
+		[/(?<=s)ʼ(?=h)/, ""]
+	],
+	normalize: g,
+	skip: [h, m]
+}, b = {
+	letters: [
+		["а", "a"],
+		["б", "b"],
+		["в", "v"],
+		["г", "g"],
+		["д", "d"],
+		["е", "e"],
+		["ё", "yo"],
+		["ж", "j"],
+		["з", "z"],
+		["и", "i"],
+		["й", "y"],
+		["к", "k"],
+		["л", "l"],
+		["м", "m"],
+		["н", "n"],
+		["о", "o"],
+		["п", "p"],
+		["р", "r"],
+		["с", "s"],
+		["т", "t"],
+		["у", "u"],
+		["ф", "f"],
+		["х", "x"],
+		["ц", "s"],
+		["ч", "ch"],
+		["ш", "sh"],
+		["ъ", "ʼ"],
+		["ь", ""],
+		["э", "e"],
+		["ю", "yu"],
+		["я", "ya"],
+		["ў", "o‘"],
+		["қ", "q"],
+		["ғ", "g‘"],
+		["ҳ", "h"]
+	],
+	rules: [
+		[/^е/, "ye"],
+		[/е{3,}/, (e) => "e".repeat(e[0].length)],
+		[RegExp(`(?<=[${v}ьъ])е`), "ye"],
+		[/(?<=[ўғ])ъ|ъ(?=е)/, ""],
+		[/(?<=ь)о/, "yo"],
+		[RegExp(`(?<=[${v}aeiou])ц`), "ts"],
+		[/(?<=с)ҳ/, "ʼh"]
+	],
+	skip: [h, m]
+}, x = {
+	letters: [
+		["sh", "ş"],
+		["ch", "ç"],
+		["oʼ", "ö"],
+		["gʼ", "ğ"]
+	],
+	rules: [[/(?<=s)ʼ(?=h)/, ""]],
+	normalize: g,
+	skip: [h, m]
+}, S = {
+	letters: [
+		["ş", "sh"],
+		["ç", "ch"],
+		["ö", "o‘"],
+		["ğ", "g‘"]
+	],
+	rules: [[/(?<=s)h/, "ʼh"]],
+	skip: [h, m]
+}, C = [
+	"latin1995",
+	"latin2026",
+	"cyrillic"
+];
+function w({ exceptions: e = [] } = {}) {
+	let t = {
+		latin1995ToCyrillic: new u(y),
+		cyrillicToLatin1995: new u(b),
+		latin1995ToLatin2026: new u(x),
+		latin2026ToLatin1995: new u(S)
+	}, n = (e) => t.latin1995ToCyrillic.transliterate(e), r = (e) => t.cyrillicToLatin1995.transliterate(e), i = (e) => t.latin1995ToLatin2026.transliterate(e), a = (e) => t.latin2026ToLatin1995.transliterate(e), o = (e) => e, s = {
+		latin1995: {
+			latin1995: o,
+			latin2026: i,
+			cyrillic: n
+		},
+		latin2026: {
+			latin1995: a,
+			latin2026: o,
+			cyrillic: d(a, n)
+		},
+		cyrillic: {
+			latin1995: r,
+			latin2026: d(r, i),
+			cyrillic: o
+		}
+	}, c = {
+		transliterate(e, { from: t, to: n }) {
+			for (let e of [t, n]) if (!C.includes(e)) throw Error(`Unknown alphabet: ${e}`);
+			return s[t][n](e);
+		},
+		addExceptions(e) {
+			for (let n of e) {
+				let { cyrillic: e, latin2026: r } = n;
+				if ([
+					n.latin1995,
+					e,
+					r
+				].filter(Boolean).length < 2) throw Error(`Invalid exceptional word ${JSON.stringify(n)}`);
+				let i = n.latin1995 || a(r), o = _(i);
+				if (e) {
+					let n = e.replace(/ь$/i, "");
+					t.latin1995ToCyrillic.addExceptions({
+						words: [[i, e]],
+						stems: [[i, n]]
+					}), t.cyrillicToLatin1995.addExceptions({
+						words: [[e, o]],
+						stems: [[e, o], [n, o]]
+					});
+				}
+				r && (t.latin1995ToLatin2026.addExceptions({ stems: [[i, r]] }), t.latin2026ToLatin1995.addExceptions({ stems: [[r, o]] }));
+			}
+		},
+		clearExceptions() {
+			for (let e of Object.values(t)) e.clearExceptions();
+		}
+	};
+	return c.addExceptions(e), c;
+}
+export { w as createTransliterator };