taraskevizer 6.1.19 → 7.0.1

package/dist/index.d.ts

@@ -1,10 +1,15 @@
 type Dict<T = RegExp> = readonly (readonly [T, string])[];
+type WritableDict<T = RegExp> = [T, string][];
+type RawDict = WritableDict<string | RegExp>;
 
 type ModifyObjectType<T, TResultObj> = T extends object ? T extends (...args: any[]) => any ? T : TResultObj : T;
 type DeepPartialReadonly<T> = ModifyObjectType<T, {
     readonly [P in keyof T]?: DeepPartialReadonly<T[P]>;
 }>;
-type Alphabet = 0 | 1 | 2 | 3;
+type Alphabet = {
+    lower: Dict;
+    upper?: Dict;
+};
 type OptionJ = 0 | 1 | 2;
 type Variation = 0 | 1 | 2;
 type TaraskOptions = {
@@ -25,6 +30,13 @@ type ExtendedDict = readonly (readonly [
     string | ((...substrings: string[]) => string)
 ])[];
 
+declare const latinLettersLowerCase: (readonly [RegExp, string])[];
+declare const latinLettersUpperCase: (readonly [RegExp, string])[];
+declare const latinLettersLowerCaseJi: (readonly [RegExp, string])[];
+declare const latinLettersUpperCaseJi: (readonly [RegExp, string])[];
+
+declare const arabLetters: Dict;
+
 declare const gobj: {
     readonly г: "ґ";
     readonly Г: "Ґ";
@@ -37,7 +49,25 @@ declare const wordlist: (readonly [RegExp, string])[];
 declare const noSoften: Dict;
 declare const softeners: Dict;
 
-declare class Taraskevizer {
+declare const index$2_arabLetters: typeof arabLetters;
+declare const index$2_gobj: typeof gobj;
+declare const index$2_latinLettersLowerCase: typeof latinLettersLowerCase;
+declare const index$2_latinLettersLowerCaseJi: typeof latinLettersLowerCaseJi;
+declare const index$2_latinLettersUpperCase: typeof latinLettersUpperCase;
+declare const index$2_latinLettersUpperCaseJi: typeof latinLettersUpperCaseJi;
+declare const index$2_noSoften: typeof noSoften;
+declare const index$2_softeners: typeof softeners;
+declare const index$2_wordlist: typeof wordlist;
+declare namespace index$2 {
+  export { index$2_arabLetters as arabLetters, index$2_gobj as gobj, index$2_latinLettersLowerCase as latinLettersLowerCase, index$2_latinLettersLowerCaseJi as latinLettersLowerCaseJi, index$2_latinLettersUpperCase as latinLettersUpperCase, index$2_latinLettersUpperCaseJi as latinLettersUpperCaseJi, index$2_noSoften as noSoften, index$2_softeners as softeners, index$2_wordlist as wordlist };
+}
+
+declare class TaraskConfig {
+    constructor(options?: DeepPartialReadonly<{
+        general: TaraskOptions;
+        html: HtmlOptions;
+        nonHtml: NonHtmlOptions;
+    }>);
     general: {
         abc: Alphabet;
         j: OptionJ;
@@ -51,28 +81,7 @@ declare class Taraskevizer {
         ansiColors: boolean;
         variations: Variation;
     };
-    private spaces;
-    restoreSpaces(text: string): string;
-    constructor(options?: DeepPartialReadonly<{
-        general: TaraskOptions;
-        html: HtmlOptions;
-        nonHtml: NonHtmlOptions;
-        taraskevize(this: Taraskevizer, text: string): string;
-    }>);
-    convert(text: string): string;
-    convertToHtml(text: string): string;
-    private prepare;
-    convertAlphabetOnly(text: string): string;
-    private process;
-    protected taraskevize(text: string): string;
 }
-
-declare const ALPHABET: {
-    readonly CYRILLIC: 0;
-    readonly LATIN: 1;
-    readonly ARABIC: 2;
-    readonly LATIN_JI: 3;
-};
 declare const REPLACE_J: {
     readonly NEVER: 0;
     readonly RANDOM: 1;
@@ -84,17 +93,162 @@ declare const VARIATION: {
     readonly ALL: 2;
 };
 
-declare const replaceWithDict: (text: string, dict?: ExtendedDict) => string;
+type TaraskStep<Storage = {}> = (text: string, args: {
+    storage: Storage;
+    cfg: TaraskConfig;
+}) => string;
+type SplittedTextStorage = {
+    text: string[];
+    orig: readonly string[];
+};
+
+declare const convertAlphabet: TaraskStep;
+declare const convertAlphabetLowerCase: TaraskStep;
+
+declare const highlightDiffStep: (highlight: (content: string) => string) => TaraskStep<SplittedTextStorage>;
+declare const highlightDiffNonHtmlStep: TaraskStep<SplittedTextStorage>;
+
+declare const applyHtmlVariations: TaraskStep;
+declare const applyHtmlG: TaraskStep;
+
+declare const replaceIbyJ: TaraskStep;
+
+declare const joinSplittedText: TaraskStep<SplittedTextStorage>;
+
+declare const applyNonHtmlVariations: TaraskStep;
+declare const applyNonHtmlG: TaraskStep;
+
+declare const prepare: TaraskStep;
+
+declare const applyNoFix: TaraskStep<SpecialSyntaxStorage>;
+declare const applyVariableParts: (callback: (arr: string[]) => string) => TaraskStep;
+type SpecialSyntaxStorage = {
+    noFixArr: string[];
+};
+declare const resolveSpecialSyntax: (leftAngleBracket: string) => TaraskStep<SpecialSyntaxStorage>;
+
+declare const restoreCaseStep: TaraskStep<SplittedTextStorage>;
+
+declare const storeSplittedAbcConvertedOrig: TaraskStep<SplittedTextStorage>;
+
+declare const storeSplittedText: TaraskStep<SplittedTextStorage>;
+
+declare const taraskevize: TaraskStep;
+
+type WhiteSpaceStorage = {
+    spaces: string[];
+    positions: number[];
+};
+declare const whitespacesToSpaces: TaraskStep<WhiteSpaceStorage>;
+declare const restoreWhitespaces: TaraskStep<WhiteSpaceStorage>;
+
+declare const trim: TaraskStep;
+
+type index$1_SplittedTextStorage = SplittedTextStorage;
+type index$1_TaraskStep<Storage = {}> = TaraskStep<Storage>;
+declare const index$1_applyHtmlG: typeof applyHtmlG;
+declare const index$1_applyHtmlVariations: typeof applyHtmlVariations;
+declare const index$1_applyNoFix: typeof applyNoFix;
+declare const index$1_applyNonHtmlG: typeof applyNonHtmlG;
+declare const index$1_applyNonHtmlVariations: typeof applyNonHtmlVariations;
+declare const index$1_applyVariableParts: typeof applyVariableParts;
+declare const index$1_convertAlphabet: typeof convertAlphabet;
+declare const index$1_convertAlphabetLowerCase: typeof convertAlphabetLowerCase;
+declare const index$1_highlightDiffNonHtmlStep: typeof highlightDiffNonHtmlStep;
+declare const index$1_highlightDiffStep: typeof highlightDiffStep;
+declare const index$1_joinSplittedText: typeof joinSplittedText;
+declare const index$1_prepare: typeof prepare;
+declare const index$1_replaceIbyJ: typeof replaceIbyJ;
+declare const index$1_resolveSpecialSyntax: typeof resolveSpecialSyntax;
+declare const index$1_restoreCaseStep: typeof restoreCaseStep;
+declare const index$1_restoreWhitespaces: typeof restoreWhitespaces;
+declare const index$1_storeSplittedAbcConvertedOrig: typeof storeSplittedAbcConvertedOrig;
+declare const index$1_storeSplittedText: typeof storeSplittedText;
+declare const index$1_taraskevize: typeof taraskevize;
+declare const index$1_trim: typeof trim;
+declare const index$1_whitespacesToSpaces: typeof whitespacesToSpaces;
+declare namespace index$1 {
+  export { type index$1_SplittedTextStorage as SplittedTextStorage, type index$1_TaraskStep as TaraskStep, index$1_applyHtmlG as applyHtmlG, index$1_applyHtmlVariations as applyHtmlVariations, index$1_applyNoFix as applyNoFix, index$1_applyNonHtmlG as applyNonHtmlG, index$1_applyNonHtmlVariations as applyNonHtmlVariations, index$1_applyVariableParts as applyVariableParts, index$1_convertAlphabet as convertAlphabet, index$1_convertAlphabetLowerCase as convertAlphabetLowerCase, index$1_highlightDiffNonHtmlStep as highlightDiffNonHtmlStep, index$1_highlightDiffStep as highlightDiffStep, index$1_joinSplittedText as joinSplittedText, index$1_prepare as prepare, index$1_replaceIbyJ as replaceIbyJ, index$1_resolveSpecialSyntax as resolveSpecialSyntax, index$1_restoreCaseStep as restoreCaseStep, index$1_restoreWhitespaces as restoreWhitespaces, index$1_storeSplittedAbcConvertedOrig as storeSplittedAbcConvertedOrig, index$1_storeSplittedText as storeSplittedText, index$1_taraskevize as taraskevize, index$1_trim as trim, index$1_whitespacesToSpaces as whitespacesToSpaces };
+}
+
+declare const tarask: (text: string, pipeline: TaraskStep<any>[], cfg?: TaraskConfig) => string;
+
+declare const ALPHABET: {
+    LATIN: {
+        lower: (readonly [RegExp, string])[];
+        upper: (readonly [RegExp, string])[];
+    };
+    LATIN_JI: {
+        lower: (readonly [RegExp, string])[];
+        upper: (readonly [RegExp, string])[];
+    };
+    ARABIC: {
+        lower: Dict;
+    };
+    CYRILLIC: {
+        lower: never[];
+        upper: never[];
+    };
+};
+
+declare const abcOnlyPipeline: (TaraskStep<{
+    noFixArr: string[];
+}> | TaraskStep<{
+    spaces: string[];
+    positions: number[];
+}> | ((_: string, { storage, cfg: { general } }: {
+    storage: {
+        doEscapeCapitalized: boolean;
+    };
+    cfg: TaraskConfig;
+}) => string))[];
+declare const plainTextPipeline: (TaraskStep<SplittedTextStorage> | TaraskStep<{
+    noFixArr: string[];
+}> | TaraskStep<{
+    spaces: string[];
+    positions: number[];
+}>)[];
+declare const htmlPipeline: (TaraskStep<SplittedTextStorage> | TaraskStep<{
+    noFixArr: string[];
+}> | TaraskStep<{
+    spaces: string[];
+    positions: number[];
+}>)[];
 
 declare const afterTarask: ExtendedDict;
 
-declare const forPlugins_afterTarask: typeof afterTarask;
-declare const forPlugins_noSoften: typeof noSoften;
-declare const forPlugins_replaceWithDict: typeof replaceWithDict;
-declare const forPlugins_softeners: typeof softeners;
-declare const forPlugins_wordlist: typeof wordlist;
-declare namespace forPlugins {
-  export { forPlugins_afterTarask as afterTarask, forPlugins_noSoften as noSoften, forPlugins_replaceWithDict as replaceWithDict, forPlugins_softeners as softeners, forPlugins_wordlist as wordlist };
+declare const highlightDiff: (text: string[], orig: readonly string[], isCyrillic: boolean, highlight: (content: string) => string) => void;
+
+declare const replaceG: (replacer: string | ((g: 'Ґ' | 'ґ') => string)) => (text: string) => string;
+
+declare const replaceWithDict: (text: string, dict?: ExtendedDict) => string;
+
+declare const restoreCase: (text: string[], orig: readonly string[]) => string[];
+
+declare const htmlWrappers: {
+    fix: (content: string) => string;
+    letterH: (content: string) => string;
+};
+declare const ansiColorWrappers: {
+    fix: (content: string) => string;
+    variable: (content: string) => string;
+};
+
+declare const dictFrom: {
+    raw: (dict: RawDict) => Dict;
+    nonGlobal: (dict: WritableDict) => Dict;
+};
+
+declare const index_afterTarask: typeof afterTarask;
+declare const index_ansiColorWrappers: typeof ansiColorWrappers;
+declare const index_dictFrom: typeof dictFrom;
+declare const index_highlightDiff: typeof highlightDiff;
+declare const index_htmlWrappers: typeof htmlWrappers;
+declare const index_replaceG: typeof replaceG;
+declare const index_replaceWithDict: typeof replaceWithDict;
+declare const index_restoreCase: typeof restoreCase;
+declare namespace index {
+  export { index_afterTarask as afterTarask, index_ansiColorWrappers as ansiColorWrappers, index_dictFrom as dictFrom, index_highlightDiff as highlightDiff, index_htmlWrappers as htmlWrappers, index_replaceG as replaceG, index_replaceWithDict as replaceWithDict, index_restoreCase as restoreCase };
 }
 
-export { ALPHABET, type HtmlOptions, type NonHtmlOptions, REPLACE_J, type TaraskOptions, Taraskevizer, VARIATION, forPlugins as __TARASK__, gobj };
+export { ALPHABET, type HtmlOptions, type NonHtmlOptions, REPLACE_J, TaraskConfig, type TaraskOptions, VARIATION, abcOnlyPipeline, index$2 as dicts, htmlPipeline, index as lib, index$1 as pipelineSteps, plainTextPipeline, tarask };