taraskevizer 8.0.7 → 8.0.9

package/dist/lib/after-tarask.d.ts

@@ -0,0 +1,2 @@
+import type { ExtendedDict } from './types';
+export declare const afterTarask: ExtendedDict;

package/dist/lib/after-tarask.js

@@ -0,0 +1,9 @@
+const iaReplacer = ($0, $1, $2) => $2.match(/[аеёіоуыэюя]/g)?.length === 1 ? $1 + 'я' + $2 : $0;
+export const afterTarask = [
+    [/( б)е(зь? \S+)/g, iaReplacer],
+    [/( н)е( \S+)/g, iaReplacer],
+    [
+        /( (?:б[ея]|пра|цера)?з) і(\S*)/g,
+        ($0, $1, $2) => (/([ая]ў|ну)$/.test($2) ? $1 + 'ь і' + $2 : $0),
+    ],
+];

package/dist/lib/highlight-diff.d.ts

@@ -0,0 +1 @@
+export declare const highlightDiff: (text: string[], orig: readonly string[], isCyrillic: boolean, highlight: (content: string) => string) => void;

package/dist/lib/highlight-diff.js

@@ -0,0 +1,62 @@
+import { replaceG } from './replace-g';
+import { gobj } from '../dict';
+export const highlightDiff = (text, orig, isCyrillic, highlight) => {
+    const replaceGByOpposite = replaceG(($0) => gobj[$0]);
+    for (let i = 0; i < text.length; i++) {
+        const word = text[i];
+        const oWord = orig[i];
+        if (oWord === word)
+            continue;
+        const wordH = isCyrillic ? replaceGByOpposite(word) : word;
+        if (oWord === wordH)
+            continue;
+        if (!/\(/.test(word)) {
+            if (word.length === oWord.length) {
+                const wordLetters = word.split('');
+                for (let j = 0; j < wordLetters.length; j++) {
+                    if (wordH[j] !== oWord[j])
+                        wordLetters[j] = highlight(wordLetters[j]);
+                }
+                text[i] = wordLetters.join('');
+                continue;
+            }
+            if (isCyrillic) {
+                const word1 = word.replace(/ь/g, '');
+                switch (oWord) {
+                    case word1:
+                        text[i] = word.replace(/ь/g, highlight('ь'));
+                        continue;
+                    case word1 + 'ь':
+                        text[i] = word.slice(0, -1).replace(/ь/g, highlight('ь')) + 'ь';
+                        continue;
+                }
+            }
+        }
+        const oWordEnd = oWord.length - 1;
+        let fromStart = 0;
+        let fromWordEnd = word.length - 1;
+        let fromOWordEnd = oWordEnd;
+        while (wordH[fromStart] === oWord[fromStart])
+            ++fromStart;
+        while (wordH[fromWordEnd] === oWord[fromOWordEnd]) {
+            --fromWordEnd;
+            --fromOWordEnd;
+        }
+        if (oWord.length < word.length) {
+            if (fromOWordEnd === oWordEnd) {
+                text[i] = highlight(word);
+                continue;
+            }
+            if (fromWordEnd < 0)
+                fromWordEnd = 0;
+        }
+        if (fromStart === fromWordEnd + 1) {
+            --fromStart;
+            ++fromWordEnd;
+        }
+        text[i] =
+            word.slice(0, fromStart) +
+                highlight(word.slice(fromStart, fromWordEnd + 1)) +
+                word.slice(fromWordEnd + 1);
+    }
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './after-tarask';
+export * from './highlight-diff';
+export * from './replace-g';
+export * from './replace-with-dict';
+export * from './restore-case';
+export * from './wrappers';
+export * from './mutating-step';
+export { dictFrom } from './../dict/lib';
+export type * from './types';

package/dist/lib/index.js

@@ -0,0 +1,8 @@
+export * from './after-tarask';
+export * from './highlight-diff';
+export * from './replace-g';
+export * from './replace-with-dict';
+export * from './restore-case';
+export * from './wrappers';
+export * from './mutating-step';
+export { dictFrom } from './../dict/lib';

package/dist/lib/mutating-step.d.ts

@@ -0,0 +1,8 @@
+import { TaraskStep } from '../steps/types';
+/**
+ * An abstraction for a step that always changes the text.
+ *
+ * > Not recommended to use if
+ * a step doesn't ALWAYS change the text.
+ */
+export declare const mutatingStep: <T extends object = {}>(callback: (...args: Parameters<TaraskStep<T>>) => string) => TaraskStep<T>;

package/dist/lib/mutating-step.js

@@ -0,0 +1,4 @@
+
+export const mutatingStep = (callback) => (options) => {
+    options.text = callback(options);
+};

package/dist/lib/replace-g.d.ts

@@ -0,0 +1 @@
+export declare const replaceG: (replacer: string | ((g: 'Ґ' | 'ґ') => string)) => (text: string) => string;

package/dist/lib/replace-g.js

@@ -0,0 +1,3 @@
+export const replaceG = (replacer) => (text) => text.replace(/[Ґґ]/g, 
+// @ts-ignore
+replacer);

package/dist/lib/replace-with-dict.d.ts

@@ -0,0 +1,2 @@
+import type { ExtendedDict } from './types';
+export declare const replaceWithDict: (text: string, dict?: ExtendedDict) => string;

package/dist/lib/replace-with-dict.js

@@ -0,0 +1,7 @@
+export const replaceWithDict = (text, dict = []) => {
+    for (const [pattern, result] of dict)
+        text = text.replace(pattern, 
+        //@ts-ignore
+        result);
+    return text;
+};

package/dist/lib/restore-case.d.ts

@@ -0,0 +1 @@
+export declare const restoreCase: (text: string[], orig: readonly string[]) => string[];

package/dist/lib/restore-case.js

@@ -0,0 +1,33 @@
+const isUpperCase = (str) => str === str.toUpperCase();
+const getLastLetter = (word, i) => {
+    const result = /\p{L}(?=[^\p{L}]*$)/u.exec(word);
+    if (result)
+        return result[0];
+    throw new Error(`the last letter of the word "${word}" not found. index: ${i}`);
+};
+export const restoreCase = (text, orig) => {
+    for (let i = 0; i < text.length; i++) {
+        const word = text[i];
+        const oWord = orig[i];
+        if (word === oWord)
+            continue;
+        if (word === oWord.toLowerCase()) {
+            text[i] = oWord;
+            continue;
+        }
+        if (!oWord[0] || !isUpperCase(oWord[0]))
+            continue;
+        if (word === 'зь') {
+            text[i] = isUpperCase(orig[i + 1]) ? 'ЗЬ' : 'Зь';
+        }
+        else if (isUpperCase(getLastLetter(oWord, i))) {
+            text[i] = word.toUpperCase();
+        }
+        else {
+            text[i] = word.startsWith('(')
+                ? word.replace(/[^)]*?(?=\))/, ($0) => $0.replace(/[(|]./g, ($0) => $0.toUpperCase()))
+                : word[0].toUpperCase() + word.slice(1);
+        }
+    }
+    return text;
+};

package/dist/lib/types.d.ts

@@ -0,0 +1,4 @@
+export type ExtendedDict = readonly (readonly [
+    RegExp,
+    string | ((...substrings: string[]) => string)
+])[];

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/wrappers.d.ts

@@ -0,0 +1,8 @@
+export declare const htmlWrappers: {
+    fix: (content: string) => `<tarF>${string}</tarF>`;
+    letterH: (content: string) => `<tarH>${string}</tarH>`;
+};
+export declare const ansiColorWrappers: {
+    fix: (content: string) => string;
+    variable: (content: string) => string;
+};

package/dist/lib/wrappers.js

@@ -0,0 +1,8 @@
+export const htmlWrappers = {
+    fix: (content) => `<tarF>${content}</tarF>`,
+    letterH: (content) => `<tarH>${content}</tarH>`,
+};
+export const ansiColorWrappers = {
+    fix: (content) => `\x1b[32m${content}\x1b[0m`,
+    variable: (content) => `\x1b[35m${content}\x1b[0m`,
+};

package/dist/pipelines.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A pipeline in Taraskevizer is basically
+ * an array of steps of type {@link steps.TaraskStep}.
+ *
+ * You can use pre-made pipelines from this module or create your own.
+ *
+ * If you want to create a pipeline based on a pre-made one
+ * and do it more safely, it's recommended to use
+ * `.map` if you need replacing only or
+ * `.flatMap` if you also need to add or remove steps.
+ *
+ * This way you will depend less on the
+ * internal structure of the pre-made pipeline.
+ *
+ * @module
+ */
+import { type TaraskStep } from './steps';
+/**
+ * Storage for the pipeline {@link abcOnly}.
+ */
+type AbcOnlyStorage = {
+    doEscapeCapitalized: boolean;
+};
+/**
+ * Pipeline for changing only the alphabet.
+ *
+ * The property `cfg.general.doEscapeCapitalized` is set to `false` during the pipeline execution.
+ *
+ * To see the full list of steps, check the source code.
+ */
+export declare const abcOnly: (TaraskStep<import("./steps").SpecialSyntaxStorage> | TaraskStep<import("./steps").WhiteSpaceStorage> | (({ storage, cfg: { general } }: {
+    text: string;
+    storage: AbcOnlyStorage;
+    cfg: import("./config").TaraskConfig;
+}) => void))[];
+/**
+ * Pipeline for taraskevizing into plain text.
+ *
+ * To see the full list of steps, check the source code.
+ */
+export declare const plainText: (TaraskStep<import("./steps").SplittedTextStorage> | TaraskStep<import("./steps").SpecialSyntaxStorage> | TaraskStep<import("./steps").WhiteSpaceStorage>)[];
+/**
+ * Pipeline for taraskevizing into HTML.
+ *
+ * To see the full list of steps, check the source code.
+ */
+export declare const html: (TaraskStep<import("./steps").SplittedTextStorage> | TaraskStep<import("./steps").SpecialSyntaxStorage> | TaraskStep<import("./steps").WhiteSpaceStorage>)[];
+export {};

package/dist/pipelines.js

@@ -0,0 +1,47 @@
+
+import { applyVariationsHtml, applyVariationsNonHtml, applyGHtml, applyGNonHtml, highlightDiffStep, highlightDiffStepNonHtml, applyNoFix, convertAlphabet, convertAlphabetLowerCase, joinSplittedText, prepare, replaceIbyJ, resolveSpecialSyntax, restoreCaseStep, restoreWhitespaces, storeSplittedAbcConvertedOrig, storeSplittedText, taraskevize, whitespacesToSpaces, trim, finalize, toLowerCase, } from './steps';
+import { htmlWrappers } from './lib/wrappers';
+const resolveSpecialSyntaxWithLAB = resolveSpecialSyntax('<');
+const finalizeWithNewLine = finalize('\n');
+
+export const abcOnly = [
+    (({ storage, cfg: { general } }) => {
+        storage.doEscapeCapitalized = general.doEscapeCapitalized;
+        general.doEscapeCapitalized = false;
+    }),
+    trim,
+    resolveSpecialSyntaxWithLAB,
+    prepare,
+    whitespacesToSpaces,
+    convertAlphabet,
+    restoreWhitespaces,
+    applyNoFix,
+    finalizeWithNewLine,
+    (({ storage, cfg: { general } }) => {
+        general.doEscapeCapitalized = storage.doEscapeCapitalized;
+    }),
+];
+const createPipeline = (resolveSpecialSyntax, applyG, applyVariations, finalize, highlightDiffStep) => [
+    trim,
+    resolveSpecialSyntax,
+    prepare,
+    whitespacesToSpaces,
+    storeSplittedAbcConvertedOrig,
+    toLowerCase,
+    taraskevize,
+    replaceIbyJ,
+    convertAlphabetLowerCase,
+    storeSplittedText,
+    restoreCaseStep,
+    highlightDiffStep,
+    joinSplittedText,
+    restoreWhitespaces,
+    applyG,
+    applyVariations,
+    applyNoFix,
+    finalize,
+];
+
+export const plainText = createPipeline(resolveSpecialSyntaxWithLAB, applyGNonHtml, applyVariationsNonHtml, finalizeWithNewLine, highlightDiffStepNonHtml);
+
+export const html = createPipeline(resolveSpecialSyntax('&lt;'), applyGHtml, applyVariationsHtml, finalize('<br>'), highlightDiffStep(htmlWrappers.fix));

package/dist/steps/apply-g.d.ts

@@ -0,0 +1,3 @@
+import type { TaraskStep } from './types';
+export declare const applyGHtml: TaraskStep;
+export declare const applyGNonHtml: TaraskStep;

package/dist/steps/apply-g.js

@@ -0,0 +1,18 @@
+import { replaceG, ansiColorWrappers, htmlWrappers } from '../lib';
+import { alphabets } from '../dict';
+import { gobj } from '../dict';
+export const applyGHtml = (options) => {
+    const colorize = htmlWrappers.letterH;
+    if (options.cfg.general.abc === alphabets.cyrillic)
+        options.text = replaceG(options.cfg.html.g ? colorize('$&') : ($0) => colorize(gobj[$0]))(options.text);
+};
+export const applyGNonHtml = (options) => {
+    const colorize = ansiColorWrappers.variable;
+    const { cfg: { general: { abc }, nonHtml: { h, ansiColors }, }, } = options;
+    if (abc === alphabets.cyrillic && (h || ansiColors))
+        options.text = replaceG(ansiColors
+            ? h
+                ? ($0) => colorize(gobj[$0])
+                : colorize('$&')
+            : ($0) => gobj[$0])(options.text);
+};

package/dist/steps/apply-variations.d.ts

@@ -0,0 +1,24 @@
+import type { TaraskStep } from './types';
+/**
+ * @param callback - A function that takes an
+ * array of variable parts and returns a string.
+ *
+ * The step replaces strings like `"(a|b|c)"`
+ * with the result of the callback.
+ *
+ * @see {@link applyVariationsHtml}
+ * @see {@link applyVariationsNonHtml}
+ */
+export declare const applyVariableParts: (callback: (arr: string[]) => string) => TaraskStep;
+/**
+ * Uses {@link applyVariableParts}
+ *
+ * @example
+ * applyVariationsHtml({text: "a(b|c)d"});
+ * // {text: "a<tarL data-l='c'>b</tarL>d"}
+ */
+export declare const applyVariationsHtml: TaraskStep;
+/**
+ * Uses {@link applyVariableParts}
+ */
+export declare const applyVariationsNonHtml: TaraskStep;

package/dist/steps/apply-variations.js

@@ -0,0 +1,18 @@
+import { ansiColorWrappers, mutatingStep } from '../lib';
+import { VARIATION } from '../constants';
+
+export const applyVariableParts = (callback) => mutatingStep(({ text }) => text.replace(/\([^)]*?\)/g, ($0) => callback($0.slice(1, -1).split('|'))));
+
+export const applyVariationsHtml = applyVariableParts((parts) => {
+    const main = parts.shift();
+    return `<tarL data-l='${parts}'>${main}</tarL>`;
+});
+
+export const applyVariationsNonHtml = (options) => {
+    const partIndex = options.cfg.nonHtml.variations;
+    const colorize = ansiColorWrappers.variable;
+    if (partIndex !== VARIATION.ALL)
+        applyVariableParts(options.cfg.nonHtml.ansiColors
+            ? (parts) => colorize(parts[partIndex])
+            : (parts) => parts[partIndex])(options);
+};

