taraskevizer 9.2.3 → 9.3.0

package/dist/bin.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { dicts, TaraskConfig, tarask, pipelines, htmlConfigOptions, wrappers, } from './index.js';
 const printWithPrefix = (msg) => {
-    process.stdout.write("[taraskevizer]" + msg + '\n');
+    process.stdout.write("[taraskevizer]" + ' ' + msg + '\n');
 };
 process.argv.splice(0, 2);
 const checkForOptions = (options) => process.argv[0] && options.includes(process.argv[0].toLowerCase());
 if (checkForOptions(['-v', '--version'])) {
-    printWithPrefix("9.2.3");
+    printWithPrefix("9.3.0");
     process.exit(0);
 }
 if (checkForOptions(['-h', '--help'])) {
@@ -66,7 +66,7 @@ let cfg = {
 let mode = 'tar';
 const toHashTable = (dict) => {
     const result = {};
-    for (const [options, callback] of dict)
+    for (const { 0: options, 1: callback } of dict)
         for (const option of options)
             result[option] = callback;
     return result;

package/dist/dict/alphabets/arabic.d.ts

@@ -1,3 +1,3 @@
 export declare const arabic: {
-    lower: import("..").Dict;
+    lower: import("..").CallableDict;
 };

package/dist/dict/alphabets/arabic.js

@@ -1,62 +1,65 @@
-import { dictFrom } from '../lib.js';
+import { callableDict, regexGI } from '../lib.js';
 const soft = '\u0652(?=[еёіюяь])';
 const presoft = '([تزكثࢮбвгджзйклмнпрстфхцчшў])\u0652?(\u0651?)';
 
 export const arabic = {
-    lower: dictFrom.raw([
-        [/ л[ая]/, ' لا'],
-        [/л[ая]/, 'ـلا'],
+    lower: callableDict([
+        [/ [Лл][АаЯя]/g, ' لا'],
+        [/[Лл][АаЯя]/g, 'ـلا'],
         // падваеньне зычнага, шадда
-        [/([бвгджзйклмнпрстфхцчшў]|д[зж])\1/, '$1\u0651'],
+        [
+            /([БбВвГгДдЖжЗзЙйКкЛлМмНнПпРрСсТтФфХхЦцЧчШшЎў]|[Дд][ЗзЖж])\1/g,
+            '$1\u0651',
+        ],
         // няма галоснага, сукун
-        [/([бвгджзйклмнпрстфхцчшў])/, '$1\u0652'],
+        [/([БбВвГгДдЖжЗзЙйКкЛлМмНнПпРрСсТтФфХхЦцЧчШшЎў])/g, '$1\u0652'],
         // а, аліф
-        [/а/, '\u0627а'],
+        [/[Аа]/g, '\u0627а'],
         // першая галосная, аліф
-        [/ (?=[еэыуо])/, ' \u0627'],
-        ['д\u0652з' + soft, 'ࢮ'],
-        ['з' + soft, 'ز'],
-        ['к' + soft, 'ك'],
-        ['с' + soft, 'ث'],
-        ['т' + soft, 'ت'],
-        [/([تزكث])і/, 'ы'],
+        [/ (?=[ЕеЭэЫыУуОо])/g, ' \u0627'],
+        [regexGI('д\u0652з' + soft), 'ࢮ'],
+        [regexGI('з' + soft), 'ز'],
+        [regexGI('к' + soft), 'ك'],
+        [regexGI('с' + soft), 'ث'],
+        [regexGI('т' + soft), 'ت'],
+        [/([تزكث])[Іі]/g, 'ы'],
         // $2 - шадда
-        [presoft + '[аяэе]', '$1$2\u064E'],
-        [presoft + '[іы]', '$1$2\u0650'],
-        [/ і /, ' \u0627\u0650 '],
-        [presoft + '[оёую]', '$1$2\u064F'],
-        [/ʼ/, 'ع'],
-        [/ь/, ''],
-        // [/[ьʼ]/, ''],
-        [/[яе]/, 'ي\u064E'],
-        [/і/, 'ي\u0650'],
-        [/[ёю]/, 'ي\u064F'],
-        [/[аэ]/, '\u064E'],
-        [/[ыі]/, '\u0650'],
-        [/[оу]/, '\u064F'],
-        [/б/, 'ب'],
-        [/[вў]/, 'و'],
-        [/г/, 'ه'],
-        [/ґ/, 'غ'],
-        [/д\u0652ж/, 'ج'],
-        [/д/, 'د'],
-        [/ж/, 'ژ'],
-        [/з/, 'ض'],
-        [/й/, 'ي'],
-        [/к/, 'ق'],
-        [/л/, 'ل'],
-        [/м/, 'م'],
-        [/н/, 'ن'],
-        [/п/, 'پ'],
-        [/р/, 'ر'],
-        [/с/, 'ص'],
-        [/т/, 'ط'],
-        [/ф/, 'ف'],
-        [/х/, 'ح'],
-        [/ц/, 'ࢯ'],
-        [/ч/, 'چ'],
-        [/ш/, 'ش'],
-        [/,/, '،'],
-        [/\?/, '؟'],
-    ], 'gi'),
+        [regexGI(presoft + '[аяэе]'), '$1$2\u064E'],
+        [regexGI(presoft + '[іы]'), '$1$2\u0650'],
+        [/ [Iі] /g, ' \u0627\u0650 '],
+        [regexGI(presoft + '[оёую]'), '$1$2\u064F'],
+        [/[ʼ]/g, 'ع'],
+        [/[Ьь]/g, ''],
+        // [/[ьʼ]/g, ''],
+        [/[ЯяЕе]/g, 'ي\u064E'],
+        [/[Іі]/g, 'ي\u0650'],
+        [/[ЁёЮю]/g, 'ي\u064F'],
+        [/[АаЭэ]/g, '\u064E'],
+        [/[ЫыІі]/g, '\u0650'],
+        [/[ОоУу]/g, '\u064F'],
+        [/[Бб]/g, 'ب'],
+        [/[ВвЎў]/g, 'و'],
+        [/[Гг]/g, 'ه'],
+        [/[Ґґ]/g, 'غ'],
+        [/д\u0652ж/gi, 'ج'],
+        [/[Дд]/g, 'د'],
+        [/[Жж]/g, 'ژ'],
+        [/[Зз]/g, 'ض'],
+        [/[Йй]/g, 'ي'],
+        [/[Кк]/g, 'ق'],
+        [/[Лл]/g, 'ل'],
+        [/[Мм]/g, 'م'],
+        [/[Нн]/g, 'ن'],
+        [/[Пп]/g, 'پ'],
+        [/[Рр]/g, 'ر'],
+        [/[Сс]/g, 'ص'],
+        [/[Тт]/g, 'ط'],
+        [/[Фф]/g, 'ف'],
+        [/[Хх]/g, 'ح'],
+        [/[Цц]/g, 'ࢯ'],
+        [/[Чч]/g, 'چ'],
+        [/[Шш]/g, 'ش'],
+        [/[,]/g, '،'],
+        [/\?/g, '؟'],
+    ]),
 };

package/dist/dict/alphabets/cyrillic.d.ts

@@ -1,4 +1,4 @@
 export declare const cyrillic: {
-    readonly lower: readonly [];
-    readonly upper: readonly [];
+    readonly lower: import("..").CallableDict;
+    readonly upper: import("..").CallableDict;
 };

package/dist/dict/alphabets/cyrillic.js

@@ -1,4 +1,5 @@
+import { callableDict } from '../lib.js';
 export const cyrillic = {
-    lower: [],
-    upper: [],
+    lower: callableDict([]),
+    upper: callableDict([]),
 };

package/dist/dict/alphabets/latin.d.ts

@@ -1,8 +1,8 @@
 export declare const latin: {
-    lower: (readonly [RegExp, string])[];
-    upper: (readonly [RegExp, string])[];
+    lower: import("../types").CallableDict;
+    upper: import("../types").CallableDict;
 };
 export declare const latinJi: {
-    lower: (readonly [RegExp, string])[];
-    upper: (readonly [RegExp, string])[];
+    lower: import("../types").CallableDict;
+    upper: import("../types").CallableDict;
 };

package/dist/dict/alphabets/latin.js

@@ -1,141 +1,138 @@
 import { iwords } from '../iwords.js';
-import { dictFrom } from '../lib.js';
+import { callableDict, regexG } from '../lib.js';
 const common = {
     lower: [
         [
-            [/(?<=[аеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)е/, 'je'],
-            [/(?<=[eаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)ё/, 'jo'],
-            [/(?<=[eoаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)ю/, 'ju'],
-            [/(?<=[eouаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)я/, 'ja'],
+            [/(?<=[аеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)е/g, 'je'],
+            [/(?<=[eаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)ё/g, 'jo'],
+            [/(?<=[eoаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)ю/g, 'ju'],
+            [/(?<=[eouаеёіоуўыэюяьʼ| >АЕЁІОУЎЫЭЮЯЬ]|^)я/g, 'ja'],
         ],
         [
-            [/ʼ/, ''],
-            [/ць/, 'ć'],
-            [/зь/, 'ź'],
-            [/сь/, 'ś'],
-            [/нь/, 'ń'],
-            [/ль/, 'l'],
-            [/а/, 'a'],
-            [/б/, 'b'],
-            [/в/, 'v'],
-            [/г/, 'h'],
-            [/ґ/, 'g'],
-            [/д/, 'd'],
-            [/е/, 'ie'],
-            [/ё/, 'io'],
-            [/ж/, 'ž'],
-            [/з/, 'z'],
-            [/і/, 'i'],
-            [/й/, 'j'],
-            [/к/, 'k'],
-            [/л/, 'ł'],
-            [/м/, 'm'],
-            [/н/, 'n'],
-            [/о/, 'o'],
-            [/п/, 'p'],
-            [/р/, 'r'],
-            [/с/, 's'],
-            [/т/, 't'],
-            [/у/, 'u'],
-            [/ў/, 'ŭ'],
-            [/ф/, 'f'],
-            [/х/, 'ch'],
-            [/ц/, 'c'],
-            [/ч/, 'č'],
-            [/ш/, 'š'],
-            [/ы/, 'y'],
-            [/э/, 'e'],
-            [/ю/, 'iu'],
-            [/я/, 'ia'],
-            [/łi(?=[eoua])/, 'l'],
-            [/łi/, 'li'],
+            [/ʼ/g, ''],
+            [/ць/g, 'ć'],
+            [/зь/g, 'ź'],
+            [/сь/g, 'ś'],
+            [/нь/g, 'ń'],
+            [/ль/g, 'l'],
+            [/а/g, 'a'],
+            [/б/g, 'b'],
+            [/в/g, 'v'],
+            [/г/g, 'h'],
+            [/ґ/g, 'g'],
+            [/д/g, 'd'],
+            [/е/g, 'ie'],
+            [/ё/g, 'io'],
+            [/ж/g, 'ž'],
+            [/з/g, 'z'],
+            [/і/g, 'i'],
+            [/й/g, 'j'],
+            [/к/g, 'k'],
+            [/л/g, 'ł'],
+            [/м/g, 'm'],
+            [/н/g, 'n'],
+            [/о/g, 'o'],
+            [/п/g, 'p'],
+            [/р/g, 'r'],
+            [/с/g, 's'],
+            [/т/g, 't'],
+            [/у/g, 'u'],
+            [/ў/g, 'ŭ'],
+            [/ф/g, 'f'],
+            [/х/g, 'ch'],
+            [/ц/g, 'c'],
+            [/ч/g, 'č'],
+            [/ш/g, 'š'],
+            [/ы/g, 'y'],
+            [/э/g, 'e'],
+            [/ю/g, 'iu'],
+            [/я/g, 'ia'],
+            [/łi(?=[eoua])/g, 'l'],
+            [/łi/g, 'li'],
         ],
-    ].map(dictFrom.nonGlobal),
+    ],
     upper: [
         [
-            [/ Е(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/u, ' Je'],
-            [/ Ё(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/u, ' Jo'],
-            [/ Ю(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/u, ' Ju'],
-            [/ Я(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/u, ' Ja'],
+            [/ Е(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/gu, ' Je'],
+            [/ Ё(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/gu, ' Jo'],
+            [/ Ю(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/gu, ' Ju'],
+            [/ Я(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/gu, ' Ja'],
         ],
         [
-            [/([АЕЁІОУЎЫЭЮЯЬ| ]\(?)Е/, '$1JE'],
-            [/([EАЕЁІОУЎЫЭЮЯЬ| ]\(?)Ё/, '$1JO'],
-            [/([EOАЕЁІОУЎЫЭЮЯЬ| ]\(?)Ю/, '$1JU'],
-            [/([EOUАЕЁІОУЎЫЭЮЯЬ| ]\(?)Я/, '$1JA'],
+            [/([АЕЁІОУЎЫЭЮЯЬ| ]\(?)Е/g, '$1JE'],
+            [/([EАЕЁІОУЎЫЭЮЯЬ| ]\(?)Ё/g, '$1JO'],
+            [/([EOАЕЁІОУЎЫЭЮЯЬ| ]\(?)Ю/g, '$1JU'],
+            [/([EOUАЕЁІОУЎЫЭЮЯЬ| ]\(?)Я/g, '$1JA'],
         ],
         [
-            [/Е/, 'IE'],
-            [/Ё/, 'IO'],
-            [/Ю/, 'IU'],
-            [/Я/, 'IA'],
-            [/Ц[Ьь]/, 'Ć'],
-            [/З[Ьь]/, 'Ź'],
-            [/С[Ьь]/, 'Ś'],
-            [/Н[Ьь]/, 'Ń'],
-            [/Л[Ьь]/, 'L'],
-            [/А/, 'A'],
-            [/Б/, 'B'],
-            [/В/, 'V'],
-            [/Г/, 'H'],
-            [/Ґ/, 'G'],
-            [/Д/, 'D'],
-            [/Ж/, 'Ž'],
-            [/З/, 'Z'],
-            [/І/, 'I'],
-            [/Й/, 'J'],
-            [/К/, 'K'],
-            [/Л/, 'Ł'],
-            [/М/, 'M'],
-            [/Н/, 'N'],
-            [/О/, 'O'],
-            [/П/, 'P'],
-            [/Р/, 'R'],
-            [/С/, 'S'],
-            [/Т/, 'T'],
-            [/У/, 'U'],
-            [/Ў/, 'Ŭ'],
-            [/Ф/, 'F'],
-            [/ Х(?=[\p{Ll} ])/u, ' Ch'],
-            [/Х/, 'CH'],
-            [/Ц/, 'C'],
-            [/Ч/, 'Č'],
-            [/Ш/, 'Š'],
-            [/Ы/, 'Y'],
-            [/Э/, 'E'],
-            [/Ł[Ii](?=[AEOUaeou])/, 'L'],
-            [/Ł(?=[Ii])/, 'L'],
+            [/Е/g, 'IE'],
+            [/Ё/g, 'IO'],
+            [/Ю/g, 'IU'],
+            [/Я/g, 'IA'],
+            [/Ц[Ьь]/g, 'Ć'],
+            [/З[Ьь]/g, 'Ź'],
+            [/С[Ьь]/g, 'Ś'],
+            [/Н[Ьь]/g, 'Ń'],
+            [/Л[Ьь]/g, 'L'],
+            [/А/g, 'A'],
+            [/Б/g, 'B'],
+            [/В/g, 'V'],
+            [/Г/g, 'H'],
+            [/Ґ/g, 'G'],
+            [/Д/g, 'D'],
+            [/Ж/g, 'Ž'],
+            [/З/g, 'Z'],
+            [/І/g, 'I'],
+            [/Й/g, 'J'],
+            [/К/g, 'K'],
+            [/Л/g, 'Ł'],
+            [/М/g, 'M'],
+            [/Н/g, 'N'],
+            [/О/g, 'O'],
+            [/П/g, 'P'],
+            [/Р/g, 'R'],
+            [/С/g, 'S'],
+            [/Т/g, 'T'],
+            [/У/g, 'U'],
+            [/Ў/g, 'Ŭ'],
+            [/Ф/g, 'F'],
+            [/ Х(?=[\p{Ll} ])/gu, ' Ch'],
+            [/Х/g, 'CH'],
+            [/Ц/g, 'C'],
+            [/Ч/g, 'Č'],
+            [/Ш/g, 'Š'],
+            [/Ы/g, 'Y'],
+            [/Э/g, 'E'],
+            [/Ł[Ii](?=[AEOUaeou])/g, 'L'],
+            [/Ł(?=[Ii])/g, 'L'],
         ],
-    ].map(dictFrom.nonGlobal),
+    ],
 };
 export const latin = {
-    lower: [...common.lower[0], [/ʼі/g, 'ji'], ...common.lower[1]],
-    upper: common.upper.flat(),
+    lower: callableDict([...common.lower[0], [/ʼі/g, 'ji'], ...common.lower[1]]),
+    upper: callableDict(common.upper.flat()),
 };
 export const latinJi = {
-    lower: dictFrom
-        .raw([
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і Ў/, '$1j U'],
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і ў/, '$1j u'],
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і /, '$1j '],
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І Ў/, '$1J U'],
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І ў/, '$1J u'],
-        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І /, '$1J '],
-        [` і(?=${iwords})`, ' ji'],
-        [` І(?=${iwords})`, ' Ji'],
-        [` І(?=${iwords.toUpperCase()})`, ' JI'],
-    ])
-        .concat([
+    lower: callableDict([
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і Ў/g, '$1j U'],
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і ў/g, '$1j u'],
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )і /g, '$1j '],
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І Ў/g, '$1J U'],
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І ў/g, '$1J u'],
+        [/([аеёіоуыэюяАЕЁІОУЫЭЮЯ] )І /g, '$1J '],
+        [regexG(` і(?=${iwords})`), ' ji'],
+        [regexG(` І(?=${iwords})`), ' Ji'],
+        [regexG(` І(?=${iwords.toUpperCase()})`), ' JI'],
         ...common.lower[0],
         [/([eouaаеёіоуыэюяʼАЕЁІОУЫЭЮЯЬ] *)і/g, '$1ji'],
         ...common.lower[1],
     ]),
-    upper: [
+    upper: callableDict([
         ...common.upper[0],
         [/([eoua] *)І(?=[ \p{P}\d]*\p{Lu}?\p{Ll})/gu, '$1Ji'],
         ...common.upper[1],
         [/([AOEUАЕЁІОУЎЫЭЮЯ][( ]*)І/g, '$1JI'],
         ...common.upper[2],
         [/ JIŁ -/g, ' IŁ -'],
-    ],
+    ]),
 };

package/dist/dict/alphabets/types.d.ts

@@ -1,4 +1,4 @@
-import type { Dict } from '../types';
+import type { CallableDict } from '../types';
 /**
  * If {@link Alphabet.upper} in not defined,
  * it is assumed that the alphabet is case-insensitive,
@@ -6,6 +6,6 @@ import type { Dict } from '../types';
  * upper and lower case letters.
  */
 export type Alphabet = {
-    lower: Dict;
-    upper?: Dict;
+    lower: CallableDict;
+    upper?: CallableDict;
 };

package/dist/dict/iawords.d.ts

@@ -1 +1 @@
-export declare const iaWords: import("./types").Dict;
+export declare const iaWords: import("./types").CallableDict;

package/dist/dict/iawords.js

@@ -1,7 +1,7 @@
 import { iwords } from './iwords.js';
-import { dictFrom, toOneLine } from './lib.js';
-const ia = (word, words) => ` ${word}(?= \\(?(?:[бвгджзйклмнпрстфхцчшўьʼ]*[оё]|${toOneLine(words).replace(/\(/g, '(?:')}|i(?:${iwords})))`;
-export const iaWords = dictFrom.raw([
+import { callableDict, regexG, toOneLine } from './lib.js';
+const ia = (word, words) => regexG(` ${word}(?= \\(?(?:[бвгджзйклмнпрстфхцчшўьʼ]*[оё]|${toOneLine(words).replace(/\(/g, '(?:')}|i(?:${iwords})))`);
+export const iaWords = callableDict([
     
     [
         ia('не', `(вы)?(бач[ауы]

package/dist/dict/lib.d.ts

@@ -1,4 +1,4 @@
-import type { Dict, RawDict, WritableDict } from './types';
+import type { CallableDict, Dict } from './types';
 export declare const copyDict: <T extends [any, any][]>(dict: T) => T;
 /**
  * Collection of MUTATING functions
@@ -12,14 +12,10 @@ export declare const copyDict: <T extends [any, any][]>(dict: T) => T;
  *   ["pattern", "result"],
  * ];
  *
- * const dict = dictFrom.raw(copyDict(rawDict));
+ * const dict = dict.raw(copyDict(rawDict));
  * // [ [ /pattern/g, "result" ] ]
  */
-export declare const dictFrom: {
-    raw: (dict: RawDict, additionalFlags?: string) => Dict;
-    /**
-     * Adds the global flag to all patterns in the dictionary.
-     */
-    nonGlobal: (dict: WritableDict) => Dict;
-};
+export declare const callableDict: (dict: Dict) => CallableDict;
 export declare const toOneLine: (str: string) => string;
+export declare const regexG: (pattern: string) => RegExp;
+export declare const regexGI: (pattern: string) => RegExp;

package/dist/dict/lib.js

@@ -1,18 +1,10 @@
-export const copyDict = (dict) => dict.map(([pattern, result]) => [pattern, result]);
+export const copyDict = (dict) => dict.map(({ 0: pattern, 1: result }) => [pattern, result]);
 
-export const dictFrom = {
-    raw: (dict, additionalFlags = 'g') => {
-        for (const item of dict)
-            item[0] = RegExp(item[0], item[0] instanceof RegExp
-                ? item[0].flags + additionalFlags
-                : additionalFlags);
-        return dict;
-    },
-    
-    nonGlobal: (dict) => {
-        for (const item of dict)
-            item[0] = RegExp(item[0], 'g' + item[0].flags);
-        return dict;
-    },
+export const callableDict = (dict) => {
+    const fn = (text) => fn.value.reduce((acc, item) => acc.replace(item[0], item[1]), text);
+    fn.value = dict;
+    return fn;
 };
 export const toOneLine = (str) => str.replace(/\n/g, '|');
+export const regexG = (pattern) => new RegExp(pattern, 'g');
+export const regexGI = (pattern) => new RegExp(pattern, 'gi');

package/dist/dict/phonetic.d.ts

@@ -1,3 +1,3 @@
 import type { Dict } from './types';
 export declare const commonPhonetic: Dict;
-export declare const phonetic: Dict;
+export declare const phonetic: import("./types").CallableDict;

package/dist/dict/phonetic.js

@@ -1,12 +1,13 @@
+import { callableDict } from './lib.js';
 export const commonPhonetic = [
     [/шся /g, 'сься '],
     [/здж/g, 'ждж'],
-    [/ ([бд]|кнд|нот)р /, ' $1\ue0ffр '],
-    [/(\S\S[дт])р /, '$1ар '],
+    [/ ([бд]|кнд|нот)р /g, ' $1\ue0ffр '],
+    [/(\S\S[дт])р /g, '$1ар '],
 ];
-export const phonetic = [
+export const phonetic = callableDict([
     [/сш/g, 'шш'],
     [/[зс]ч/g, 'шч'],
     [/чц(?![ьіеюя])/g, 'цц'],
     [/[жш]ц(?=ы )/g, 'сц'],
-].concat(commonPhonetic);
+].concat(commonPhonetic));

package/dist/dict/softening.d.ts

@@ -1,2 +1,2 @@
-export declare const noSoften: import("./types").Dict;
-export declare const softeners: import("./types").Dict;
+export declare const noSoften: import("./types").CallableDict;
+export declare const softeners: import("./types").CallableDict;

package/dist/dict/softening.js

@@ -1,19 +1,19 @@
-import { dictFrom } from './lib.js';
+import { callableDict, regexG } from './lib.js';
 import { iwords } from './iwords.js';
-export const noSoften = dictFrom.nonGlobal([
-    [/масфільм/, 'мас\ue0ffфільм'],
-    [/пэндзлік/, 'пэндз\ue0ffлік'],
-    [/ ((?:[пн]|пе?р)?)аддз/, ' $1ад\ue0ffдз'],
+export const noSoften = callableDict([
+    [/масфільм/g, 'мас\ue0ffфільм'],
+    [/пэндзлік/g, 'пэндз\ue0ffлік'],
+    [/ ((?:[пн]|пе?р)?)аддз/g, ' $1ад\ue0ffдз'],
 ]);
-export const softeners = dictFrom.raw([
-    [/([лнц])\1(?=[еёіюяь])/, '$1ь$1'],
-    [/(\S\S)дз?дз(?=[еёіюяь])/, '$1дзьдз'],
-    [/з(?=(?:[бвзлмнц]|дз)[еёіюяь])/, 'зь'],
-    [/с(?=[бвлмнпсфц][еёіюяь])/, 'сь'],
-    [/ц(?=[вм][еёіюяь])/, 'ць'],
+export const softeners = callableDict([
+    [/([лнц])\1(?=[еёіюяь])/g, '$1ь$1'],
+    [/(\S\S)дз?дз(?=[еёіюяь])/g, '$1дзьдз'],
+    [/з(?=(?:[бвзлмнц]|дз)[еёіюяь])/g, 'зь'],
+    [/с(?=[бвлмнпсфц][еёіюяь])/g, 'сь'],
+    [/ц(?=[вм][еёіюяь])/g, 'ць'],
     [
-        `( (?:б[ея]|пра|цера)?з) (?=\\(?)(?=[еёюяь]|([бвзйлмнпстфц]|дз)[еёіюяь]|імі? |іх(?:ні)?|і(?:${iwords}))`,
+        regexG(`( (?:б[ея]|пра|цера)?з) (?=\\(?)(?=[еёюяь]|([бвзйлмнпстфц]|дз)[еёіюяь]|імі? |іх(?:ні)?|і(?:${iwords}))`),
         '$1ь ',
     ],
-    [/([сз])ʼ(?=[яюеё])/, '$1ь'],
+    [/([сз])ʼ(?=[яюеё])/g, '$1ь'],
 ]);

package/dist/dict/types.d.ts

@@ -1,15 +1,13 @@
+export type Callable<Value> = {
+    (value: string): string;
+    value: Value;
+};
 export type Dict<T = RegExp> = readonly (readonly [T, string])[];
+export type CallableDict<T = RegExp> = Callable<Dict<T>>;
 /**
  * Useful if you want to modify the dictionary.
  *
- * Consider converting it to the type {@link Dict}
+ * Consider converting it to the type {@link CallableDict}
  * if you no longer need to modify it.
  */
 export type WritableDict<T = RegExp> = [T, string][];
-/**
- * useful if you use variables in patterns.
- *
- * Don't forget to convert it to the type {@link Dict},
- * {@link lib.dictFrom} can help you with this.
- */
-export type RawDict = WritableDict<string | RegExp>;

package/dist/dict/wordlist.d.ts

@@ -1,2 +1 @@
-import type { Dict } from "./types";
-export declare const wordlist: Dict;
+export declare const wordlist: import("./types").CallableDict;