axyseo 2.0.0-alpha.0.0.37 → 2.0.0-alpha.0.0.39

package/build/languageProcessing/helpers/syllables/syllableCountStep.js

@@ -0,0 +1,68 @@
+import { isUndefined } from "lodash";
+import arrayToRegex from "../regex/createRegexFromArray.js";
+
+/**
+ * A SyllableCountStep is an individual step in a SyllableCountIterator.
+ */
+export default class SyllableCountStep {
+  /**
+   * Constructs a language syllable regex that contains a regex for matching syllable exclusion.
+   *
+   * @param {object} syllableRegex The object containing the syllable exclusions.
+   * @constructor
+   */
+  constructor(syllableRegex) {
+    this._hasRegex = false;
+    this._regex = "";
+    this._multiplier = "";
+    this.createRegex(syllableRegex);
+  }
+
+  /**
+   * Checks whether a valid regex has been set.
+   *
+   * @returns {boolean} True if a regex has been set, false if not.
+   */
+  hasRegex() {
+    return this._hasRegex;
+  }
+
+  /**
+   * Creates a regex based on the given syllable exclusions, and sets the multiplier to use.
+   *
+   * @param {object} syllableRegex The object containing the syllable exclusions and multiplier.
+   * @returns {void}
+   */
+  createRegex(syllableRegex) {
+    if (!isUndefined(syllableRegex) && !isUndefined(syllableRegex.fragments)) {
+      this._hasRegex = true;
+      this._regex = arrayToRegex(syllableRegex.fragments, true);
+      this._multiplier = syllableRegex.countModifier;
+    }
+  }
+
+  /**
+   * Returns the stored regular expression.
+   *
+   * @returns {RegExp} The stored regular expression.
+   */
+  getRegex() {
+    return this._regex;
+  }
+
+  /**
+   * Matches syllable exclusions in a given word and returns the number found multiplied by the
+   * given multiplier. The result of this multiplication is the syllable count.
+   *
+   * @param {String} word The word to match for syllable exclusions.
+   * @returns {number} The amount of syllables found.
+   */
+  countSyllables(word) {
+    if (this._hasRegex) {
+      const match = word.match(this._regex) || [];
+      return match.length * this._multiplier;
+    }
+    return 0;
+  }
+}
+//# sourceMappingURL=syllableCountStep.js.map

package/build/languageProcessing/helpers/syllables/syllableCountStep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syllableCountStep.js","names":["isUndefined","arrayToRegex","SyllableCountStep","constructor","syllableRegex","_hasRegex","_regex","_multiplier","createRegex","hasRegex","fragments","countModifier","getRegex","countSyllables","word","match","length"],"sources":["../../../../src/languageProcessing/helpers/syllables/syllableCountStep.js"],"sourcesContent":["import { isUndefined } from \"lodash\";\n\nimport arrayToRegex from \"../regex/createRegexFromArray.js\";\n\n/**\n * A SyllableCountStep is an individual step in a SyllableCountIterator.\n */\nexport default class SyllableCountStep {\n\t/**\n\t * Constructs a language syllable regex that contains a regex for matching syllable exclusion.\n\t *\n\t * @param {object} syllableRegex The object containing the syllable exclusions.\n\t * @constructor\n\t */\n\tconstructor( syllableRegex ) {\n\t\tthis._hasRegex = false;\n\t\tthis._regex = \"\";\n\t\tthis._multiplier = \"\";\n\t\tthis.createRegex( syllableRegex );\n\t}\n\n\t/**\n\t * Checks whether a valid regex has been set.\n\t *\n\t * @returns {boolean} True if a regex has been set, false if not.\n\t */\n\thasRegex() {\n\t\treturn this._hasRegex;\n\t}\n\n\t/**\n\t * Creates a regex based on the given syllable exclusions, and sets the multiplier to use.\n\t *\n\t * @param {object} syllableRegex The object containing the syllable exclusions and multiplier.\n\t * @returns {void}\n\t */\n\tcreateRegex( syllableRegex ) {\n\t\tif ( ! isUndefined( syllableRegex ) && ! isUndefined( syllableRegex.fragments ) ) {\n\t\t\tthis._hasRegex = true;\n\t\t\tthis._regex = arrayToRegex( syllableRegex.fragments, true );\n\t\t\tthis._multiplier = syllableRegex.countModifier;\n\t\t}\n\t}\n\n\t/**\n\t * Returns the stored regular expression.\n\t *\n\t * @returns {RegExp} The stored regular expression.\n\t */\n\tgetRegex() {\n\t\treturn this._regex;\n\t}\n\n\t/**\n\t * Matches syllable exclusions in a given word and returns the number found multiplied by the\n\t * given multiplier. The result of this multiplication is the syllable count.\n\t *\n\t * @param {String} word The word to match for syllable exclusions.\n\t * @returns {number} The amount of syllables found.\n\t */\n\tcountSyllables( word ) {\n\t\tif ( this._hasRegex ) {\n\t\t\tconst match = word.match( this._regex ) || [];\n\t\t\treturn match.length * this._multiplier;\n\t\t}\n\t\treturn 0;\n\t}\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,QAAQ;AAEpC,OAAOC,YAAY;;AAEnB;AACA;AACA;AACA,eAAe,MAAMC,iBAAiB,CAAC;EACtC;AACD;AACA;AACA;AACA;AACA;EACCC,WAAWA,CAAEC,aAAa,EAAG;IAC5B,IAAI,CAACC,SAAS,GAAG,KAAK;IACtB,IAAI,CAACC,MAAM,GAAG,EAAE;IAChB,IAAI,CAACC,WAAW,GAAG,EAAE;IACrB,IAAI,CAACC,WAAW,CAAEJ,aAAc,CAAC;EAClC;;EAEA;AACD;AACA;AACA;AACA;EACCK,QAAQA,CAAA,EAAG;IACV,OAAO,IAAI,CAACJ,SAAS;EACtB;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCG,WAAWA,CAAEJ,aAAa,EAAG;IAC5B,IAAK,CAAEJ,WAAW,CAAEI,aAAc,CAAC,IAAI,CAAEJ,WAAW,CAAEI,aAAa,CAACM,SAAU,CAAC,EAAG;MACjF,IAAI,CAACL,SAAS,GAAG,IAAI;MACrB,IAAI,CAACC,MAAM,GAAGL,YAAY,CAAEG,aAAa,CAACM,SAAS,EAAE,IAAK,CAAC;MAC3D,IAAI,CAACH,WAAW,GAAGH,aAAa,CAACO,aAAa;IAC/C;EACD;;EAEA;AACD;AACA;AACA;AACA;EACCC,QAAQA,CAAA,EAAG;IACV,OAAO,IAAI,CAACN,MAAM;EACnB;;EAEA;AACD;AACA;AACA;AACA;AACA;AACA;EACCO,cAAcA,CAAEC,IAAI,EAAG;IACtB,IAAK,IAAI,CAACT,SAAS,EAAG;MACrB,MAAMU,KAAK,GAAGD,IAAI,CAACC,KAAK,CAAE,IAAI,CAACT,MAAO,CAAC,IAAI,EAAE;MAC7C,OAAOS,KAAK,CAACC,MAAM,GAAG,IAAI,CAACT,WAAW;IACvC;IACA,OAAO,CAAC;EACT;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/transform/transformWordsWithHyphens.js