package/dist/steps/convert-alphabet.d.ts

@@ -0,0 +1,2 @@
+export declare const convertAlphabet: import("./types").TaraskStep<{}>;
+export declare const convertAlphabetLowerCase: import("./types").TaraskStep<{}>;

package/dist/steps/convert-alphabet.js

@@ -0,0 +1,3 @@
+import { mutatingStep, replaceWithDict } from '../lib';
+export const convertAlphabet = mutatingStep(({ text, cfg: { general: { abc: { upper, lower }, }, }, }) => replaceWithDict(replaceWithDict(text, lower), upper));
+export const convertAlphabetLowerCase = mutatingStep(({ text, cfg: { general: { abc: { lower }, }, }, }) => replaceWithDict(text, lower));

package/dist/steps/finalize.d.ts

@@ -0,0 +1,14 @@
+import type { TaraskStep } from './types';
+/**
+ * @param newLine - The string to replace new lines with.
+ *
+ * Reverse the changes made in the {@link prepare} step
+ * and replace new lines with the passed string.
+ *
+ * Restores:
+ * `(` from `&#40`,
+ * ` ` from ` `,
+ *
+ * Removes spaces around punctuation marks and digits.
+ */
+export declare const finalize: (newLine: string) => TaraskStep;

package/dist/steps/finalize.js

