taraskevizer 6.1.19 → 7.0.1

package/dist/index.js

@@ -4,6 +4,20 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/dict/index.ts
+var dict_exports = {};
+__export(dict_exports, {
+  arabLetters: () => arabLetters,
+  gobj: () => gobj,
+  latinLettersLowerCase: () => latinLettersLowerCase,
+  latinLettersLowerCaseJi: () => latinLettersLowerCaseJi,
+  latinLettersUpperCase: () => latinLettersUpperCase,
+  latinLettersUpperCaseJi: () => latinLettersUpperCaseJi,
+  noSoften: () => noSoften,
+  softeners: () => softeners,
+  wordlist: () => wordlist
+});
+
 // src/dict/lib.ts
 var dictFrom = {
   raw: (dict) => {
@@ -1988,31 +2002,142 @@ var softeners = dictFrom.raw([
   [/([сз])ʼ(?=[яюеё])/, "$1ь"]
 ]);
 
-// src/replace-g.ts
-var replaceG = (text, replacer) => text.replace(
+// src/alphabet.ts
+var ALPHABET = {
+  LATIN: {
+    lower: latinLettersLowerCase,
+    upper: latinLettersUpperCase
+  },
+  LATIN_JI: {
+    lower: latinLettersLowerCaseJi,
+    upper: latinLettersUpperCaseJi
+  },
+  ARABIC: {
+    lower: arabLetters
+  },
+  CYRILLIC: {
+    lower: [],
+    upper: []
+  }
+};
+
+// src/config.ts
+var TaraskConfig = class {
+  constructor(options) {
+    if (!options)
+      return;
+    for (const [target, source] of [
+      [this.general, options.general],
+      [this.html, options.html],
+      [this.nonHtml, options.nonHtml]
+    ]) {
+      if (source)
+        for (const [key, value] of Object.entries(source)) {
+          if (value !== void 0)
+            target[key] = value;
+        }
+    }
+  }
+  general = {
+    abc: ALPHABET.CYRILLIC,
+    j: REPLACE_J.NEVER,
+    doEscapeCapitalized: true
+  };
+  html = {
+    g: false
+  };
+  nonHtml = {
+    h: false,
+    ansiColors: false,
+    variations: VARIATION.ALL
+  };
+};
+var REPLACE_J = {
+  NEVER: 0,
+  RANDOM: 1,
+  ALWAYS: 2
+};
+var VARIATION = {
+  NO: 0,
+  FIRST: 1,
+  ALL: 2
+};
+
+// src/tarask.ts
+var tarask = (text, pipeline, cfg = new TaraskConfig()) => {
+  const options = { cfg, storage: {} };
+  return pipeline.reduce((text2, step) => step(text2, options), text);
+};
+
+// src/steps/index.ts
+var steps_exports = {};
+__export(steps_exports, {
+  applyHtmlG: () => applyHtmlG,
+  applyHtmlVariations: () => applyHtmlVariations,
+  applyNoFix: () => applyNoFix,
+  applyNonHtmlG: () => applyNonHtmlG,
+  applyNonHtmlVariations: () => applyNonHtmlVariations,
+  applyVariableParts: () => applyVariableParts,
+  convertAlphabet: () => convertAlphabet,
+  convertAlphabetLowerCase: () => convertAlphabetLowerCase,
+  highlightDiffNonHtmlStep: () => highlightDiffNonHtmlStep,
+  highlightDiffStep: () => highlightDiffStep,
+  joinSplittedText: () => joinSplittedText,
+  prepare: () => prepare,
+  replaceIbyJ: () => replaceIbyJ,
+  resolveSpecialSyntax: () => resolveSpecialSyntax,
+  restoreCaseStep: () => restoreCaseStep,
+  restoreWhitespaces: () => restoreWhitespaces,
+  storeSplittedAbcConvertedOrig: () => storeSplittedAbcConvertedOrig,
+  storeSplittedText: () => storeSplittedText,
+  taraskevize: () => taraskevize,
+  trim: () => trim,
+  whitespacesToSpaces: () => whitespacesToSpaces
+});
+
+// src/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  afterTarask: () => afterTarask,
+  ansiColorWrappers: () => ansiColorWrappers,
+  dictFrom: () => dictFrom,
+  highlightDiff: () => highlightDiff,
+  htmlWrappers: () => htmlWrappers,
+  replaceG: () => replaceG,
+  replaceWithDict: () => replaceWithDict,
+  restoreCase: () => restoreCase
+});
+
+// src/lib/after-tarask.ts
+var iaReplacer = ($0, $1, $2) => {
+  var _a;
+  return ((_a = $2.match(/[аеёіоуыэюя]/g)) == null ? void 0 : _a.length) === 1 ? $1 + "я" + $2 : $0;
+};
+var afterTarask = [
+  [/( б)е(зь? \S+)/g, iaReplacer],
+  [/( н)е( \S+)/g, iaReplacer],
+  [
+    /( (?:б[ея]|пра|цера)?з) і(\S*)/g,
+    ($0, $1, $2) => /([ая]ў|ну)$/.test($2) ? $1 + "ь і" + $2 : $0
+  ]
+];
+
+// src/lib/replace-g.ts
+var replaceG = (replacer) => (text) => text.replace(
   /[Ґґ]/g,
   // @ts-ignore
   replacer
 );
 
-// src/highlight-diff.ts
-var wrappers = {
-  html: {
-    fix: (content) => `<tarF>${content}</tarF>`,
-    letterH: (content) => `<tarH>${content}</tarH>`
-  },
-  ansiColors: {
-    fix: (content) => `\x1B[32m${content}\x1B[0m`,
-    variable: (content) => `\x1B[35m${content}\x1B[0m`
-  }
-};
+// src/lib/highlight-diff.ts
 var 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 ? replaceG(word, ($0) => gobj[$0]) : word;
+    const wordH = isCyrillic ? replaceGByOpposite(word) : word;
     if (oWord === wordH)
       continue;
     if (!/\(/.test(word)) {
@@ -2063,14 +2188,18 @@ var highlightDiff = (text, orig, isCyrillic, highlight) => {
   }
 };
 
-// src/i-to-j.ts
-var toJ = (shortU) => "й " + (shortU ? "у" : "");
-var replaceIbyJ = (text, always = false) => text.replace(
-  /(?<=[аеёіоуыэюя] )і (ў?)/g,
-  always ? ($0, $1) => toJ($1) : ($0, $1) => Math.random() >= 0.5 ? toJ($1) : $0
-);
+// src/lib/replace-with-dict.ts
+var replaceWithDict = (text, dict = []) => {
+  for (const [pattern, result] of dict)
+    text = text.replace(
+      pattern,
+      //@ts-ignore
+      result
+    );
+  return text;
+};
 
-// src/restore-case.ts
+// src/lib/restore-case.ts
 var isUpperCase = (str) => str === str.toUpperCase();
 var getLastLetter = (word, i) => {
   const result = new RegExp("\\p{L}(?=[^\\p{L}]*$)", "u").exec(word);
@@ -2106,71 +2235,73 @@ var restoreCase = (text, orig) => {
   return text;
 };
 
-// src/after-tarask.ts
-var iaReplacer = ($0, $1, $2) => {
-  var _a;
-  return ((_a = $2.match(/[аеёіоуыэюя]/g)) == null ? void 0 : _a.length) === 1 ? $1 + "я" + $2 : $0;
+// src/lib/wrappers.ts
+var htmlWrappers = {
+  fix: (content) => `<tarF>${content}</tarF>`,
+  letterH: (content) => `<tarH>${content}</tarH>`
 };
-var afterTarask = [
-  [/( б)е(зь? \S+)/g, iaReplacer],
-  [/( н)е( \S+)/g, iaReplacer],
-  [
-    /( (?:б[ея]|пра|цера)?з) і(\S*)/g,
-    ($0, $1, $2) => /([ая]ў|ну)$/.test($2) ? $1 + "ь і" + $2 : $0
-  ]
-];
-
-// src/config-constants.ts
-var ALPHABET = {
-  CYRILLIC: 0,
-  LATIN: 1,
-  ARABIC: 2,
-  LATIN_JI: 3
-};
-var REPLACE_J = {
-  NEVER: 0,
-  RANDOM: 1,
-  ALWAYS: 2
-};
-var VARIATION = {
-  NO: 0,
-  FIRST: 1,
-  ALL: 2
+var ansiColorWrappers = {
+  fix: (content) => `\x1B[32m${content}\x1B[0m`,
+  variable: (content) => `\x1B[35m${content}\x1B[0m`
 };
 
-// src/letters.ts
-var letters = {
-  [ALPHABET.LATIN]: latinLettersLowerCase,
-  [ALPHABET.ARABIC]: arabLetters,
-  [ALPHABET.LATIN_JI]: latinLettersLowerCaseJi
-};
-var lettersUpperCase = {
-  [ALPHABET.LATIN]: latinLettersUpperCase,
-  [ALPHABET.LATIN_JI]: latinLettersUpperCaseJi
-};
+// src/steps/convert-alphabet.ts
+var convertAlphabet = (text, {
+  cfg: {
+    general: { abc }
+  }
+}) => replaceWithDict(replaceWithDict(text, abc.lower), abc.upper);
+var convertAlphabetLowerCase = (text, {
+  cfg: {
+    general: { abc }
+  }
+}) => replaceWithDict(text, abc.lower);
 
-// src/tools.ts
-var replaceWithDict = (text, dict = []) => {
-  for (const [pattern, result] of dict)
-    text = text.replace(
-      pattern,
-      //@ts-ignore
-      result
-    );
-  return text;
+// src/steps/highlight-diff.ts
+var highlightDiffStep = (highlight) => (_, {
+  cfg: {
+    general: { abc }
+  },
+  storage: { text, orig }
+}) => {
+  highlightDiff(text, orig, abc === ALPHABET.CYRILLIC, highlight);
+  return _;
+};
+var highlightDiffNonHtmlStep = (_, {
+  cfg: {
+    general: { abc },
+    nonHtml: { ansiColors }
+  },
+  storage: { text, orig }
+}) => {
+  if (ansiColors)
+    highlightDiff(text, orig, abc === ALPHABET.CYRILLIC, ansiColorWrappers.fix);
+  return _;
 };
-var convertAlphabet = (text, abc) => replaceWithDict(replaceWithDict(text, letters[abc]), lettersUpperCase[abc]);
 
-// src/resolve-syntax.ts
+// src/steps/resolve-syntax.ts
 var NOFIX_CHAR = "  ";
 var NOFIX_REGEX = new RegExp(NOFIX_CHAR, "g");
-var applyNoFix = (arr, text) => arr.length ? text.replace(NOFIX_REGEX, () => arr.shift()) : text;
-var applyVariableParts = (text, callback) => text.replace(/\([^)]*?\)/g, ($0) => callback($0.slice(1, -1).split("|")));
-var resolveSpecialSyntax = (text, noFixArr, leftAngleBracket, convertAlphavet, doEscapeCaps) => {
-  const escapeCapsIfNeeded = (text2) => doEscapeCaps ? text2.replace(new RegExp("(?!<=\\p{Lu} )\\p{Lu}{2}[\\p{Lu} ]*(?!= \\p{Lu})", "gu"), ($0) => {
-    noFixArr.push(convertAlphavet($0));
-    return NOFIX_CHAR;
-  }) : text2;
+var applyNoFix = (text, { storage: { noFixArr } }) => noFixArr.length ? text.replace(NOFIX_REGEX, () => noFixArr.shift()) : text;
+var applyVariableParts = (callback) => (text) => text.replace(/\([^)]*?\)/g, ($0) => callback($0.slice(1, -1).split("|")));
+var resolveSpecialSyntax = (leftAngleBracket) => (text, {
+  storage,
+  cfg: {
+    general: { doEscapeCapitalized, abc }
+  }
+}) => {
+  const noFixArr = storage.noFixArr = [];
+  const convertAlphavet = (abcOnlyText, abc2) => restoreCase(
+    replaceWithDict(abcOnlyText.toLowerCase(), abc2.lower).split(" "),
+    abcOnlyText.split(" ")
+  ).join(" ");
+  const escapeCapsIfNeeded = (text2) => doEscapeCapitalized ? text2.replace(
+    new RegExp("(?!<=\\p{Lu} )\\p{Lu}{2}[\\p{Lu} ]*(?!= \\p{Lu})", "gu"),
+    ($0) => {
+      noFixArr.push(convertAlphavet($0, abc));
+      return NOFIX_CHAR;
+    }
+  ) : text2;
   const parts = text.split(/(?=[<>])/g);
   if (parts.length === 1)
     return escapeCapsIfNeeded(text);
@@ -2187,11 +2318,12 @@ var resolveSpecialSyntax = (text, noFixArr, leftAngleBracket, convertAlphavet, d
         currentPart += part;
       } else {
         let char = "";
-        const abc = currentPart[1] === "*";
-        if (abc) {
+        const isAbc = currentPart[1] === "*";
+        if (isAbc) {
           char = currentPart[2];
           currentPart = convertAlphavet(
-            currentPart.slice(char === "," || char === "." ? 3 : 2)
+            currentPart.slice(char === "," || char === "." ? 3 : 2),
+            abc
           );
         } else {
           char = currentPart[1];
@@ -2208,7 +2340,7 @@ var resolveSpecialSyntax = (text, noFixArr, leftAngleBracket, convertAlphavet, d
             break;
           default:
             toAddToResult = leftAngleBracket + NOFIX_CHAR;
-            noFixArr.push((abc ? "" : char) + currentPart + ">");
+            noFixArr.push((isAbc ? "" : char) + currentPart + ">");
         }
         result += toAddToResult + escapeCapsIfNeeded(part.slice(1));
         currentPart = "";
@@ -2220,163 +2352,211 @@ var resolveSpecialSyntax = (text, noFixArr, leftAngleBracket, convertAlphavet, d
   return result + escapeCapsIfNeeded(currentPart);
 };
 
-// src/tarask.ts
-var afterJoin = (text) => text.replace(/&nbsp;/g, " ").replace(new RegExp(" (\\p{P}|\\p{S}|\\d+|&#40) ", "gu"), "$1");
-var finalize = (text, newLine) => text.replace(/\n/g, newLine).trim();
-var restoreParentheses = (text) => text.replace(/&#40/g, "(");
-var wordlistPlusNoSoften = wordlist.concat(noSoften);
-var Taraskevizer = class {
-  general = {
-    abc: ALPHABET.CYRILLIC,
-    j: REPLACE_J.NEVER,
-    doEscapeCapitalized: true
-  };
-  html = {
-    g: false
-  };
-  nonHtml = {
-    h: false,
-    ansiColors: false,
-    variations: VARIATION.ALL
-  };
-  spaces = [];
-  restoreSpaces(text) {
-    return text.replace(/ /g, () => this.spaces.shift());
-  }
-  constructor(options) {
-    if (!options)
-      return;
-    Object.assign(this.general, options.general);
-    Object.assign(this.html, options.html);
-    Object.assign(this.nonHtml, options.nonHtml);
-    if (options.taraskevize)
-      this.taraskevize = options.taraskevize;
-  }
-  convert(text) {
-    const wrapInColorOf = wrappers.ansiColors;
-    const isCyrillic = this.general.abc === ALPHABET.CYRILLIC;
-    const noFixArr = [];
-    const { splitted, splittedOrig } = this.process(
-      this.prepare(text, noFixArr, "<")
-    );
-    if (this.nonHtml.ansiColors)
-      highlightDiff(splitted, splittedOrig, isCyrillic, wrapInColorOf.fix);
-    text = afterJoin(this.restoreSpaces(splitted.join(" ")));
-    if (isCyrillic && (this.nonHtml.h || this.nonHtml.ansiColors))
-      text = replaceG(
-        text,
-        this.nonHtml.ansiColors ? this.nonHtml.h ? ($0) => wrapInColorOf.variable(gobj[$0]) : wrapInColorOf.variable("$&") : ($0) => gobj[$0]
-      );
-    if (this.nonHtml.variations !== VARIATION.ALL) {
-      const partIndex = this.nonHtml.variations;
-      text = applyVariableParts(
-        text,
-        this.nonHtml.ansiColors ? (parts) => wrapInColorOf.variable(parts[partIndex]) : (parts) => parts[partIndex]
-      );
-    }
-    return finalize(restoreParentheses(applyNoFix(noFixArr, text)), "\n");
+// src/steps/html-steps.ts
+var applyHtmlVariations = applyVariableParts((parts) => {
+  const main = parts.shift();
+  return `<tarL data-l='${parts}'>${main}</tarL>`;
+});
+var applyHtmlG = (text, {
+  cfg: {
+    general: { abc },
+    html: { g }
   }
-  convertToHtml(text) {
-    const wrapInTag = wrappers.html;
-    const isCyrillic = this.general.abc === ALPHABET.CYRILLIC;
-    const noFixArr = [];
-    const { splitted, splittedOrig } = this.process(
-      this.prepare(text, noFixArr, "&lt;")
-    );
-    highlightDiff(splitted, splittedOrig, isCyrillic, wrapInTag.fix);
-    text = afterJoin(this.restoreSpaces(splitted.join(" ")));
-    if (isCyrillic)
-      text = replaceG(
-        text,
-        this.html.g ? wrapInTag.letterH("$&") : ($0) => wrapInTag.letterH(gobj[$0])
-      );
-    return finalize(
-      applyVariableParts(applyNoFix(noFixArr, text), (parts) => {
-        const main = parts.shift();
-        return `<tarL data-l='${parts}'>${main}</tarL>`;
-      }),
-      "<br>"
-    );
+}) => {
+  const colorize = htmlWrappers.letterH;
+  return abc === ALPHABET.CYRILLIC ? replaceG(g ? colorize("$&") : ($0) => colorize(gobj[$0]))(text) : text;
+};
+
+// src/steps/i-to-j.ts
+var toJ = (shortU) => "й " + (shortU ? "у" : "");
+var replaceIbyJ = (text, {
+  cfg: {
+    general: { j, abc }
   }
-  prepare(text, noFixArr, LEFT_ANGLE_BRACKET, doEscapeCapitalized = this.general.doEscapeCapitalized) {
-    text = resolveSpecialSyntax(
-      ` ${text.trim()} `.replace(//g, ""),
-      noFixArr,
-      LEFT_ANGLE_BRACKET,
-      (abcOnlyText) => restoreCase(
-        replaceWithDict(
-          abcOnlyText.toLowerCase(),
-          letters[this.general.abc]
-        ).split(" "),
-        abcOnlyText.split(" ")
-      ).join(" "),
-      doEscapeCapitalized
-    ).replace(/г'(?![еёіюя])/g, "ґ").replace(/ - /g, " — ").replace(new RegExp("(\\p{P}|\\p{S}|\\d+)", "gu"), " $1 ").replace(/ ['`’] (?=\S)/g, "ʼ").replace(/\(/g, "&#40");
-    text = text.replace(/\s+/g, (match) => {
-      this.spaces.push(match);
-      return " ";
-    });
-    return text;
+}) => j && abc !== ALPHABET.LATIN_JI ? text.replace(
+  /(?<=[аеёіоуыэюя] )і (ў?)/g,
+  j === REPLACE_J.ALWAYS ? ($0, $1) => toJ($1) : ($0, $1) => Math.random() >= 0.5 ? toJ($1) : $0
+) : text;
+
+// src/steps/join-splitted.ts
+var joinSplittedText = (_, { storage: { text } }) => text.join(" ");
+
+// src/steps/non-html-steps.ts
+var applyNonHtmlVariations = (text, options) => {
+  const partIndex = options.cfg.nonHtml.variations;
+  const colorize = ansiColorWrappers.variable;
+  return partIndex === VARIATION.ALL ? text : applyVariableParts(
+    options.cfg.nonHtml.ansiColors ? (parts) => colorize(parts[partIndex]) : (parts) => parts[partIndex]
+  )(text, options);
+};
+var applyNonHtmlG = (text, {
+  cfg: {
+    general: { abc },
+    nonHtml: { h, ansiColors }
   }
-  convertAlphabetOnly(text) {
-    const noFixArr = [];
-    return finalize(
-      afterJoin(
-        restoreParentheses(
-          applyNoFix(
-            noFixArr,
-            this.restoreSpaces(
-              convertAlphabet(
-                this.prepare(text, noFixArr, "<", false),
-                this.general.abc
-              )
-            )
-          )
-        )
-      ),
-      "\n"
-    );
+}) => {
+  const colorize = ansiColorWrappers.variable;
+  return abc === ALPHABET.CYRILLIC && (h || ansiColors) ? replaceG(
+    ansiColors ? h ? ($0) => colorize(gobj[$0]) : colorize("$&") : ($0) => gobj[$0]
+  )(text) : text;
+};
+
+// src/steps/prepare.ts
+var prepare = (text) => text.replace(/г'(?![еёіюя])/g, "ґ").replace(/ - /g, " — ").replace(new RegExp("(\\p{P}|\\p{S}|\\d+)", "gu"), " $1 ").replace(/ ['`’] (?=\S)/g, "ʼ").replace(/\(/g, "&#40");
+
+// src/steps/restore-case.ts
+var restoreCaseStep = (_, {
+  cfg: {
+    general: { abc }
+  },
+  storage
+}) => {
+  if (abc !== ALPHABET.ARABIC) {
+    storage.text = restoreCase(storage.text, storage.orig);
   }
-  process(text) {
-    const { abc, j } = this.general;
-    const splittedOrig = convertAlphabet(text, abc).split(" ");
-    text = this.taraskevize(text.toLowerCase());
-    if (j && abc !== ALPHABET.LATIN_JI)
-      text = replaceIbyJ(text, j === REPLACE_J.ALWAYS);
-    text = replaceWithDict(text, letters[abc]);
-    let splitted = text.split(" ");
-    if (abc !== ALPHABET.ARABIC)
-      splitted = restoreCase(splitted, splittedOrig);
-    return { splittedOrig, splitted };
+  return _;
+};
+
+// src/steps/store-splitted-abc-converted-orig.ts
+var storeSplittedAbcConvertedOrig = (text, options) => {
+  options.storage.orig = convertAlphabet(text, options).split(" ");
+  return text;
+};
+
+// src/steps/store-splitted-text.ts
+var storeSplittedText = (text, { storage }) => {
+  storage.text = text.split(" ");
+  return text;
+};
+
+// src/steps/taraskevize.ts
+var wordlistPlusNoSoften = wordlist.concat(noSoften);
+var taraskevize = (text) => {
+  text = replaceWithDict(text, wordlistPlusNoSoften);
+  softening:
+    do {
+      text = replaceWithDict(text, softeners);
+      for (const [pattern, result] of softeners)
+        if (result !== "$1дзьдз" && pattern.test(text))
+          continue softening;
+      break;
+    } while (true);
+  return replaceWithDict(text.replace(//g, ""), afterTarask);
+};
+
+// src/steps/whitespaces.ts
+var whitespacesToSpaces = (text, { storage }) => {
+  storage.spaces = [];
+  storage.positions = [];
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (/\s/.test(text[i])) {
+      let start = i;
+      while (i < text.length && /\s/.test(text[i]))
+        ++i;
+      storage.spaces.push(text.slice(start, i));
+      storage.positions.push(result.length);
+      result += " ";
+    } else {
+      result += text[i];
+      ++i;
+    }
   }
-  taraskevize(text) {
-    text = replaceWithDict(text, wordlistPlusNoSoften);
-    softening:
-      do {
-        text = replaceWithDict(text, softeners);
-        for (const [pattern, result] of softeners)
-          if (result !== "$1дзьдз" && pattern.test(text))
-            continue softening;
-        break;
-      } while (true);
-    return replaceWithDict(text.replace(//g, ""), afterTarask);
+  return result;
+};
+var restoreWhitespaces = (text, { storage }) => {
+  let result = "";
+  let lastIndex = 0;
+  let spaceIndex = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === " " && spaceIndex < storage.spaces.length) {
+      result += text.slice(lastIndex, i) + storage.spaces[spaceIndex];
+      lastIndex = i + 1;
+      ++spaceIndex;
+    }
   }
+  result += text.slice(lastIndex);
+  return result;
 };
 
-// src/for-plugins.ts
-var for_plugins_exports = {};
-__export(for_plugins_exports, {
-  afterTarask: () => afterTarask,
-  noSoften: () => noSoften,
-  replaceWithDict: () => replaceWithDict,
-  softeners: () => softeners,
-  wordlist: () => wordlist
-});
+// src/steps/trim.ts
+var trim = (text) => ` ${text.trim()} `;
+
+// src/pipelines.ts
+var restoreParentheses = (text) => text.replace(/&#40/g, "(");
+var afterJoin = (text) => text.replace(/&nbsp;/g, " ").replace(new RegExp(" (\\p{P}|\\p{S}|\\d+|&#40) ", "gu"), "$1");
+var finalize = (newLine) => (text) => text.replace(/\n/g, newLine).trim();
+var resolveSpecialSyntaxWithLAB = resolveSpecialSyntax("<");
+var toLowerCase = (text) => text.toLowerCase();
+var finalizeWithNewLine = finalize("\n");
+var abcOnlyPipeline = [
+  (_, { storage, cfg: { general } }) => {
+    storage.doEscapeCapitalized = general.doEscapeCapitalized;
+    general.doEscapeCapitalized = false;
+    return _;
+  },
+  trim,
+  resolveSpecialSyntaxWithLAB,
+  prepare,
+  whitespacesToSpaces,
+  convertAlphabet,
+  restoreWhitespaces,
+  applyNoFix,
+  restoreParentheses,
+  afterJoin,
+  finalizeWithNewLine,
+  (_, { storage, cfg: { general } }) => {
+    general.doEscapeCapitalized = storage.doEscapeCapitalized;
+    return _;
+  }
+];
+var createPipeline = (resolveSpecialSyntax2, applyG, applyVariations, finalize2, highlightDiffStep2) => [
+  trim,
+  resolveSpecialSyntax2,
+  prepare,
+  whitespacesToSpaces,
+  storeSplittedAbcConvertedOrig,
+  toLowerCase,
+  taraskevize,
+  replaceIbyJ,
+  convertAlphabetLowerCase,
+  storeSplittedText,
+  restoreCaseStep,
+  highlightDiffStep2,
+  joinSplittedText,
+  restoreWhitespaces,
+  restoreParentheses,
+  afterJoin,
+  applyG,
+  applyVariations,
+  applyNoFix,
+  finalize2
+];
+var plainTextPipeline = createPipeline(
+  resolveSpecialSyntaxWithLAB,
+  applyNonHtmlG,
+  applyNonHtmlVariations,
+  finalizeWithNewLine,
+  highlightDiffNonHtmlStep
+);
+var htmlPipeline = createPipeline(
+  resolveSpecialSyntax("&lt;"),
+  applyHtmlG,
+  applyHtmlVariations,
+  finalize("<br>"),
+  highlightDiffStep(htmlWrappers.fix)
+);
 export {
   ALPHABET,
   REPLACE_J,
-  Taraskevizer,
+  TaraskConfig,
   VARIATION,
-  for_plugins_exports as __TARASK__,
-  gobj
+  abcOnlyPipeline,
+  dict_exports as dicts,
+  htmlPipeline,
+  lib_exports as lib,
+  steps_exports as pipelineSteps,
+  plainTextPipeline,
+  tarask
 };