@@ -0,0 +1,18 @@
+/**
+ * Splits words from an array that contain hyphens and adds the elements to the array if they are not yet there.
+ *
+ * @param {Array} array The array to check and modify.
+ *
+ * @returns {Array} A new array with the elements containing hyphens split.
+ */
+export default function (array) {
+  let newArray = array;
+  array.forEach(element => {
+    element = element.split("-");
+    if (element.length > 0 && element.filter(unit => !array.includes(unit)).length > 0) {
+      newArray = newArray.concat(element);
+    }
+  });
+  return newArray;
+}
+//# sourceMappingURL=transformWordsWithHyphens.js.map

package/build/languageProcessing/helpers/transform/transformWordsWithHyphens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformWordsWithHyphens.js","names":["array","newArray","forEach","element","split","length","filter","unit","includes","concat"],"sources":["../../../../src/languageProcessing/helpers/transform/transformWordsWithHyphens.js"],"sourcesContent":["/**\n * Splits words from an array that contain hyphens and adds the elements to the array if they are not yet there.\n *\n * @param {Array} array The array to check and modify.\n *\n * @returns {Array} A new array with the elements containing hyphens split.\n */\nexport default function( array ) {\n\tlet newArray = array;\n\tarray.forEach( element => {\n\t\telement = element.split( \"-\" );\n\t\tif ( element.length > 0 && element.filter( unit => ! array.includes( unit ) ).length > 0 ) {\n\t\t\tnewArray = newArray.concat( element );\n\t\t}\n\t} );\n\treturn newArray;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,KAAK,EAAG;EAChC,IAAIC,QAAQ,GAAGD,KAAK;EACpBA,KAAK,CAACE,OAAO,CAAEC,OAAO,IAAI;IACzBA,OAAO,GAAGA,OAAO,CAACC,KAAK,CAAE,GAAI,CAAC;IAC9B,IAAKD,OAAO,CAACE,MAAM,GAAG,CAAC,IAAIF,OAAO,CAACG,MAAM,CAAEC,IAAI,IAAI,CAAEP,KAAK,CAACQ,QAAQ,CAAED,IAAK,CAAE,CAAC,CAACF,MAAM,GAAG,CAAC,EAAG;MAC1FJ,QAAQ,GAAGA,QAAQ,CAACQ,MAAM,CAAEN,OAAQ,CAAC;IACtC;EACD,CAAE,CAAC;EACH,OAAOF,QAAQ;AAChB","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/replaceDiacritics.js

@@ -0,0 +1,19 @@
+/** @module stringProcessing/replaceDiacritics */
+
+import diacriticsRemovalMap from "../../../config/diacritics.js";
+
+/**
+ * Replaces all diacritics from the text based on the diacritics removal map.
+ *
+ * @param {string} text The text to remove diacritics from.
+ *
+ * @returns {string} The text with all diacritics replaced.
+ */
+export default function (text) {
+  const map = diacriticsRemovalMap();
+  for (let i = 0; i < map.length; i++) {
+    text = text.replace(map[i].letters, map[i].base);
+  }
+  return text;
+}
+//# sourceMappingURL=replaceDiacritics.js.map

package/build/languageProcessing/helpers/transliterate/replaceDiacritics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceDiacritics.js","names":["diacriticsRemovalMap","text","map","i","length","replace","letters","base"],"sources":["../../../../src/languageProcessing/helpers/transliterate/replaceDiacritics.js"],"sourcesContent":["/** @module stringProcessing/replaceDiacritics */\n\nimport diacriticsRemovalMap from \"../../../config/diacritics.js\";\n\n/**\n * Replaces all diacritics from the text based on the diacritics removal map.\n *\n * @param {string} text The text to remove diacritics from.\n *\n * @returns {string} The text with all diacritics replaced.\n */\nexport default function( text ) {\n\tconst map = diacriticsRemovalMap();\n\n\tfor ( let i = 0; i < map.length; i++ ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letters,\n\t\t\tmap[ i ].base\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,oBAAoB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,MAAMC,GAAG,GAAGF,oBAAoB,CAAC,CAAC;EAElC,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,GAAG,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IACtCF,IAAI,GAAGA,IAAI,CAACI,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,OAAO,EAChBJ,GAAG,CAAEC,CAAC,CAAE,CAACI,IACV,CAAC;EACF;EACA,OAAON,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/specialCharacterMappings.js

@@ -0,0 +1,183 @@
+import { filter, includes, isEqual, memoize } from "lodash";
+import getWords from "../word/getWords";
+
+/**
+ * Gets positions of the first character of a word in the input text.
+ *
+ * @param {string} text The original text, for which the indices of word beginnings need to be determined.
+ *
+ * @returns {Array} indices The array of indices in the text at which words start.
+ */
+function getIndicesOfWords(text) {
+  const indices = [];
+  const words = getWords(text);
+  let startSearchFrom = 0;
+  words.forEach(function (word) {
+    const currentIndex = text.indexOf(word, startSearchFrom);
+    indices.push(currentIndex);
+    startSearchFrom = currentIndex + word.length;
+  });
+  return indices;
+}
+
+/**
+ * Gets indices of a specific character in the input text.
+ *
+ * @param {string} text             The original text, for which the indices of specific characters have to be determined.
+ * @param {string} characterToFind  The character that needs to be found in the text.
+ *
+ * @returns {Array} indices The array of indices in the text at which the characterToFind occurs.
+ */
+function getIndicesOfCharacter(text, characterToFind) {
+  const indices = [];
+  if (text.indexOf(characterToFind) > -1) {
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === characterToFind) {
+        indices.push(i);
+      }
+    }
+  }
+  return indices;
+}
+
+/**
+ * Compares two arrays of which the second array is the sub-array of the first array.
+ * Returns the array of elements of the first array which are not in the second array.
+ *
+ * @param {Array} bigArray The array with all elements.
+ * @param {Array} subarray The array with some elements from the bigArray.
+ *
+ * @returns {Array} difference An array of all elements of bigArray which are not in subarray.
+ */
+function arraysDifference(bigArray, subarray) {
+  return filter(bigArray, function (element) {
+    return !includes(subarray, element);
+  });
+}
+
+/**
+ * Compares two arrays and returns the array of elements that occur in both arrays.
+ *
+ * @param {Array} firstArray    The first array with elements to compare.
+ * @param {Array} secondArray   The second array with elements to compare.
+ *
+ * @returns {Array} overlap An array of all elements of firstArray which are also in secondArray.
+ */
+function arraysOverlap(firstArray, secondArray) {
+  return filter(firstArray, function (element) {
+    return includes(secondArray, element);
+  });
+}
+
+/**
+ * Generates all possible combinations of the elements of an array (treated as unique).
+ * https://gist.github.com/jpillora/4435759
+ *
+ * @param {Array} collection The array with elements that should be combined.
+ *
+ * @returns {Array} result An array of all possible combinations of elements of the original array.
+ */
+function combinations(collection) {
+  /**
+   * A recursive function that iterates through all elements of an array to produce its combinations.
+   *
+   * @param {Array} xs        The array to start accumulating with.
+   * @param {Array} array     The array with elements that should be combined.
+   *
+   * @returns {Array} result An array of all possible combinations of elements of the original array.
+   */
+  function acc(xs, array) {
+    const x = xs[0];
+    if (typeof x === "undefined") {
+      return array;
+    }
+    for (let i = 0, l = array.length; i < l; ++i) {
+      array.push(array[i].concat(x));
+    }
+    return acc(xs.slice(1), array);
+  }
+  return acc(collection, [[]]).slice(1).concat([[]]);
+}
+
+/**
+ * Replaces characters on specified indices in the input text.
+ *
+ * @param {string} text         The original text, for which the characters have to be substituted.
+ * @param {Array} indices       The array of indices that have to be substituted.
+ * @param {string} substitute   The character that is used to substitute in the text.
+ *
+ * @returns {string} result The string of the original text with the characters on specified indices are substituted with the substitute character.
+ */
+function replaceCharactersByIndex(text, indices, substitute) {
+  const modifiedTextSplitByLetter = text.split("");
+  indices.forEach(function (index) {
+    modifiedTextSplitByLetter.splice(index, 1, substitute);
+  });
+  return modifiedTextSplitByLetter.join("");
+}
+
+/**
+ * Generates upper and lower case for Turkish strings that contain characters İ or ı, which appear to not be processed correctly by regexes.
+ *
+ * @param {string} text The text to build possible upper and lower case alternatives.
+ *
+ * @returns {Array} An array of strings that contains all possible upper and lower case alternatives of the original string
+ */
+function replaceTurkishIs(text) {
+  // Get indices of all occurrences of İ, I, i, or ı.
+  const indicesOfAllIs = getIndicesOfCharacter(text, "İ").concat(getIndicesOfCharacter(text, "I"), getIndicesOfCharacter(text, "i"), getIndicesOfCharacter(text, "ı"));
+  indicesOfAllIs.sort();
+
+  // If there are no Is return the text
+  if (indicesOfAllIs.length === 0) {
+    return [text];
+  }
+  const indicesOfIsInWordBeginnings = arraysOverlap(getIndicesOfWords(text), indicesOfAllIs);
+  const results = [];
+
+  // First round of creating combinations: assign which indices will be replaced by İ
+  const combinationsDottedI = combinations(indicesOfIsInWordBeginnings);
+  combinationsDottedI.forEach(function (oneCombinationDottedI) {
+    // If the combination is full array, just add it to results immediately without going through the rest of iterations.
+    if (isEqual(oneCombinationDottedI, indicesOfIsInWordBeginnings)) {
+      results.push([oneCombinationDottedI, [], [], []]);
+    } else {
+      const indicesNotDottedI = arraysDifference(indicesOfIsInWordBeginnings, oneCombinationDottedI);
+
+      // Second round of creating combinations: assign which indices will be replaced by I
+      const combinationsDotlessI = combinations(indicesNotDottedI);
+      combinationsDotlessI.forEach(function (oneCombinationDotlessI) {
+        // If the combination is full array, just add it to results immediately without going through the rest of iterations.
+        if (isEqual(oneCombinationDotlessI, indicesNotDottedI)) {
+          results.push([oneCombinationDottedI, oneCombinationDotlessI, [], []]);
+        } else {
+          const indicesSmalli = arraysDifference(indicesNotDottedI, oneCombinationDotlessI);
+
+          // Third round of creating combinations: assign which indices will be replaced by i
+          const combinationsDottedi = combinations(indicesSmalli);
+          combinationsDottedi.forEach(function (oneCombinationDottedi) {
+            // If the combination is full array, just add it to results immediately without going through the rest of iterations.
+            if (isEqual(oneCombinationDottedi, indicesSmalli)) {
+              results.push([oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, []]);
+            } else {
+              const oneCombinationDotlessi = arraysDifference(indicesSmalli, oneCombinationDottedi);
+              results.push([oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, oneCombinationDotlessi]);
+            }
+          });
+        }
+      });
+    }
+  });
+  const textAlternations = [];
+  results.forEach(function (result) {
+    const toDottedI = replaceCharactersByIndex(text, result[0], "İ");
+    const toDotlessI = replaceCharactersByIndex(toDottedI, result[1], "I");
+    const toDottedi = replaceCharactersByIndex(toDotlessI, result[2], "i");
+    const toDotlessi = replaceCharactersByIndex(toDottedi, result[3], "ı");
+    textAlternations.push(toDotlessi);
+  });
+  return textAlternations;
+}
+const replaceTurkishIsMemoized = memoize(replaceTurkishIs);
+export { getIndicesOfWords, getIndicesOfCharacter, arraysDifference, arraysOverlap, combinations, replaceTurkishIs, replaceTurkishIsMemoized };
+//# sourceMappingURL=specialCharacterMappings.js.map

package/build/languageProcessing/helpers/transliterate/specialCharacterMappings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specialCharacterMappings.js","names":["filter","includes","isEqual","memoize","getWords","getIndicesOfWords","text","indices","words","startSearchFrom","forEach","word","currentIndex","indexOf","push","length","getIndicesOfCharacter","characterToFind","i","arraysDifference","bigArray","subarray","element","arraysOverlap","firstArray","secondArray","combinations","collection","acc","xs","array","x","l","concat","slice","replaceCharactersByIndex","substitute","modifiedTextSplitByLetter","split","index","splice","join","replaceTurkishIs","indicesOfAllIs","sort","indicesOfIsInWordBeginnings","results","combinationsDottedI","oneCombinationDottedI","indicesNotDottedI","combinationsDotlessI","oneCombinationDotlessI","indicesSmalli","combinationsDottedi","oneCombinationDottedi","oneCombinationDotlessi","textAlternations","result","toDottedI","toDotlessI","toDottedi","toDotlessi","replaceTurkishIsMemoized"],"sources":["../../../../src/languageProcessing/helpers/transliterate/specialCharacterMappings.js"],"sourcesContent":["import { filter, includes, isEqual, memoize } from \"lodash\";\nimport getWords from \"../word/getWords\";\n\n/**\n * Gets positions of the first character of a word in the input text.\n *\n * @param {string} text The original text, for which the indices of word beginnings need to be determined.\n *\n * @returns {Array} indices The array of indices in the text at which words start.\n */\nfunction getIndicesOfWords( text ) {\n\tconst indices = [];\n\tconst words = getWords( text );\n\tlet startSearchFrom = 0;\n\n\twords.forEach( function( word ) {\n\t\tconst currentIndex = text.indexOf( word, startSearchFrom );\n\t\tindices.push( currentIndex );\n\t\tstartSearchFrom = currentIndex + word.length;\n\t} );\n\n\treturn indices;\n}\n\n\n/**\n * Gets indices of a specific character in the input text.\n *\n * @param {string} text             The original text, for which the indices of specific characters have to be determined.\n * @param {string} characterToFind  The character that needs to be found in the text.\n *\n * @returns {Array} indices The array of indices in the text at which the characterToFind occurs.\n */\nfunction getIndicesOfCharacter( text, characterToFind ) {\n\tconst indices = [];\n\n\tif ( text.indexOf( characterToFind ) > -1 ) {\n\t\tfor ( let i = 0; i < text.length; i++ ) {\n\t\t\tif ( text[ i ] === characterToFind ) {\n\t\t\t\tindices.push( i );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn indices;\n}\n\n/**\n * Compares two arrays of which the second array is the sub-array of the first array.\n * Returns the array of elements of the first array which are not in the second array.\n *\n * @param {Array} bigArray The array with all elements.\n * @param {Array} subarray The array with some elements from the bigArray.\n *\n * @returns {Array} difference An array of all elements of bigArray which are not in subarray.\n */\nfunction arraysDifference( bigArray, subarray ) {\n\treturn filter( bigArray, function( element ) {\n\t\treturn ( ! includes( subarray, element ) );\n\t} );\n}\n\n/**\n * Compares two arrays and returns the array of elements that occur in both arrays.\n *\n * @param {Array} firstArray    The first array with elements to compare.\n * @param {Array} secondArray   The second array with elements to compare.\n *\n * @returns {Array} overlap An array of all elements of firstArray which are also in secondArray.\n */\nfunction arraysOverlap( firstArray, secondArray ) {\n\treturn filter( firstArray, function( element ) {\n\t\treturn ( includes( secondArray, element ) );\n\t} );\n}\n\n\n/**\n * Generates all possible combinations of the elements of an array (treated as unique).\n * https://gist.github.com/jpillora/4435759\n *\n * @param {Array} collection The array with elements that should be combined.\n *\n * @returns {Array} result An array of all possible combinations of elements of the original array.\n */\nfunction combinations( collection ) {\n\t/**\n\t * A recursive function that iterates through all elements of an array to produce its combinations.\n\t *\n\t * @param {Array} xs        The array to start accumulating with.\n\t * @param {Array} array     The array with elements that should be combined.\n\t *\n\t * @returns {Array} result An array of all possible combinations of elements of the original array.\n\t */\n\tfunction acc( xs, array ) {\n\t\tconst x = xs[ 0 ];\n\n\t\tif ( typeof x === \"undefined\" ) {\n\t\t\treturn array;\n\t\t}\n\n\t\tfor ( let i = 0, l = array.length; i < l; ++i ) {\n\t\t\tarray.push( array[ i ].concat( x ) );\n\t\t}\n\t\treturn acc( xs.slice( 1 ), array );\n\t}\n\treturn acc( collection, [ [ ] ] ).slice( 1 ).concat( [ [] ] );\n}\n\n\n/**\n * Replaces characters on specified indices in the input text.\n *\n * @param {string} text         The original text, for which the characters have to be substituted.\n * @param {Array} indices       The array of indices that have to be substituted.\n * @param {string} substitute   The character that is used to substitute in the text.\n *\n * @returns {string} result The string of the original text with the characters on specified indices are substituted with the substitute character.\n */\nfunction replaceCharactersByIndex( text, indices, substitute ) {\n\tconst modifiedTextSplitByLetter = text.split( \"\" );\n\n\tindices.forEach( function( index ) {\n\t\tmodifiedTextSplitByLetter.splice( index, 1, substitute );\n\t} );\n\n\treturn modifiedTextSplitByLetter.join( \"\" );\n}\n\n/**\n * Generates upper and lower case for Turkish strings that contain characters İ or ı, which appear to not be processed correctly by regexes.\n *\n * @param {string} text The text to build possible upper and lower case alternatives.\n *\n * @returns {Array} An array of strings that contains all possible upper and lower case alternatives of the original string\n */\nfunction replaceTurkishIs( text ) {\n\t// Get indices of all occurrences of İ, I, i, or ı.\n\tconst indicesOfAllIs = getIndicesOfCharacter( text, \"İ\" ).concat(\n\t\tgetIndicesOfCharacter( text, \"I\" ),\n\t\tgetIndicesOfCharacter( text, \"i\" ),\n\t\tgetIndicesOfCharacter( text, \"ı\" )\n\t);\n\tindicesOfAllIs.sort();\n\n\t// If there are no Is return the text\n\tif ( indicesOfAllIs.length === 0 ) {\n\t\treturn [ text ];\n\t}\n\tconst indicesOfIsInWordBeginnings = arraysOverlap( getIndicesOfWords( text ), indicesOfAllIs );\n\n\tconst results = [];\n\n\t// First round of creating combinations: assign which indices will be replaced by İ\n\tconst combinationsDottedI = combinations( indicesOfIsInWordBeginnings );\n\n\tcombinationsDottedI.forEach( function( oneCombinationDottedI ) {\n\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\tif ( isEqual( oneCombinationDottedI, indicesOfIsInWordBeginnings ) ) {\n\t\t\tresults.push( [ oneCombinationDottedI, [], [], [] ] );\n\t\t} else {\n\t\t\tconst indicesNotDottedI = arraysDifference( indicesOfIsInWordBeginnings, oneCombinationDottedI );\n\n\t\t\t// Second round of creating combinations: assign which indices will be replaced by I\n\t\t\tconst combinationsDotlessI = combinations( indicesNotDottedI );\n\t\t\tcombinationsDotlessI.forEach( function( oneCombinationDotlessI ) {\n\t\t\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\t\t\tif ( isEqual( oneCombinationDotlessI, indicesNotDottedI ) ) {\n\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, [], [] ] );\n\t\t\t\t} else {\n\t\t\t\t\tconst indicesSmalli = arraysDifference( indicesNotDottedI, oneCombinationDotlessI );\n\n\t\t\t\t\t// Third round of creating combinations: assign which indices will be replaced by i\n\t\t\t\t\tconst combinationsDottedi = combinations( indicesSmalli );\n\n\t\t\t\t\tcombinationsDottedi.forEach( function( oneCombinationDottedi ) {\n\t\t\t\t\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\t\t\t\t\tif ( isEqual( oneCombinationDottedi, indicesSmalli ) ) {\n\t\t\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, [] ] );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconst oneCombinationDotlessi = arraysDifference( indicesSmalli, oneCombinationDottedi );\n\n\t\t\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, oneCombinationDotlessi ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t} );\n\n\tconst textAlternations = [];\n\n\tresults.forEach( function( result ) {\n\t\tconst toDottedI = replaceCharactersByIndex( text, result[ 0 ], \"İ\" );\n\t\tconst toDotlessI = replaceCharactersByIndex( toDottedI, result[ 1 ], \"I\" );\n\t\tconst toDottedi = replaceCharactersByIndex( toDotlessI, result[ 2 ], \"i\" );\n\t\tconst toDotlessi = replaceCharactersByIndex( toDottedi, result[ 3 ], \"ı\" );\n\t\ttextAlternations.push( toDotlessi );\n\t} );\n\n\treturn textAlternations;\n}\n\nconst replaceTurkishIsMemoized = memoize( replaceTurkishIs );\n\nexport {\n\tgetIndicesOfWords,\n\tgetIndicesOfCharacter,\n\tarraysDifference,\n\tarraysOverlap,\n\tcombinations,\n\treplaceTurkishIs,\n\treplaceTurkishIsMemoized,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/transliterate.js

@@ -0,0 +1,18 @@
+import transliterationsMap from "../../../config/getTransliterations.js";
+
+/**
+ * Replaces all special characters from the text based on the transliterations map.
+ *
+ * @param {string} text     The text to remove special characters from.
+ * @param {string} locale   The locale.
+ *
+ * @returns {string} The text with all special characters replaced.
+ */
+export default function (text, locale) {
+  const map = transliterationsMap(locale);
+  for (let i = 0; i < map.length; i++) {
+    text = text.replace(map[i].letter, map[i].alternative);
+  }
+  return text;
+}
+//# sourceMappingURL=transliterate.js.map

package/build/languageProcessing/helpers/transliterate/transliterate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transliterate.js","names":["transliterationsMap","text","locale","map","i","length","replace","letter","alternative"],"sources":["../../../../src/languageProcessing/helpers/transliterate/transliterate.js"],"sourcesContent":["import transliterationsMap from \"../../../config/getTransliterations.js\";\n\n/**\n * Replaces all special characters from the text based on the transliterations map.\n *\n * @param {string} text     The text to remove special characters from.\n * @param {string} locale   The locale.\n *\n * @returns {string} The text with all special characters replaced.\n */\nexport default function( text, locale ) {\n\tconst map = transliterationsMap( locale );\n\tfor ( let i = 0; i < map.length; i++ ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letter,\n\t\t\tmap[ i ].alternative\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA,OAAOA,mBAAmB;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,MAAM,EAAG;EACvC,MAAMC,GAAG,GAAGH,mBAAmB,CAAEE,MAAO,CAAC;EACzC,KAAM,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,GAAG,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IACtCH,IAAI,GAAGA,IAAI,CAACK,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,MAAM,EACfJ,GAAG,CAAEC,CAAC,CAAE,CAACI,WACV,CAAC;EACF;EACA,OAAOP,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/transliterateWPstyle.js

@@ -0,0 +1,19 @@
+import transliterationsMap from "../../../config/transliterationsWPstyle.js";
+
+/**
+ * Replaces all special characters from the text based on the transliterations map specific for WP
+ * (and different from the one used by YoastSEO.js).
+ *
+ * @param {string} text     The text to remove special characters from.
+ * @param {string} locale   The locale.
+ *
+ * @returns {string} The text with all special characters replaced.
+ */
+export default function (text, locale) {
+  const map = transliterationsMap(locale);
+  for (let i = map.length - 1; i >= 0; i--) {
+    text = text.replace(map[i].letter, map[i].alternative);
+  }
+  return text;
+}
+//# sourceMappingURL=transliterateWPstyle.js.map

package/build/languageProcessing/helpers/transliterate/transliterateWPstyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transliterateWPstyle.js","names":["transliterationsMap","text","locale","map","i","length","replace","letter","alternative"],"sources":["../../../../src/languageProcessing/helpers/transliterate/transliterateWPstyle.js"],"sourcesContent":["import transliterationsMap from \"../../../config/transliterationsWPstyle.js\";\n\n/**\n * Replaces all special characters from the text based on the transliterations map specific for WP\n * (and different from the one used by YoastSEO.js).\n *\n * @param {string} text     The text to remove special characters from.\n * @param {string} locale   The locale.\n *\n * @returns {string} The text with all special characters replaced.\n */\nexport default function( text, locale ) {\n\tconst map = transliterationsMap( locale );\n\tfor ( let i = map.length - 1; i >= 0; i-- ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letter,\n\t\t\tmap[ i ].alternative\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA,OAAOA,mBAAmB;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,MAAM,EAAG;EACvC,MAAMC,GAAG,GAAGH,mBAAmB,CAAEE,MAAO,CAAC;EACzC,KAAM,IAAIE,CAAC,GAAGD,GAAG,CAACE,MAAM,GAAG,CAAC,EAAED,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAG;IAC3CH,IAAI,GAAGA,IAAI,CAACK,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,MAAM,EACfJ,GAAG,CAAEC,CAAC,CAAE,CAACI,WACV,CAAC;EACF;EACA,OAAOP,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/url/parseSlug.js

@@ -0,0 +1,11 @@
+/**
+ * Parses the slug by transforming hyphens and underscores into white space.
+ *
+ * @param {string} slug The slug to parse
+ *
+ * @returns {string} The parsed slug.
+ */
+export default function (slug) {
+  return slug.replace(/[-_]/ig, " ");
+}
+//# sourceMappingURL=parseSlug.js.map

package/build/languageProcessing/helpers/url/parseSlug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSlug.js","names":["slug","replace"],"sources":["../../../../src/languageProcessing/helpers/url/parseSlug.js"],"sourcesContent":["/**\n * Parses the slug by transforming hyphens and underscores into white space.\n *\n * @param {string} slug The slug to parse\n *\n * @returns {string} The parsed slug.\n */\nexport default function( slug ) {\n\treturn slug.replace( /[-_]/ig, \" \" );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAE,QAAQ,EAAE,GAAI,CAAC;AACrC","ignoreList":[]}

package/build/languageProcessing/helpers/url/url.js

@@ -0,0 +1,168 @@
+const urlFromAnchorRegex = /href=(["'])([^"']+)\1/i;
+import urlMethods from "url";
+
+/**
+ * Removes a hash from a URL, assumes a well formed URL.
+ *
+ * @param {string} url The URL to remove a hash from.
+ * @returns {string} The URL without the hash.
+ */
+function removeHash(url) {
+  return url.split("#")[0];
+}
+
+/**
+ * Removes all query args from a URL, assumes a well formed URL.
+ *
+ * @param {string} url The URL to remove the query args from.
+ * @returns {string} The URL without the query args.
+ */
+function removeQueryArgs(url) {
+  return url.split("?")[0];
+}
+
+/**
+ * Removes the trailing slash of a URL.
+ *
+ * @param {string} url The URL to remove the trailing slash from.
+ * @returns {string} A URL without a trailing slash.
+ */
+function removeTrailingSlash(url) {
+  return url.replace(/\/$/, "");
+}
+
+/**
+ * Adds a trailing slash to a URL if it is not present.
+ *
+ * @param {string} url The URL to add a trailing slash to.
+ * @returns {string} A URL with a trailing slash.
+ */
+function addTrailingSlash(url) {
+  return removeTrailingSlash(url) + "/";
+}
+
+/**
+ * Retrieves the URL from an anchor tag.
+ *
+ * @param {string} anchorTag An anchor tag.
+ * @returns {string} The URL in the anchor tag.
+ */
+function getFromAnchorTag(anchorTag) {
+  const urlMatch = urlFromAnchorRegex.exec(anchorTag);
+  return urlMatch === null ? "" : urlMatch[2];
+}
+
+/**
+ * Returns whether or not the given URLs are equal.
+ *
+ * @param {string} urlA The first URL to compare.
+ * @param {string} urlB The second URL to compare.
+ *
+ * @returns {boolean} Whether or not the given URLs are equal.
+ */
+function areEqual(urlA, urlB) {
+  // Make sure we are comparing URLs without query arguments and hashes.
+  urlA = removeQueryArgs(removeHash(urlA));
+  urlB = removeQueryArgs(removeHash(urlB));
+  return addTrailingSlash(urlA) === addTrailingSlash(urlB);
+}
+
+/**
+ * Returns the domain name of a URL.
+ *
+ * @param {string} url The URL to retrieve the domain name of.
+ * @returns {string} The domain name of the URL.
+ */
+function getHostname(url) {
+  url = urlMethods.parse(url);
+  return url.hostname;
+}
+
+/**
+ * Returns the protocol of a URL.
+ *
+ * Note that the colon (http:) is also part of the protocol, conform to node's url.parse api.
+ *
+ * @param {string} url The URL to retrieve the protocol of.
+ * @returns {string|null} The protocol of the URL or null if no protocol is present.
+ */
+function getProtocol(url) {
+  return urlMethods.parse(url).protocol;
+}
+
+/**
+ * Determine whether an anchor URL is internal.
+ *
+ * @param {string} anchorUrl 		The anchor URL to test.
+ * @param {string} siteUrlOrDomain  The current site's URL or domain.
+ *
+ * @returns {boolean} Whether or not the anchor URL is internal.
+ */
+function isInternalLink(anchorUrl, siteUrlOrDomain) {
+  const parsedAnchorUrl = urlMethods.parse(anchorUrl, false, true);
+  const anchorUrlHostName = parsedAnchorUrl.hostname;
+
+  // Check if the anchor URL starts with a single slash.
+  if (anchorUrl.indexOf("//") === -1 && anchorUrl.indexOf("/") === 0) {
+    return true;
+  }
+
+  // Check if the anchor URL starts with a # indicating a fragment.
+  if (anchorUrl.indexOf("#") === 0) {
+    return false;
+  }
+
+  // No host of the anchor URL indicates an internal link.
+  if (!anchorUrlHostName) {
+    return true;
+  }
+
+  // If the siteUrlOrDomain variable is a domain, it would be idential to the anchor URL's hostname in case of an internal link.
+  if (anchorUrlHostName === siteUrlOrDomain) {
+    return true;
+  }
+
+  // If the siteUrlOrDomain variable is a URL and it shares the hostname with the anchor URL, it's an internal link.
+  const parsedSiteUrlOrDomain = urlMethods.parse(siteUrlOrDomain);
+  const siteUrlOrDomainHostName = parsedSiteUrlOrDomain.hostname;
+  return anchorUrlHostName === siteUrlOrDomainHostName;
+}
+
+/**
+ * Checks whether the protocol is either HTTP: or HTTPS:.
+ *
+ * @param {string} protocol The protocol to test.
+ *
+ * @returns {boolean} Whether the protocol is http(s):.
+ */
+function protocolIsHttpScheme(protocol) {
+  if (!protocol) {
+    return false;
+  }
+  return protocol === "http:" || protocol === "https:";
+}
+
+/**
+ * Determines whether the link is a relative fragment URL.
+ *
+ * @param {string} url The URL to test.
+ *
+ * @returns {boolean} Whether the link is a relative fragment URL.
+ */
+function isRelativeFragmentURL(url) {
+  return url.indexOf("#") === 0;
+}
+export default {
+  removeHash: removeHash,
+  removeQueryArgs: removeQueryArgs,
+  removeTrailingSlash: removeTrailingSlash,
+  addTrailingSlash: addTrailingSlash,
+  getFromAnchorTag: getFromAnchorTag,
+  areEqual: areEqual,
+  getHostname: getHostname,
+  getProtocol: getProtocol,
+  isInternalLink: isInternalLink,
+  protocolIsHttpScheme: protocolIsHttpScheme,
+  isRelativeFragmentURL: isRelativeFragmentURL
+};
+//# sourceMappingURL=url.js.map

package/build/languageProcessing/helpers/url/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":["urlFromAnchorRegex","urlMethods","removeHash","url","split","removeQueryArgs","removeTrailingSlash","replace","addTrailingSlash","getFromAnchorTag","anchorTag","urlMatch","exec","areEqual","urlA","urlB","getHostname","parse","hostname","getProtocol","protocol","isInternalLink","anchorUrl","siteUrlOrDomain","parsedAnchorUrl","anchorUrlHostName","indexOf","parsedSiteUrlOrDomain","siteUrlOrDomainHostName","protocolIsHttpScheme","isRelativeFragmentURL"],"sources":["../../../../src/languageProcessing/helpers/url/url.js"],"sourcesContent":["const urlFromAnchorRegex = /href=([\"'])([^\"']+)\\1/i;\nimport urlMethods from \"url\";\n\n/**\n * Removes a hash from a URL, assumes a well formed URL.\n *\n * @param {string} url The URL to remove a hash from.\n * @returns {string} The URL without the hash.\n */\nfunction removeHash( url ) {\n\treturn url.split( \"#\" )[ 0 ];\n}\n\n/**\n * Removes all query args from a URL, assumes a well formed URL.\n *\n * @param {string} url The URL to remove the query args from.\n * @returns {string} The URL without the query args.\n */\nfunction removeQueryArgs( url ) {\n\treturn url.split( \"?\" )[ 0 ];\n}\n\n/**\n * Removes the trailing slash of a URL.\n *\n * @param {string} url The URL to remove the trailing slash from.\n * @returns {string} A URL without a trailing slash.\n */\nfunction removeTrailingSlash( url ) {\n\treturn url.replace( /\\/$/, \"\" );\n}\n\n/**\n * Adds a trailing slash to a URL if it is not present.\n *\n * @param {string} url The URL to add a trailing slash to.\n * @returns {string} A URL with a trailing slash.\n */\nfunction addTrailingSlash( url ) {\n\treturn removeTrailingSlash( url ) + \"/\";\n}\n\n/**\n * Retrieves the URL from an anchor tag.\n *\n * @param {string} anchorTag An anchor tag.\n * @returns {string} The URL in the anchor tag.\n */\nfunction getFromAnchorTag( anchorTag ) {\n\tconst urlMatch = urlFromAnchorRegex.exec( anchorTag );\n\n\treturn ( urlMatch === null ) ? \"\" : urlMatch[ 2 ];\n}\n\n/**\n * Returns whether or not the given URLs are equal.\n *\n * @param {string} urlA The first URL to compare.\n * @param {string} urlB The second URL to compare.\n *\n * @returns {boolean} Whether or not the given URLs are equal.\n */\nfunction areEqual( urlA, urlB ) {\n\t// Make sure we are comparing URLs without query arguments and hashes.\n\turlA = removeQueryArgs( removeHash( urlA ) );\n\turlB = removeQueryArgs( removeHash( urlB ) );\n\n\treturn addTrailingSlash( urlA ) === addTrailingSlash( urlB );\n}\n\n/**\n * Returns the domain name of a URL.\n *\n * @param {string} url The URL to retrieve the domain name of.\n * @returns {string} The domain name of the URL.\n */\nfunction getHostname( url ) {\n\turl = urlMethods.parse( url );\n\n\treturn url.hostname;\n}\n\n/**\n * Returns the protocol of a URL.\n *\n * Note that the colon (http:) is also part of the protocol, conform to node's url.parse api.\n *\n * @param {string} url The URL to retrieve the protocol of.\n * @returns {string|null} The protocol of the URL or null if no protocol is present.\n */\nfunction getProtocol( url ) {\n\treturn urlMethods.parse( url ).protocol;\n}\n\n/**\n * Determine whether an anchor URL is internal.\n *\n * @param {string} anchorUrl \t\tThe anchor URL to test.\n * @param {string} siteUrlOrDomain  The current site's URL or domain.\n *\n * @returns {boolean} Whether or not the anchor URL is internal.\n */\nfunction isInternalLink( anchorUrl, siteUrlOrDomain ) {\n\tconst parsedAnchorUrl = urlMethods.parse( anchorUrl, false, true );\n\tconst anchorUrlHostName = parsedAnchorUrl.hostname;\n\n\t// Check if the anchor URL starts with a single slash.\n\tif ( anchorUrl.indexOf( \"//\" ) === -1 && anchorUrl.indexOf( \"/\" ) === 0 ) {\n\t\treturn true;\n\t}\n\n\t// Check if the anchor URL starts with a # indicating a fragment.\n\tif ( anchorUrl.indexOf( \"#\" ) === 0 ) {\n\t\treturn false;\n\t}\n\n\t// No host of the anchor URL indicates an internal link.\n\tif ( ! anchorUrlHostName ) {\n\t\treturn true;\n\t}\n\n\t// If the siteUrlOrDomain variable is a domain, it would be idential to the anchor URL's hostname in case of an internal link.\n\tif ( anchorUrlHostName === siteUrlOrDomain ) {\n\t\treturn true;\n\t}\n\n\t// If the siteUrlOrDomain variable is a URL and it shares the hostname with the anchor URL, it's an internal link.\n\tconst parsedSiteUrlOrDomain = urlMethods.parse( siteUrlOrDomain );\n\tconst siteUrlOrDomainHostName = parsedSiteUrlOrDomain.hostname;\n\treturn anchorUrlHostName === siteUrlOrDomainHostName;\n}\n\n/**\n * Checks whether the protocol is either HTTP: or HTTPS:.\n *\n * @param {string} protocol The protocol to test.\n *\n * @returns {boolean} Whether the protocol is http(s):.\n */\nfunction protocolIsHttpScheme( protocol ) {\n\tif ( ! protocol ) {\n\t\treturn false;\n\t}\n\n\treturn ( protocol === \"http:\" || protocol === \"https:\" );\n}\n\n/**\n * Determines whether the link is a relative fragment URL.\n *\n * @param {string} url The URL to test.\n *\n * @returns {boolean} Whether the link is a relative fragment URL.\n */\nfunction isRelativeFragmentURL( url ) {\n\treturn url.indexOf( \"#\" ) === 0;\n}\n\nexport default {\n\tremoveHash: removeHash,\n\tremoveQueryArgs: removeQueryArgs,\n\tremoveTrailingSlash: removeTrailingSlash,\n\taddTrailingSlash: addTrailingSlash,\n\tgetFromAnchorTag: getFromAnchorTag,\n\tareEqual: areEqual,\n\tgetHostname: getHostname,\n\tgetProtocol: getProtocol,\n\tisInternalLink: isInternalLink,\n\tprotocolIsHttpScheme: protocolIsHttpScheme,\n\tisRelativeFragmentURL: isRelativeFragmentURL,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/word/addWordboundary.js

@@ -0,0 +1,35 @@
+/**
+ * Returns a string that can be used in a regex to match a matchString with word boundaries.
+ *
+ * @param {string}  matchString                 The string to generate a regex string for.
+ * @param {boolean} [positiveLookAhead=false]   Boolean indicating whether or not to include a positive look ahead
+ * for the word boundaries at the end.
+ * @param {string} [extraWordBoundary=""]       Extra characters to match a word boundary on.
+ * @param {string} [language=""]                The language used to determine the word boundary.
+ *
+ * @returns {string} A regex string that matches the matchString with word boundaries.
+ */
+export default function (matchString, positiveLookAhead = false, extraWordBoundary = "", language = "") {
+  let wordBoundary, wordBoundaryEnd;
+  if (language === "id") {
+    wordBoundary = "[ \\u00a0\\n\\r\\t.,()”“〝〞〟‟„\"+;!¡?¿:/»«‹›" + extraWordBoundary + "<>";
+  } else {
+    /*
+     * \u00a0 - no-break space
+     * \u2014 - em dash
+           * \u06d4 - Urdu full stop
+           * \u061f - Arabic question mark
+           * \u060C - Arabic comma
+           * \u061B - Arabic semicolon
+           */
+    wordBoundary = "[ \\u00a0\\u2014\\u06d4\\u061f\\u060C\\u061B\\n\\r\\t.,()”“〝〞〟‟„\"+\\-;!¡?¿:/»«‹›" + extraWordBoundary + "<>";
+  }
+  const wordBoundaryStart = "(^|" + wordBoundary + "'‘’‛`])";
+  if (positiveLookAhead) {
+    wordBoundaryEnd = "($|((?=" + wordBoundary + "]))|((['‘’‛`])(" + wordBoundary + "])))";
+  } else {
+    wordBoundaryEnd = "($|(" + wordBoundary + "])|((['‘’‛`])(" + wordBoundary + "])))";
+  }
+  return wordBoundaryStart + matchString + wordBoundaryEnd;
+}
+//# sourceMappingURL=addWordboundary.js.map

package/build/languageProcessing/helpers/word/addWordboundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addWordboundary.js","names":["matchString","positiveLookAhead","extraWordBoundary","language","wordBoundary","wordBoundaryEnd","wordBoundaryStart"],"sources":["../../../../src/languageProcessing/helpers/word/addWordboundary.js"],"sourcesContent":["/**\n * Returns a string that can be used in a regex to match a matchString with word boundaries.\n *\n * @param {string}  matchString                 The string to generate a regex string for.\n * @param {boolean} [positiveLookAhead=false]   Boolean indicating whether or not to include a positive look ahead\n * for the word boundaries at the end.\n * @param {string} [extraWordBoundary=\"\"]       Extra characters to match a word boundary on.\n * @param {string} [language=\"\"]                The language used to determine the word boundary.\n *\n * @returns {string} A regex string that matches the matchString with word boundaries.\n */\nexport default function( matchString, positiveLookAhead = false, extraWordBoundary = \"\", language = \"\" ) {\n\tlet wordBoundary, wordBoundaryEnd;\n\n\tif ( language === \"id\" ) {\n\t\twordBoundary = \"[ \\\\u00a0\\\\n\\\\r\\\\t.,()”“〝〞〟‟„\\\"+;!¡?¿:/»«‹›\" + extraWordBoundary + \"<>\";\n\t} else {\n\t\t/*\n\t\t * \\u00a0 - no-break space\n\t\t * \\u2014 - em dash\n         * \\u06d4 - Urdu full stop\n         * \\u061f - Arabic question mark\n         * \\u060C - Arabic comma\n         * \\u061B - Arabic semicolon\n         */\n\t\twordBoundary = \"[ \\\\u00a0\\\\u2014\\\\u06d4\\\\u061f\\\\u060C\\\\u061B\\\\n\\\\r\\\\t.,()”“〝〞〟‟„\\\"+\\\\-;!¡?¿:/»«‹›\" + extraWordBoundary + \"<>\";\n\t}\n\n\tconst wordBoundaryStart = \"(^|\" + wordBoundary + \"'‘’‛`])\";\n\tif ( positiveLookAhead ) {\n\t\twordBoundaryEnd = \"($|((?=\" + wordBoundary + \"]))|((['‘’‛`])(\" + wordBoundary + \"])))\";\n\t} else {\n\t\twordBoundaryEnd = \"($|(\" + wordBoundary + \"])|((['‘’‛`])(\" + wordBoundary + \"])))\";\n\t}\n\n\treturn wordBoundaryStart + matchString + wordBoundaryEnd;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,WAAW,EAAEC,iBAAiB,GAAG,KAAK,EAAEC,iBAAiB,GAAG,EAAE,EAAEC,QAAQ,GAAG,EAAE,EAAG;EACxG,IAAIC,YAAY,EAAEC,eAAe;EAEjC,IAAKF,QAAQ,KAAK,IAAI,EAAG;IACxBC,YAAY,GAAG,6CAA6C,GAAGF,iBAAiB,GAAG,IAAI;EACxF,CAAC,MAAM;IACN;AACF;AACA;AACA;AACA;AACA;AACA;AACA;IACEE,YAAY,GAAG,mFAAmF,GAAGF,iBAAiB,GAAG,IAAI;EAC9H;EAEA,MAAMI,iBAAiB,GAAG,KAAK,GAAGF,YAAY,GAAG,SAAS;EAC1D,IAAKH,iBAAiB,EAAG;IACxBI,eAAe,GAAG,SAAS,GAAGD,YAAY,GAAG,iBAAiB,GAAGA,YAAY,GAAG,MAAM;EACvF,CAAC,MAAM;IACNC,eAAe,GAAG,MAAM,GAAGD,YAAY,GAAG,gBAAgB,GAAGA,YAAY,GAAG,MAAM;EACnF;EAEA,OAAOE,iBAAiB,GAAGN,WAAW,GAAGK,eAAe;AACzD","ignoreList":[]}