@@ -0,0 +1,8 @@
+import { mutatingStep } from '../lib';
+
+export const finalize = (newLine) => mutatingStep(({ text }) => text
+    .replace(/&#40/g, '(')
+    .replace(/ /g, ' ')
+    .replace(/ (\p{P}|\p{S}|\d+) /gu, '$1')
+    .replace(/\n/g, newLine)
+    .trim());

package/dist/steps/highlight-diff.d.ts

@@ -0,0 +1,9 @@
+import type { TaraskStep, SplittedTextStorage } from './types';
+/**
+ * Uses {@link highlightDiff}
+ */
+export declare const highlightDiffStep: (highlight: (content: string) => string) => TaraskStep<SplittedTextStorage>;
+/**
+ * Uses {@link highlightDiff}
+ */
+export declare const highlightDiffStepNonHtml: TaraskStep<SplittedTextStorage>;

package/dist/steps/highlight-diff.js

@@ -0,0 +1,11 @@
+import { highlightDiff, ansiColorWrappers } from '../lib';
+import { alphabets } from '../dict';
+
+export const highlightDiffStep = (highlight) => ({ cfg: { general: { abc }, }, storage: { textArr, origArr }, }) => {
+    highlightDiff(textArr, origArr, abc === alphabets.cyrillic, highlight);
+};
+
+export const highlightDiffStepNonHtml = ({ cfg: { general: { abc }, nonHtml: { ansiColors }, }, storage: { textArr, origArr }, }) => {
+    if (ansiColors)
+        highlightDiff(textArr, origArr, abc === alphabets.cyrillic, ansiColorWrappers.fix);
+};

package/dist/steps/i-to-j.d.ts

@@ -0,0 +1,2 @@
+import type { TaraskStep } from './types';
+export declare const replaceIbyJ: TaraskStep;

package/dist/steps/i-to-j.js

@@ -0,0 +1,10 @@
+import { alphabets } from '../dict';
+import { REPLACE_J } from '../constants';
+const toJ = (shortU) => 'й ' + (shortU ? 'у' : '');
+export const replaceIbyJ = (options) => {
+    const { abc, j } = options.cfg.general;
+    if (j && abc !== alphabets.latinJi)
+        options.text = options.text.replace(/(?<=[аеёіоуыэюя] )і (ў?)/g, j === REPLACE_J.ALWAYS
+            ? ($0, $1) => toJ($1)
+            : ($0, $1) => (Math.random() >= 0.5 ? toJ($1) : $0));
+};

package/dist/steps/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This module exports all the steps
+ * that are used in builtin pipelines.
+ *
+ * A step implements the {@link TaraskStep} type.
+ *
+ * Some steps are configurable, they take
+ * additional arguments and return a {@link TaraskStep},
+ * for example {@link resolveSpecialSyntax}.
+ *
+ * @module
+ */
+export * from './convert-alphabet';
+export * from './highlight-diff';
+export * from './i-to-j';
+export * from './join-splitted';
+export * from './apply-g';
+export * from './apply-variations';
+export * from './prepare';
+export * from './resolve-syntax';
+export * from './restore-case';
+export * from './store-splitted-abc-converted-orig';
+export * from './store-splitted-text';
+export * from './taraskevize';
+export * from './whitespaces';
+export * from './trim';
+export * from './finalize';
+export * from './to-lower-case';
+export type * from './types';

package/dist/steps/index.js

@@ -0,0 +1,17 @@
+
+export * from './convert-alphabet';
+export * from './highlight-diff';
+export * from './i-to-j';
+export * from './join-splitted';
+export * from './apply-g';
+export * from './apply-variations';
+export * from './prepare';
+export * from './resolve-syntax';
+export * from './restore-case';
+export * from './store-splitted-abc-converted-orig';
+export * from './store-splitted-text';
+export * from './taraskevize';
+export * from './whitespaces';
+export * from './trim';
+export * from './finalize';
+export * from './to-lower-case';

package/dist/steps/join-splitted.d.ts

@@ -0,0 +1,2 @@
+import { SplittedTextStorage } from './types';
+export declare const joinSplittedText: import("./types").TaraskStep<SplittedTextStorage>;

package/dist/steps/join-splitted.js

@@ -0,0 +1,2 @@
+import { mutatingStep } from '../lib';
+export const joinSplittedText = mutatingStep(({ storage: { textArr } }) => textArr.join(' '));

package/dist/steps/prepare.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prepares the text for correct processing.
+ *
+ * Some changes should be reverted in the {@link finalize} step.
+ */
+export declare const prepare: import("./types").TaraskStep<{}>;

package/dist/steps/prepare.js

@@ -0,0 +1,8 @@
+import { mutatingStep } from '../lib';
+
+export const prepare = mutatingStep(({ text }) => text
+    .replace(/г'(?![еёіюя])/g, 'ґ')
+    .replace(/ - /g, ' — ')
+    .replace(/(\p{P}|\p{S}|\d+)/gu, ' $1 ')
+    .replace(/ ['`’] (?=\S)/g, 'ʼ')
+    .replace(/\(/g, '&#40'));

package/dist/steps/resolve-syntax.d.ts

@@ -0,0 +1,24 @@
+import type { TaraskStep } from './types';
+/**
+ * Created in {@link resolveSpecialSyntax}.
+ *
+ * Emptied in {@link applyNoFix}.
+ */
+export type SpecialSyntaxStorage = {
+    noFixArr: string[];
+};
+/**
+ * Brings parts from {@link SpecialSyntaxStorage} back to the text.
+ *
+ * Empties {@link SpecialSyntaxStorage.noFixArr}.
+ */
+export declare const applyNoFix: TaraskStep<SpecialSyntaxStorage>;
+/**
+ * Captures noFix parts and stores them in {@link SpecialSyntaxStorage.noFixArr}.
+ * Places a special character `" \ue0fe "` in their place.
+ *
+ * Use {@link applyNoFix} to bring the parts back to the text.
+ *
+ * Creates storage: {@link SpecialSyntaxStorage}.
+ */
+export declare const resolveSpecialSyntax: (leftAngleBracket: string) => TaraskStep<SpecialSyntaxStorage>;

package/dist/steps/resolve-syntax.js

@@ -0,0 +1,73 @@
+import { restoreCase, replaceWithDict, mutatingStep } from '../lib';
+const NOFIX_CHAR = ' \ue0fe ';
+const NOFIX_REGEX = new RegExp(NOFIX_CHAR, 'g');
+
+export const applyNoFix = (options) => {
+    const { noFixArr } = options.storage;
+    if (noFixArr.length) {
+        noFixArr.reverse();
+        options.text = options.text.replace(NOFIX_REGEX, () => noFixArr.pop());
+    }
+};
+
+export const resolveSpecialSyntax = (leftAngleBracket) => mutatingStep(({ text, storage, cfg: { general: { doEscapeCapitalized, abc }, }, }) => {
+    const noFixArr = (storage.noFixArr = []);
+    const convertAlphavet = (abcOnlyText, abc) => restoreCase(replaceWithDict(abcOnlyText.toLowerCase(), abc.lower).split(' '), abcOnlyText.split(' ')).join(' ');
+    const escapeCapsIfNeeded = (text) => doEscapeCapitalized
+        ? text.replace(/(?!<=\p{Lu} )\p{Lu}{2}[\p{Lu} ]*(?!= \p{Lu})/gu, ($0) => {
+            noFixArr.push(convertAlphavet($0, abc));
+            return NOFIX_CHAR;
+        })
+        : text;
+    const parts = text.split(/(?=[<>])/g);
+    if (parts.length === 1)
+        return escapeCapsIfNeeded(text);
+    let result = text.startsWith('<')
+        ? ''
+        : escapeCapsIfNeeded(parts.shift());
+    let depth = 0;
+    let currentPart = '';
+    for (const part of parts) {
+        if (part.startsWith('<')) {
+            ++depth;
+            currentPart += part;
+        }
+        else if (depth) {
+            --depth;
+            if (depth) {
+                currentPart += part;
+            }
+            else {
+                let char = '';
+                const isAbc = currentPart[1] === '*';
+                if (isAbc) {
+                    char = currentPart[2];
+                    currentPart = convertAlphavet(currentPart.slice(char === ',' || char === '.' ? 3 : 2), abc);
+                }
+                else {
+                    char = currentPart[1];
+                    currentPart = currentPart.slice(2);
+                }
+                let toAddToResult;
+                switch (char) {
+                    case '.':
+                        toAddToResult = NOFIX_CHAR;
+                        noFixArr.push(currentPart);
+                        break;
+                    case ',':
+                        toAddToResult = leftAngleBracket + currentPart + '>';
+                        break;
+                    default:
+                        toAddToResult = leftAngleBracket + NOFIX_CHAR;
+                        noFixArr.push((isAbc ? '' : char) + currentPart + '>');
+                }
+                result += toAddToResult + escapeCapsIfNeeded(part.slice(1));
+                currentPart = '';
+            }
+        }
+        else {
+            result += escapeCapsIfNeeded(part);
+        }
+    }
+    return result + escapeCapsIfNeeded(currentPart);
+});

package/dist/steps/restore-case.d.ts

@@ -0,0 +1,2 @@
+import type { TaraskStep, SplittedTextStorage } from './types';
+export declare const restoreCaseStep: TaraskStep<SplittedTextStorage>;

package/dist/steps/restore-case.js

@@ -0,0 +1,12 @@
+import { restoreCase } from '../lib';
+export const restoreCaseStep = ({ cfg: { general: { abc }, }, storage: { textArr, origArr }, }) => {
+    if (abc.upper) {
+        restoreCase(textArr, origArr);
+    }
+    else {
+        for (let i = 0; i < textArr.length; i++) {
+            if (origArr[i] !== origArr[i].toLowerCase())
+                textArr[i] = origArr[i];
+        }
+    }
+};

package/dist/steps/store-splitted-abc-converted-orig.d.ts

@@ -0,0 +1,2 @@
+import type { TaraskStep, SplittedTextStorage } from './types';
+export declare const storeSplittedAbcConvertedOrig: TaraskStep<SplittedTextStorage>;

package/dist/steps/store-splitted-abc-converted-orig.js

@@ -0,0 +1,4 @@
+import { replaceWithDict } from '../lib';
+export const storeSplittedAbcConvertedOrig = ({ cfg: { general: { abc: { lower, upper }, }, }, text, storage, }) => {
+    storage.origArr = replaceWithDict(replaceWithDict(text, lower), upper).split(' ');
+};