axyseo 2.0.0-alpha.2 → 2.1.0

package/build/languageProcessing/helpers/morphology/buildFormRule.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildFormRule;
 /**
  * Checks if the input word qualifies for the input regex and if so builds a required form.
  * This function is used for other more specific functions.
@@ -13,7 +7,7 @@ exports.default = buildFormRule;
  *
  * @returns {string} The newly built form of the word.
  */
-function buildFormRule(word, regexes) {
+export default function buildFormRule(word, regexes) {
   if (regexes.includes(null)) {
     return word;
   }

package/build/languageProcessing/helpers/morphology/buildFormRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildFormRule.js","names":["buildFormRule","word","regexes","includes","i","length","reg","test","replace","repl"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildFormRule.js"],"sourcesContent":["/**\n * Checks if the input word qualifies for the input regex and if so builds a required form.\n * This function is used for other more specific functions.\n *\n * @param {string} word The word to build forms for.\n * @param {Array} regexes The regex-based array of rules to compare the word against.\n *\n * @returns {string} The newly built form of the word.\n */\nexport default function buildFormRule( word, regexes ) {\n\tif ( regexes.includes( null ) ) {\n\t\treturn word;\n\t}\n\tfor ( let i = 0; i < regexes.length; i++ ) {\n\t\tif ( regexes[ i ].reg.test( word ) === true ) {\n\t\t\treturn word.replace( regexes[ i ].reg, regexes[ i ].repl );\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,aAAaA,CAAEC,IAAI,EAAEC,OAAO,EAAG;EACtD,IAAKA,OAAO,CAACC,QAAQ,CAAE,IAAK,CAAC,EAAG;IAC/B,OAAOF,IAAI;EACZ;EACA,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,CAACG,MAAM,EAAED,CAAC,EAAE,EAAG;IAC1C,IAAKF,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,CAACC,IAAI,CAAEN,IAAK,CAAC,KAAK,IAAI,EAAG;MAC7C,OAAOA,IAAI,CAACO,OAAO,CAAEN,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,EAAEJ,OAAO,CAAEE,CAAC,CAAE,CAACK,IAAK,CAAC;IAC3D;EACD;AACD","ignoreList":[]}
+{"version":3,"file":"buildFormRule.js","names":["buildFormRule","word","regexes","includes","i","length","reg","test","replace","repl"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildFormRule.js"],"sourcesContent":["/**\n * Checks if the input word qualifies for the input regex and if so builds a required form.\n * This function is used for other more specific functions.\n *\n * @param {string} word The word to build forms for.\n * @param {Array} regexes The regex-based array of rules to compare the word against.\n *\n * @returns {string} The newly built form of the word.\n */\nexport default function buildFormRule( word, regexes ) {\n\tif ( regexes.includes( null ) ) {\n\t\treturn word;\n\t}\n\tfor ( let i = 0; i < regexes.length; i++ ) {\n\t\tif ( regexes[ i ].reg.test( word ) === true ) {\n\t\t\treturn word.replace( regexes[ i ].reg, regexes[ i ].repl );\n\t\t}\n\t}\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,aAAaA,CAAEC,IAAI,EAAEC,OAAO,EAAG;EACtD,IAAKA,OAAO,CAACC,QAAQ,CAAE,IAAK,CAAC,EAAG;IAC/B,OAAOF,IAAI;EACZ;EACA,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,CAACG,MAAM,EAAED,CAAC,EAAE,EAAG;IAC1C,IAAKF,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,CAACC,IAAI,CAAEN,IAAK,CAAC,KAAK,IAAI,EAAG;MAC7C,OAAOA,IAAI,CAACO,OAAO,CAAEN,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,EAAEJ,OAAO,CAAEE,CAAC,CAAE,CAACK,IAAK,CAAC;IAC3D;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/buildTopicStems.js

@@ -1,18 +1,9 @@
-"use strict";
+import getWords from "../word/getWords.js";
+import { normalizeSingle } from "../sanitize/quotes";
+import { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from "../../../config/wordBoundariesWithoutPunctuation";
+import { isUndefined, escapeRegExp, memoize } from "lodash";
+import isDoubleQuoted from "../match/isDoubleQuoted";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.StemOriginalPair = StemOriginalPair;
-exports.buildStems = exports.TopicPhrase = void 0;
-exports.collectStems = collectStems;
-exports.primeLanguageSpecificData = void 0;
-var _getWords = _interopRequireDefault(require("../word/getWords.js"));
-var _quotes = require("../sanitize/quotes");
-var _wordBoundariesWithoutPunctuation = require("../../../config/wordBoundariesWithoutPunctuation");
-var _lodash = require("lodash");
-var _isDoubleQuoted = _interopRequireDefault(require("../match/isDoubleQuoted"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * A TopicPhrase (i.e., a keyphrase or synonym) with stem-original pairs for the words in the topic phrase.
  */
@@ -52,7 +43,6 @@ class TopicPhrase {
  *
  * @constructor
  */
-exports.TopicPhrase = TopicPhrase;
 function StemOriginalPair(stem, original) {
   this.stem = stem;
   this.original = original;
@@ -73,21 +63,21 @@ function StemOriginalPair(stem, original) {
  * phrase and information about whether the keyphrase/synonym should be matched exactly.
  */
 const buildStems = function (keyphrase, stemmer, functionWords, areHyphensWordBoundaries) {
-  if ((0, _lodash.isUndefined)(keyphrase) || keyphrase === "") {
+  if (isUndefined(keyphrase) || keyphrase === "") {
     return new TopicPhrase();
   }
 
   // If the keyphrase is embedded in double quotation marks, return the keyphrase itself, without the outermost quotation marks.
-  if ((0, _isDoubleQuoted.default)(keyphrase)) {
+  if (isDoubleQuoted(keyphrase)) {
     keyphrase = keyphrase.substring(1, keyphrase.length - 1);
-    return new TopicPhrase([new StemOriginalPair((0, _lodash.escapeRegExp)(keyphrase), keyphrase)], true);
+    return new TopicPhrase([new StemOriginalPair(escapeRegExp(keyphrase), keyphrase)], true);
   }
 
   /*
    * 	If hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,
    *  hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.
    */
-  let keyphraseWords = areHyphensWordBoundaries ? (0, _getWords.default)(keyphrase, _wordBoundariesWithoutPunctuation.WORD_BOUNDARY_WITH_HYPHEN) : (0, _getWords.default)(keyphrase, _wordBoundariesWithoutPunctuation.WORD_BOUNDARY_WITHOUT_HYPHEN);
+  let keyphraseWords = areHyphensWordBoundaries ? getWords(keyphrase, WORD_BOUNDARY_WITH_HYPHEN) : getWords(keyphrase, WORD_BOUNDARY_WITHOUT_HYPHEN);
 
   // Filter function words from the keyphrase. Don't filter if the keyphrase only consists of function words.
   const wordsWithoutFunctionWords = keyphraseWords.filter(word => !functionWords.includes(word));
@@ -97,7 +87,7 @@ const buildStems = function (keyphrase, stemmer, functionWords, areHyphensWordBo
 
   // Return a stem-original pair with a stem.
   const stemOriginalPairs = keyphraseWords.map(word => {
-    return new StemOriginalPair(stemmer((0, _quotes.normalizeSingle)((0, _lodash.escapeRegExp)(word))), word);
+    return new StemOriginalPair(stemmer(normalizeSingle(escapeRegExp(word))), word);
   });
   return new TopicPhrase(stemOriginalPairs);
 };
@@ -113,7 +103,6 @@ const buildStems = function (keyphrase, stemmer, functionWords, areHyphensWordBo
  *
  * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.
  */
-exports.buildStems = buildStems;
 const collectKeyphraseAndSynonymsStems = function (keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries) {
   const keyphraseStems = buildStems(keyphrase, stemmer, functionWords, areHyphensWordBoundaries);
   const synonymsStems = synonyms.map(synonym => buildStems(synonym, stemmer, functionWords, areHyphensWordBoundaries));
@@ -137,8 +126,8 @@ const collectKeyphraseAndSynonymsStems = function (keyphrase, synonyms, stemmer,
  *
  * @returns {function} The function that collects the stems for a given set of keyphrase, synonyms, stemmer and functionWords.
  */
-const primeLanguageSpecificData = exports.primeLanguageSpecificData = (0, _lodash.memoize)((stemmer, functionWords, areHyphensWordBoundaries) => {
-  return (0, _lodash.memoize)((keyphrase, synonyms) => {
+const primeLanguageSpecificData = memoize((stemmer, functionWords, areHyphensWordBoundaries) => {
+  return memoize((keyphrase, synonyms) => {
     return collectKeyphraseAndSynonymsStems(keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries);
   }, (keyphrase, synonyms) => {
     return keyphrase + "," + synonyms.join(",");
@@ -161,4 +150,5 @@ function collectStems(keyphrase, synonyms, stemmer, functionWords, areHyphensWor
   const collectStemsWithLanguageSpecificData = primeLanguageSpecificData(stemmer, functionWords, areHyphensWordBoundaries);
   return collectStemsWithLanguageSpecificData(keyphrase, synonyms);
 }
+export { buildStems, collectStems, TopicPhrase, StemOriginalPair, primeLanguageSpecificData };
 //# sourceMappingURL=buildTopicStems.js.map

package/build/languageProcessing/helpers/morphology/buildTopicStems.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildTopicStems.js","names":["_getWords","_interopRequireDefault","require","_quotes","_wordBoundariesWithoutPunctuation","_lodash","_isDoubleQuoted","e","__esModule","default","TopicPhrase","constructor","stemOriginalPairs","exactMatch","getStems","map","stemOriginalPair","stem","exports","StemOriginalPair","original","buildStems","keyphrase","stemmer","functionWords","areHyphensWordBoundaries","isUndefined","isDoubleQuoted","substring","length","escapeRegExp","keyphraseWords","getWords","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","wordsWithoutFunctionWords","filter","word","includes","normalizeSingle","collectKeyphraseAndSynonymsStems","synonyms","keyphraseStems","synonymsStems","synonym","primeLanguageSpecificData","memoize","join","collectStems","collectStemsWithLanguageSpecificData"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildTopicStems.js"],"sourcesContent":["import getWords from \"../word/getWords.js\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"../../../config/wordBoundariesWithoutPunctuation\";\n\nimport { isUndefined, escapeRegExp, memoize } from \"lodash\";\nimport isDoubleQuoted from \"../match/isDoubleQuoted\";\n\n/**\n * A TopicPhrase (i.e., a keyphrase or synonym) with stem-original pairs for the words in the topic phrase.\n */\nclass TopicPhrase {\n\t/**\n\t * Constructs a new TopicPhrase.\n\t *\n\t * @param {StemOriginalPair[]} stemOriginalPairs The stem-original pairs for the words in the topic phrase.\n\t * @param {boolean}            exactMatch        Whether the topic phrase is an exact match.\n\t *\n\t * @constructor\n\t */\n\tconstructor( stemOriginalPairs = [], exactMatch = false ) {\n\t\tthis.stemOriginalPairs = stemOriginalPairs;\n\t\tthis.exactMatch = exactMatch;\n\t}\n\n\t/**\n\t * Returns all stems in the topic phrase.\n\t *\n\t * @returns {string[]|[]} The stems in the topic phrase or empty array if the topic phrase is exact match.\n\t */\n\tgetStems() {\n\t\t// An exact match keyphrase doesn't have stems.\n\t\tif ( this.exactMatch ) {\n\t\t\treturn [];\n\t\t}\n\n\t\treturn this.stemOriginalPairs.map( stemOriginalPair => stemOriginalPair.stem );\n\t}\n}\n\n/**\n * A stem-original pair ƒor a word in a topic phrase.\n *\n * @param {string} stem     The stem of the topic phrase word.\n * @param {string} original The original word form the topic phrase (unsanitized)\n *\n * @constructor\n */\nfunction StemOriginalPair( stem, original ) {\n\tthis.stem = stem;\n\tthis.original = original;\n}\n\n/**\n * Analyzes the focus keyword string or one synonym phrase.\n * Checks if morphology is requested or if the user wants to match the exact string.\n * If morphology is required, the module finds a stem for all words (if no function words list is available), or\n * for all content words (i.e., excluding prepositions, articles, conjunctions, if the function words list is available).\n *\n * @param {string}   keyphrase     \t\t\t\tThe keyphrase of the paper (or a synonym phrase) to get stem for.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer.\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {TopicPhrase} Object with an array of StemOriginalPairs of all (content) words in the keyphrase or synonym\n * phrase and information about whether the keyphrase/synonym should be matched exactly.\n */\nconst buildStems = function( keyphrase, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tif ( isUndefined( keyphrase ) || keyphrase === \"\" ) {\n\t\treturn new TopicPhrase();\n\t}\n\n\t// If the keyphrase is embedded in double quotation marks, return the keyphrase itself, without the outermost quotation marks.\n\tif ( isDoubleQuoted( keyphrase ) ) {\n\t\tkeyphrase = keyphrase.substring( 1, keyphrase.length - 1 );\n\t\treturn new TopicPhrase(\n\t\t\t[ new StemOriginalPair( escapeRegExp( keyphrase ), keyphrase ) ],\n\t\t\ttrue\n\t\t);\n\t}\n\n\t/*\n\t * \tIf hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n\t *  hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n\t */\n\tlet keyphraseWords = areHyphensWordBoundaries ? getWords( keyphrase, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( keyphrase, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\t// Filter function words from the keyphrase. Don't filter if the keyphrase only consists of function words.\n\tconst wordsWithoutFunctionWords = keyphraseWords.filter( ( word ) => ! functionWords.includes( word ) );\n\tif ( wordsWithoutFunctionWords.length > 0 ) {\n\t\tkeyphraseWords = wordsWithoutFunctionWords;\n\t}\n\n\t// Return a stem-original pair with a stem.\n\tconst stemOriginalPairs = keyphraseWords.map( word => {\n\t\treturn new StemOriginalPair( stemmer( normalizeSingle( escapeRegExp( word ) ) ), word );\n\t} );\n\n\treturn new TopicPhrase( stemOriginalPairs );\n};\n\n/**\n * Builds stems of words of the keyphrase and of each synonym phrase.\n *\n * @param {string}   keyphrase     \t\t\t\tThe paper's keyphrase.\n * @param {string[]} synonyms     \t\t\t\tThe paper's synonyms.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nconst collectKeyphraseAndSynonymsStems = function( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst keyphraseStems = buildStems( keyphrase, stemmer, functionWords, areHyphensWordBoundaries );\n\tconst synonymsStems = synonyms.map( synonym => buildStems( synonym, stemmer, functionWords, areHyphensWordBoundaries ) );\n\n\treturn {\n\t\tkeyphraseStems,\n\t\tsynonymsStems,\n\t};\n};\n\n/**\n * Caches stems depending on the currently available stemmer and functionWords and (separately) keyphrase and synonyms.\n * In this way, if the stemmer and functionWords remain the same in multiple calls of this function, the function\n * that collects actual stems only needs to check if the keyphrase and synonyms also remain the\n * same to return the cached result. The joining of keyphrase and synonyms for this function is needed,\n * because by default memoize caches by the first key only, which in the current case would mean that the function would\n * return the cached forms if the keyphrase has not changed (without checking if synonyms were changed).\n *\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {function} The function that collects the stems for a given set of keyphrase, synonyms, stemmer and functionWords.\n */\nconst primeLanguageSpecificData = memoize( ( stemmer, functionWords, areHyphensWordBoundaries ) => {\n\treturn memoize( ( keyphrase, synonyms ) => {\n\t\treturn collectKeyphraseAndSynonymsStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries );\n\t}, ( keyphrase, synonyms ) => {\n\t\treturn keyphrase + \",\" + synonyms.join( \",\" );\n\t} );\n} );\n\n/**\n * Retrieves stems of words of the keyphrase and of each synonym phrase using the function that caches\n * the results of previous calls of this function.\n *\n * @param {string}      keyphrase       \t\t\tThe paper's keyphrase.\n * @param {string[]}    synonyms        \t\t\tThe paper's synonyms.\n * @param {function}    stemmer         \t\t\tThe language-specific stemmer (if available).\n * @param {string[]}    functionWords   \t\t\tThe language-specific function words.\n * @param {boolean}\t\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nfunction collectStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst collectStemsWithLanguageSpecificData = primeLanguageSpecificData( stemmer, functionWords, areHyphensWordBoundaries );\n\n\treturn collectStemsWithLanguageSpecificData( keyphrase, synonyms );\n}\n\nexport {\n\tbuildStems,\n\tcollectStems,\n\tTopicPhrase,\n\tStemOriginalPair,\n\tprimeLanguageSpecificData,\n};\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"buildTopicStems.js","names":["getWords","normalizeSingle","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","isUndefined","escapeRegExp","memoize","isDoubleQuoted","TopicPhrase","constructor","stemOriginalPairs","exactMatch","getStems","map","stemOriginalPair","stem","StemOriginalPair","original","buildStems","keyphrase","stemmer","functionWords","areHyphensWordBoundaries","substring","length","keyphraseWords","wordsWithoutFunctionWords","filter","word","includes","collectKeyphraseAndSynonymsStems","synonyms","keyphraseStems","synonymsStems","synonym","primeLanguageSpecificData","join","collectStems","collectStemsWithLanguageSpecificData"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildTopicStems.js"],"sourcesContent":["import getWords from \"../word/getWords.js\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"@axyseo/config/wordBoundariesWithoutPunctuation\";\n\nimport { isUndefined, escapeRegExp, memoize } from \"lodash\";\nimport isDoubleQuoted from \"../match/isDoubleQuoted\";\n\n/**\n * A TopicPhrase (i.e., a keyphrase or synonym) with stem-original pairs for the words in the topic phrase.\n */\nclass TopicPhrase {\n\t/**\n\t * Constructs a new TopicPhrase.\n\t *\n\t * @param {StemOriginalPair[]} stemOriginalPairs The stem-original pairs for the words in the topic phrase.\n\t * @param {boolean}            exactMatch        Whether the topic phrase is an exact match.\n\t *\n\t * @constructor\n\t */\n\tconstructor( stemOriginalPairs = [], exactMatch = false ) {\n\t\tthis.stemOriginalPairs = stemOriginalPairs;\n\t\tthis.exactMatch = exactMatch;\n\t}\n\n\t/**\n\t * Returns all stems in the topic phrase.\n\t *\n\t * @returns {string[]|[]} The stems in the topic phrase or empty array if the topic phrase is exact match.\n\t */\n\tgetStems() {\n\t\t// An exact match keyphrase doesn't have stems.\n\t\tif ( this.exactMatch ) {\n\t\t\treturn [];\n\t\t}\n\n\t\treturn this.stemOriginalPairs.map( stemOriginalPair => stemOriginalPair.stem );\n\t}\n}\n\n/**\n * A stem-original pair ƒor a word in a topic phrase.\n *\n * @param {string} stem     The stem of the topic phrase word.\n * @param {string} original The original word form the topic phrase (unsanitized)\n *\n * @constructor\n */\nfunction StemOriginalPair( stem, original ) {\n\tthis.stem = stem;\n\tthis.original = original;\n}\n\n/**\n * Analyzes the focus keyword string or one synonym phrase.\n * Checks if morphology is requested or if the user wants to match the exact string.\n * If morphology is required, the module finds a stem for all words (if no function words list is available), or\n * for all content words (i.e., excluding prepositions, articles, conjunctions, if the function words list is available).\n *\n * @param {string}   keyphrase     \t\t\t\tThe keyphrase of the paper (or a synonym phrase) to get stem for.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer.\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {TopicPhrase} Object with an array of StemOriginalPairs of all (content) words in the keyphrase or synonym\n * phrase and information about whether the keyphrase/synonym should be matched exactly.\n */\nconst buildStems = function( keyphrase, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tif ( isUndefined( keyphrase ) || keyphrase === \"\" ) {\n\t\treturn new TopicPhrase();\n\t}\n\n\t// If the keyphrase is embedded in double quotation marks, return the keyphrase itself, without the outermost quotation marks.\n\tif ( isDoubleQuoted( keyphrase ) ) {\n\t\tkeyphrase = keyphrase.substring( 1, keyphrase.length - 1 );\n\t\treturn new TopicPhrase(\n\t\t\t[ new StemOriginalPair( escapeRegExp( keyphrase ), keyphrase ) ],\n\t\t\ttrue\n\t\t);\n\t}\n\n\t/*\n\t * \tIf hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n\t *  hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n\t */\n\tlet keyphraseWords = areHyphensWordBoundaries ? getWords( keyphrase, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( keyphrase, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\t// Filter function words from the keyphrase. Don't filter if the keyphrase only consists of function words.\n\tconst wordsWithoutFunctionWords = keyphraseWords.filter( ( word ) => ! functionWords.includes( word ) );\n\tif ( wordsWithoutFunctionWords.length > 0 ) {\n\t\tkeyphraseWords = wordsWithoutFunctionWords;\n\t}\n\n\t// Return a stem-original pair with a stem.\n\tconst stemOriginalPairs = keyphraseWords.map( word => {\n\t\treturn new StemOriginalPair( stemmer( normalizeSingle( escapeRegExp( word ) ) ), word );\n\t} );\n\n\treturn new TopicPhrase( stemOriginalPairs );\n};\n\n/**\n * Builds stems of words of the keyphrase and of each synonym phrase.\n *\n * @param {string}   keyphrase     \t\t\t\tThe paper's keyphrase.\n * @param {string[]} synonyms     \t\t\t\tThe paper's synonyms.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nconst collectKeyphraseAndSynonymsStems = function( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst keyphraseStems = buildStems( keyphrase, stemmer, functionWords, areHyphensWordBoundaries );\n\tconst synonymsStems = synonyms.map( synonym => buildStems( synonym, stemmer, functionWords, areHyphensWordBoundaries ) );\n\n\treturn {\n\t\tkeyphraseStems,\n\t\tsynonymsStems,\n\t};\n};\n\n/**\n * Caches stems depending on the currently available stemmer and functionWords and (separately) keyphrase and synonyms.\n * In this way, if the stemmer and functionWords remain the same in multiple calls of this function, the function\n * that collects actual stems only needs to check if the keyphrase and synonyms also remain the\n * same to return the cached result. The joining of keyphrase and synonyms for this function is needed,\n * because by default memoize caches by the first key only, which in the current case would mean that the function would\n * return the cached forms if the keyphrase has not changed (without checking if synonyms were changed).\n *\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {function} The function that collects the stems for a given set of keyphrase, synonyms, stemmer and functionWords.\n */\nconst primeLanguageSpecificData = memoize( ( stemmer, functionWords, areHyphensWordBoundaries ) => {\n\treturn memoize( ( keyphrase, synonyms ) => {\n\t\treturn collectKeyphraseAndSynonymsStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries );\n\t}, ( keyphrase, synonyms ) => {\n\t\treturn keyphrase + \",\" + synonyms.join( \",\" );\n\t} );\n} );\n\n/**\n * Retrieves stems of words of the keyphrase and of each synonym phrase using the function that caches\n * the results of previous calls of this function.\n *\n * @param {string}      keyphrase       \t\t\tThe paper's keyphrase.\n * @param {string[]}    synonyms        \t\t\tThe paper's synonyms.\n * @param {function}    stemmer         \t\t\tThe language-specific stemmer (if available).\n * @param {string[]}    functionWords   \t\t\tThe language-specific function words.\n * @param {boolean}\t\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nfunction collectStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst collectStemsWithLanguageSpecificData = primeLanguageSpecificData( stemmer, functionWords, areHyphensWordBoundaries );\n\n\treturn collectStemsWithLanguageSpecificData( keyphrase, synonyms );\n}\n\nexport {\n\tbuildStems,\n\tcollectStems,\n\tTopicPhrase,\n\tStemOriginalPair,\n\tprimeLanguageSpecificData,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/createRulesFromArrays.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.createSingleRuleFromArray = exports.createRulesFromArrays = void 0;
 /**
  * Creates an object with a regex and a replacement pair to be processed.
  *
@@ -39,10 +33,9 @@ const createSingleRuleFromArray = function (rule, flags = "i") {
  *
  * @returns {Array} Array of objects to be used in the regex-based rules.
  */
-exports.createSingleRuleFromArray = createSingleRuleFromArray;
 const createRulesFromArrays = function (rules, flags = "i") {
   return rules.map(rule => createSingleRuleFromArray(rule, flags));
 };
-exports.createRulesFromArrays = createRulesFromArrays;
-var _default = exports.default = createRulesFromArrays;
+export { createSingleRuleFromArray, createRulesFromArrays };
+export default createRulesFromArrays;
 //# sourceMappingURL=createRulesFromArrays.js.map

package/build/languageProcessing/helpers/morphology/createRulesFromArrays.js.map

@@ -1 +1 @@
-{"version":3,"file":"createRulesFromArrays.js","names":["createSingleRuleFromArray","rule","flags","length","reg","RegExp","repl","repl1","repl2","exports","createRulesFromArrays","rules","map","_default","default"],"sources":["../../../../src/languageProcessing/helpers/morphology/createRulesFromArrays.js"],"sourcesContent":["/**\n * Creates an object with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rule        A pair or triplet of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string}  [flags=i]   The regex flags to use.\n *\n * @returns {{ reg: RegExp, repl: string }|{ reg: RegExp, repl1: string, repl2: string }|null} Object to be used in the regex-based rules.\n */\nconst createSingleRuleFromArray = function( rule, flags = \"i\" ) {\n\tif ( rule.length === 2 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl: rule[ 1 ],\n\t\t};\n\t}\n\tif ( rule.length === 3 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl1: rule[ 1 ],\n\t\t\trepl2: rule[ 2 ],\n\t\t};\n\t}\n\treturn null;\n};\n\n/**\n * Creates an array of objects with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rules       An array with pairs or triplets of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string} [flags=i]    The regex flags to use.\n *\n * @returns {Array} Array of objects to be used in the regex-based rules.\n */\nconst createRulesFromArrays = function( rules, flags = \"i\" ) {\n\treturn rules.map( rule => createSingleRuleFromArray( rule, flags ) );\n};\n\nexport {\n\tcreateSingleRuleFromArray,\n\tcreateRulesFromArrays,\n};\n\nexport default createRulesFromArrays;\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,yBAAyB,GAAG,SAAAA,CAAUC,IAAI,EAAEC,KAAK,GAAG,GAAG,EAAG;EAC/D,IAAKD,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCI,IAAI,EAAEL,IAAI,CAAE,CAAC;IACd,CAAC;EACF;EACA,IAAKA,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCK,KAAK,EAAEN,IAAI,CAAE,CAAC,CAAE;MAChBO,KAAK,EAAEP,IAAI,CAAE,CAAC;IACf,CAAC;EACF;EACA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AARAQ,OAAA,CAAAT,yBAAA,GAAAA,yBAAA;AASA,MAAMU,qBAAqB,GAAG,SAAAA,CAAUC,KAAK,EAAET,KAAK,GAAG,GAAG,EAAG;EAC5D,OAAOS,KAAK,CAACC,GAAG,CAAEX,IAAI,IAAID,yBAAyB,CAAEC,IAAI,EAAEC,KAAM,CAAE,CAAC;AACrE,CAAC;AAACO,OAAA,CAAAC,qBAAA,GAAAA,qBAAA;AAAA,IAAAG,QAAA,GAAAJ,OAAA,CAAAK,OAAA,GAOaJ,qBAAqB","ignoreList":[]}
+{"version":3,"file":"createRulesFromArrays.js","names":["createSingleRuleFromArray","rule","flags","length","reg","RegExp","repl","repl1","repl2","createRulesFromArrays","rules","map"],"sources":["../../../../src/languageProcessing/helpers/morphology/createRulesFromArrays.js"],"sourcesContent":["/**\n * Creates an object with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rule        A pair or triplet of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string}  [flags=i]   The regex flags to use.\n *\n * @returns {{ reg: RegExp, repl: string }|{ reg: RegExp, repl1: string, repl2: string }|null} Object to be used in the regex-based rules.\n */\nconst createSingleRuleFromArray = function( rule, flags = \"i\" ) {\n\tif ( rule.length === 2 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl: rule[ 1 ],\n\t\t};\n\t}\n\tif ( rule.length === 3 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl1: rule[ 1 ],\n\t\t\trepl2: rule[ 2 ],\n\t\t};\n\t}\n\treturn null;\n};\n\n/**\n * Creates an array of objects with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rules       An array with pairs or triplets of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string} [flags=i]    The regex flags to use.\n *\n * @returns {Array} Array of objects to be used in the regex-based rules.\n */\nconst createRulesFromArrays = function( rules, flags = \"i\" ) {\n\treturn rules.map( rule => createSingleRuleFromArray( rule, flags ) );\n};\n\nexport {\n\tcreateSingleRuleFromArray,\n\tcreateRulesFromArrays,\n};\n\nexport default createRulesFromArrays;\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,yBAAyB,GAAG,SAAAA,CAAUC,IAAI,EAAEC,KAAK,GAAG,GAAG,EAAG;EAC/D,IAAKD,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCI,IAAI,EAAEL,IAAI,CAAE,CAAC;IACd,CAAC;EACF;EACA,IAAKA,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCK,KAAK,EAAEN,IAAI,CAAE,CAAC,CAAE;MAChBO,KAAK,EAAEP,IAAI,CAAE,CAAC;IACf,CAAC;EACF;EACA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMQ,qBAAqB,GAAG,SAAAA,CAAUC,KAAK,EAAER,KAAK,GAAG,GAAG,EAAG;EAC5D,OAAOQ,KAAK,CAACC,GAAG,CAAEV,IAAI,IAAID,yBAAyB,CAAEC,IAAI,EAAEC,KAAM,CAAE,CAAC;AACrE,CAAC;AAED,SACCF,yBAAyB,EACzBS,qBAAqB;AAGtB,eAAeA,qBAAqB","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/exceptionListHelpers.js

@@ -1,13 +1,5 @@
-"use strict";
+import flattenSortLength from "./flattenSortLength";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkExceptionListWithTwoStems = checkExceptionListWithTwoStems;
-exports.checkIfWordEndingIsOnExceptionList = checkIfWordEndingIsOnExceptionList;
-exports.checkIfWordIsOnListThatCanHavePrefix = checkIfWordIsOnListThatCanHavePrefix;
-var _flattenSortLength = _interopRequireDefault(require("./flattenSortLength"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Checks whether the word ends in one of the words in an exception list that is a simple array.
  *
@@ -16,7 +8,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  *
  * @returns {boolean}	Whether the checked word ends in one of the words in the exception list.
  */
-function checkIfWordEndingIsOnExceptionList(word, exceptionList) {
+export function checkIfWordEndingIsOnExceptionList(word, exceptionList) {
   for (let i = 0; i < exceptionList.length; i++) {
     if (word.endsWith(exceptionList[i])) {
       return true;
@@ -35,8 +27,8 @@ function checkIfWordEndingIsOnExceptionList(word, exceptionList) {
  *
  * @returns {boolean}	Whether the word was found on the exception list or not.
  */
-function checkIfWordIsOnListThatCanHavePrefix(word, exceptionList, prefixesObject) {
-  const prefixes = (0, _flattenSortLength.default)(prefixesObject);
+export function checkIfWordIsOnListThatCanHavePrefix(word, exceptionList, prefixesObject) {
+  const prefixes = flattenSortLength(prefixesObject);
 
   // Check whether the inputted word starts with one of the prefixes
   const foundPrefix = prefixes.find(prefix => word.startsWith(prefix));
@@ -59,7 +51,7 @@ function checkIfWordIsOnListThatCanHavePrefix(word, exceptionList, prefixesObjec
  *
  * @returns {string} The stem.
  */
-function checkExceptionListWithTwoStems(exceptionListWithTwoStems, word) {
+export function checkExceptionListWithTwoStems(exceptionListWithTwoStems, word) {
   for (const stemSet of exceptionListWithTwoStems) {
     const foundStem = stemSet.find(stemWord => word.endsWith(stemWord));
     if (foundStem) {

package/build/languageProcessing/helpers/morphology/exceptionListHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"exceptionListHelpers.js","names":["_flattenSortLength","_interopRequireDefault","require","e","__esModule","default","checkIfWordEndingIsOnExceptionList","word","exceptionList","i","length","endsWith","checkIfWordIsOnListThatCanHavePrefix","prefixesObject","prefixes","flattenSortLength","foundPrefix","find","prefix","startsWith","stemmedWordWithoutPrefix","slice","includes","checkExceptionListWithTwoStems","exceptionListWithTwoStems","stemSet","foundStem","stemWord","precedingLexicalMaterial"],"sources":["../../../../src/languageProcessing/helpers/morphology/exceptionListHelpers.js"],"sourcesContent":["import flattenSortLength from \"./flattenSortLength\";\n\n/**\n * Checks whether the word ends in one of the words in an exception list that is a simple array.\n *\n * @param {string}\t    word            The word to check.\n * @param {string[]}\texceptionList\tThe list of exceptions.\n *\n * @returns {boolean}\tWhether the checked word ends in one of the words in the exception list.\n */\nexport function checkIfWordEndingIsOnExceptionList( word, exceptionList ) {\n\tfor ( let i = 0; i < exceptionList.length; i++ ) {\n\t\tif ( word.endsWith( exceptionList[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/**\n * Checks whether a word is on the list of words that can have a prefix or not. Before checking the list, checks whether the word has a prefix\n * and if it does, removes it.\n *\n * @param {string}\t \tword\t\t\t\t\tThe word to check.\n * @param {string[]}\texceptionList\t\t\tThe list of exceptions.\n * @param {Object}\t\tprefixesObject\t        An Object that contains the arrays of prefixes.\n *\n * @returns {boolean}\tWhether the word was found on the exception list or not.\n */\nexport function checkIfWordIsOnListThatCanHavePrefix( word, exceptionList, prefixesObject ) {\n\tconst prefixes = flattenSortLength( prefixesObject );\n\n\t// Check whether the inputted word starts with one of the prefixes\n\tconst foundPrefix = prefixes.find( prefix => word.startsWith( prefix ) );\n\tlet stemmedWordWithoutPrefix = \"\";\n\n\tif ( typeof( foundPrefix ) === \"string\" ) {\n\t\tstemmedWordWithoutPrefix = word.slice( foundPrefix.length );\n\t\t// At least 3 characters left after prefix deletion so that e.g. \"be\" is not treated as a prefix if found in the word \"berg\".\n\t\tif ( stemmedWordWithoutPrefix.length > 2 ) {\n\t\t\tword = stemmedWordWithoutPrefix;\n\t\t}\n\t}\n\n\treturn exceptionList.includes( word );\n}\n\n/**\n * Checks whether the word ends in one of the words in an exception list with two stems.\n *\n * @param {Array} exceptionListWithTwoStems The exception list with two stems.\n * @param {string} word\tThe word to check.\n *\n * @returns {string} The stem.\n */\nexport function checkExceptionListWithTwoStems( exceptionListWithTwoStems, word ) {\n\tfor ( const stemSet of exceptionListWithTwoStems ) {\n\t\tconst foundStem =  stemSet.find( stemWord => word.endsWith( stemWord ) );\n\t\tif ( foundStem ) {\n\t\t\tconst precedingLexicalMaterial = word.slice( 0, word.length - foundStem.length );\n\n\t\t\treturn precedingLexicalMaterial + stemSet[ 0 ];\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,kBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAoD,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,kCAAkCA,CAAEC,IAAI,EAAEC,aAAa,EAAG;EACzE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IAChD,IAAKF,IAAI,CAACI,QAAQ,CAAEH,aAAa,CAAEC,CAAC,CAAG,CAAC,EAAG;MAC1C,OAAO,IAAI;IACZ;EACD;EACA,OAAO,KAAK;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,oCAAoCA,CAAEL,IAAI,EAAEC,aAAa,EAAEK,cAAc,EAAG;EAC3F,MAAMC,QAAQ,GAAG,IAAAC,0BAAiB,EAAEF,cAAe,CAAC;;EAEpD;EACA,MAAMG,WAAW,GAAGF,QAAQ,CAACG,IAAI,CAAEC,MAAM,IAAIX,IAAI,CAACY,UAAU,CAAED,MAAO,CAAE,CAAC;EACxE,IAAIE,wBAAwB,GAAG,EAAE;EAEjC,IAAK,OAAQJ,WAAa,KAAK,QAAQ,EAAG;IACzCI,wBAAwB,GAAGb,IAAI,CAACc,KAAK,CAAEL,WAAW,CAACN,MAAO,CAAC;IAC3D;IACA,IAAKU,wBAAwB,CAACV,MAAM,GAAG,CAAC,EAAG;MAC1CH,IAAI,GAAGa,wBAAwB;IAChC;EACD;EAEA,OAAOZ,aAAa,CAACc,QAAQ,CAAEf,IAAK,CAAC;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASgB,8BAA8BA,CAAEC,yBAAyB,EAAEjB,IAAI,EAAG;EACjF,KAAM,MAAMkB,OAAO,IAAID,yBAAyB,EAAG;IAClD,MAAME,SAAS,GAAID,OAAO,CAACR,IAAI,CAAEU,QAAQ,IAAIpB,IAAI,CAACI,QAAQ,CAAEgB,QAAS,CAAE,CAAC;IACxE,IAAKD,SAAS,EAAG;MAChB,MAAME,wBAAwB,GAAGrB,IAAI,CAACc,KAAK,CAAE,CAAC,EAAEd,IAAI,CAACG,MAAM,GAAGgB,SAAS,CAAChB,MAAO,CAAC;MAEhF,OAAOkB,wBAAwB,GAAGH,OAAO,CAAE,CAAC,CAAE;IAC/C;EACD;AACD","ignoreList":[]}
+{"version":3,"file":"exceptionListHelpers.js","names":["flattenSortLength","checkIfWordEndingIsOnExceptionList","word","exceptionList","i","length","endsWith","checkIfWordIsOnListThatCanHavePrefix","prefixesObject","prefixes","foundPrefix","find","prefix","startsWith","stemmedWordWithoutPrefix","slice","includes","checkExceptionListWithTwoStems","exceptionListWithTwoStems","stemSet","foundStem","stemWord","precedingLexicalMaterial"],"sources":["../../../../src/languageProcessing/helpers/morphology/exceptionListHelpers.js"],"sourcesContent":["import flattenSortLength from \"./flattenSortLength\";\n\n/**\n * Checks whether the word ends in one of the words in an exception list that is a simple array.\n *\n * @param {string}\t    word            The word to check.\n * @param {string[]}\texceptionList\tThe list of exceptions.\n *\n * @returns {boolean}\tWhether the checked word ends in one of the words in the exception list.\n */\nexport function checkIfWordEndingIsOnExceptionList( word, exceptionList ) {\n\tfor ( let i = 0; i < exceptionList.length; i++ ) {\n\t\tif ( word.endsWith( exceptionList[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/**\n * Checks whether a word is on the list of words that can have a prefix or not. Before checking the list, checks whether the word has a prefix\n * and if it does, removes it.\n *\n * @param {string}\t \tword\t\t\t\t\tThe word to check.\n * @param {string[]}\texceptionList\t\t\tThe list of exceptions.\n * @param {Object}\t\tprefixesObject\t        An Object that contains the arrays of prefixes.\n *\n * @returns {boolean}\tWhether the word was found on the exception list or not.\n */\nexport function checkIfWordIsOnListThatCanHavePrefix( word, exceptionList, prefixesObject ) {\n\tconst prefixes = flattenSortLength( prefixesObject );\n\n\t// Check whether the inputted word starts with one of the prefixes\n\tconst foundPrefix = prefixes.find( prefix => word.startsWith( prefix ) );\n\tlet stemmedWordWithoutPrefix = \"\";\n\n\tif ( typeof( foundPrefix ) === \"string\" ) {\n\t\tstemmedWordWithoutPrefix = word.slice( foundPrefix.length );\n\t\t// At least 3 characters left after prefix deletion so that e.g. \"be\" is not treated as a prefix if found in the word \"berg\".\n\t\tif ( stemmedWordWithoutPrefix.length > 2 ) {\n\t\t\tword = stemmedWordWithoutPrefix;\n\t\t}\n\t}\n\n\treturn exceptionList.includes( word );\n}\n\n/**\n * Checks whether the word ends in one of the words in an exception list with two stems.\n *\n * @param {Array} exceptionListWithTwoStems The exception list with two stems.\n * @param {string} word\tThe word to check.\n *\n * @returns {string} The stem.\n */\nexport function checkExceptionListWithTwoStems( exceptionListWithTwoStems, word ) {\n\tfor ( const stemSet of exceptionListWithTwoStems ) {\n\t\tconst foundStem =  stemSet.find( stemWord => word.endsWith( stemWord ) );\n\t\tif ( foundStem ) {\n\t\t\tconst precedingLexicalMaterial = word.slice( 0, word.length - foundStem.length );\n\n\t\t\treturn precedingLexicalMaterial + stemSet[ 0 ];\n\t\t}\n\t}\n}\n"],"mappings":"AAAA,OAAOA,iBAAiB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kCAAkCA,CAAEC,IAAI,EAAEC,aAAa,EAAG;EACzE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IAChD,IAAKF,IAAI,CAACI,QAAQ,CAAEH,aAAa,CAAEC,CAAC,CAAG,CAAC,EAAG;MAC1C,OAAO,IAAI;IACZ;EACD;EACA,OAAO,KAAK;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,oCAAoCA,CAAEL,IAAI,EAAEC,aAAa,EAAEK,cAAc,EAAG;EAC3F,MAAMC,QAAQ,GAAGT,iBAAiB,CAAEQ,cAAe,CAAC;;EAEpD;EACA,MAAME,WAAW,GAAGD,QAAQ,CAACE,IAAI,CAAEC,MAAM,IAAIV,IAAI,CAACW,UAAU,CAAED,MAAO,CAAE,CAAC;EACxE,IAAIE,wBAAwB,GAAG,EAAE;EAEjC,IAAK,OAAQJ,WAAa,KAAK,QAAQ,EAAG;IACzCI,wBAAwB,GAAGZ,IAAI,CAACa,KAAK,CAAEL,WAAW,CAACL,MAAO,CAAC;IAC3D;IACA,IAAKS,wBAAwB,CAACT,MAAM,GAAG,CAAC,EAAG;MAC1CH,IAAI,GAAGY,wBAAwB;IAChC;EACD;EAEA,OAAOX,aAAa,CAACa,QAAQ,CAAEd,IAAK,CAAC;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASe,8BAA8BA,CAAEC,yBAAyB,EAAEhB,IAAI,EAAG;EACjF,KAAM,MAAMiB,OAAO,IAAID,yBAAyB,EAAG;IAClD,MAAME,SAAS,GAAID,OAAO,CAACR,IAAI,CAAEU,QAAQ,IAAInB,IAAI,CAACI,QAAQ,CAAEe,QAAS,CAAE,CAAC;IACxE,IAAKD,SAAS,EAAG;MAChB,MAAME,wBAAwB,GAAGpB,IAAI,CAACa,KAAK,CAAE,CAAC,EAAEb,IAAI,CAACG,MAAM,GAAGe,SAAS,CAACf,MAAO,CAAC;MAEhF,OAAOiB,wBAAwB,GAAGH,OAAO,CAAE,CAAC,CAAE;IAC/C;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/findMatchingEndingInArray.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = findMatchingEndingInArray;
 /**
  * Loops through an array of word endings and returns the longest ending that was matched at the end of the string.
  *
@@ -11,7 +5,7 @@ exports.default = findMatchingEndingInArray;
  * @param {string[]}    endings    The word endings to check.
  * @returns {string}    The longest matched ending.
  */
-function findMatchingEndingInArray(string, endings) {
+export default function findMatchingEndingInArray(string, endings) {
   const matches = [];
   for (const i in endings) {
     if (string.endsWith(endings[i])) {

package/build/languageProcessing/helpers/morphology/findMatchingEndingInArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"findMatchingEndingInArray.js","names":["findMatchingEndingInArray","string","endings","matches","i","endsWith","push","longest","sort","a","b","length"],"sources":["../../../../src/languageProcessing/helpers/morphology/findMatchingEndingInArray.js"],"sourcesContent":["/**\n * Loops through an array of word endings and returns the longest ending that was matched at the end of the string.\n *\n * @param {string}      string       The string to check.\n * @param {string[]}    endings    The word endings to check.\n * @returns {string}    The longest matched ending.\n */\nexport default function findMatchingEndingInArray( string, endings ) {\n\tconst matches = [];\n\tfor ( const i in endings ) {\n\t\tif ( string.endsWith( endings[ i ] ) ) {\n\t\t\tmatches.push( endings[ i ] );\n\t\t}\n\t}\n\n\tconst longest = matches.sort( function( a, b ) {\n\t\treturn b.length - a.length;\n\t} )[ 0 ];\n\n\tif ( longest ) {\n\t\treturn longest;\n\t}\n\treturn \"\";\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,yBAAyBA,CAAEC,MAAM,EAAEC,OAAO,EAAG;EACpE,MAAMC,OAAO,GAAG,EAAE;EAClB,KAAM,MAAMC,CAAC,IAAIF,OAAO,EAAG;IAC1B,IAAKD,MAAM,CAACI,QAAQ,CAAEH,OAAO,CAAEE,CAAC,CAAG,CAAC,EAAG;MACtCD,OAAO,CAACG,IAAI,CAAEJ,OAAO,CAAEE,CAAC,CAAG,CAAC;IAC7B;EACD;EAEA,MAAMG,OAAO,GAAGJ,OAAO,CAACK,IAAI,CAAE,UAAUC,CAAC,EAAEC,CAAC,EAAG;IAC9C,OAAOA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM;EAC3B,CAAE,CAAC,CAAE,CAAC,CAAE;EAER,IAAKJ,OAAO,EAAG;IACd,OAAOA,OAAO;EACf;EACA,OAAO,EAAE;AACV","ignoreList":[]}
+{"version":3,"file":"findMatchingEndingInArray.js","names":["findMatchingEndingInArray","string","endings","matches","i","endsWith","push","longest","sort","a","b","length"],"sources":["../../../../src/languageProcessing/helpers/morphology/findMatchingEndingInArray.js"],"sourcesContent":["/**\n * Loops through an array of word endings and returns the longest ending that was matched at the end of the string.\n *\n * @param {string}      string       The string to check.\n * @param {string[]}    endings    The word endings to check.\n * @returns {string}    The longest matched ending.\n */\nexport default function findMatchingEndingInArray( string, endings ) {\n\tconst matches = [];\n\tfor ( const i in endings ) {\n\t\tif ( string.endsWith( endings[ i ] ) ) {\n\t\t\tmatches.push( endings[ i ] );\n\t\t}\n\t}\n\n\tconst longest = matches.sort( function( a, b ) {\n\t\treturn b.length - a.length;\n\t} )[ 0 ];\n\n\tif ( longest ) {\n\t\treturn longest;\n\t}\n\treturn \"\";\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,yBAAyBA,CAAEC,MAAM,EAAEC,OAAO,EAAG;EACpE,MAAMC,OAAO,GAAG,EAAE;EAClB,KAAM,MAAMC,CAAC,IAAIF,OAAO,EAAG;IAC1B,IAAKD,MAAM,CAACI,QAAQ,CAAEH,OAAO,CAAEE,CAAC,CAAG,CAAC,EAAG;MACtCD,OAAO,CAACG,IAAI,CAAEJ,OAAO,CAAEE,CAAC,CAAG,CAAC;IAC7B;EACD;EAEA,MAAMG,OAAO,GAAGJ,OAAO,CAACK,IAAI,CAAE,UAAUC,CAAC,EAAEC,CAAC,EAAG;IAC9C,OAAOA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM;EAC3B,CAAE,CAAC,CAAE,CAAC,CAAE;EAER,IAAKJ,OAAO,EAAG;IACd,OAAOA,OAAO;EACf;EACA,OAAO,EAAE;AACV","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/flattenSortLength.js

@@ -1,10 +1,5 @@
-"use strict";
+import { flatten } from "lodash";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = flattenSortLength;
-var _lodash = require("lodash");
 /**
  * Returns combined list of strings/words, sorted by length (descending).
  *
@@ -12,8 +7,8 @@ var _lodash = require("lodash");
  *
  * @returns {Array<string>} All words, sorted by length (descending).
  */
-function flattenSortLength(dataWords) {
-  const allWords = (0, _lodash.flatten)(Object.values(dataWords));
+export default function flattenSortLength(dataWords) {
+  const allWords = flatten(Object.values(dataWords));
   return allWords.sort((a, b) => b.length - a.length || a.localeCompare(b));
 }
 //# sourceMappingURL=flattenSortLength.js.map

package/build/languageProcessing/helpers/morphology/flattenSortLength.js.map

@@ -1 +1 @@
-{"version":3,"file":"flattenSortLength.js","names":["_lodash","require","flattenSortLength","dataWords","allWords","flatten","Object","values","sort","a","b","length","localeCompare"],"sources":["../../../../src/languageProcessing/helpers/morphology/flattenSortLength.js"],"sourcesContent":["import { flatten } from \"lodash\";\n\n/**\n * Returns combined list of strings/words, sorted by length (descending).\n *\n * @param {Object} dataWords The words data that is going to be sorted.\n *\n * @returns {Array<string>} All words, sorted by length (descending).\n */\nexport default function flattenSortLength( dataWords ) {\n\tconst allWords = flatten( Object.values( dataWords ) );\n\n\treturn allWords.sort( ( a, b ) => b.length - a.length || a.localeCompare( b ) );\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,iBAAiBA,CAAEC,SAAS,EAAG;EACtD,MAAMC,QAAQ,GAAG,IAAAC,eAAO,EAAEC,MAAM,CAACC,MAAM,CAAEJ,SAAU,CAAE,CAAC;EAEtD,OAAOC,QAAQ,CAACI,IAAI,CAAE,CAAEC,CAAC,EAAEC,CAAC,KAAMA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM,IAAIF,CAAC,CAACG,aAAa,CAAEF,CAAE,CAAE,CAAC;AAChF","ignoreList":[]}
+{"version":3,"file":"flattenSortLength.js","names":["flatten","flattenSortLength","dataWords","allWords","Object","values","sort","a","b","length","localeCompare"],"sources":["../../../../src/languageProcessing/helpers/morphology/flattenSortLength.js"],"sourcesContent":["import { flatten } from \"lodash\";\n\n/**\n * Returns combined list of strings/words, sorted by length (descending).\n *\n * @param {Object} dataWords The words data that is going to be sorted.\n *\n * @returns {Array<string>} All words, sorted by length (descending).\n */\nexport default function flattenSortLength( dataWords ) {\n\tconst allWords = flatten( Object.values( dataWords ) );\n\n\treturn allWords.sort( ( a, b ) => b.length - a.length || a.localeCompare( b ) );\n}\n"],"mappings":"AAAA,SAASA,OAAO,QAAQ,QAAQ;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,iBAAiBA,CAAEC,SAAS,EAAG;EACtD,MAAMC,QAAQ,GAAGH,OAAO,CAAEI,MAAM,CAACC,MAAM,CAAEH,SAAU,CAAE,CAAC;EAEtD,OAAOC,QAAQ,CAACG,IAAI,CAAE,CAAEC,CAAC,EAAEC,CAAC,KAAMA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM,IAAIF,CAAC,CAACG,aAAa,CAAEF,CAAE,CAAE,CAAC;AAChF","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/getAllWordsFromPaper.js

@@ -1,17 +1,11 @@
-"use strict";
+import { escapeRegExp } from "lodash";
+import getAltAttribute from "../image/getAltAttribute";
+import { normalizeSingle } from "../sanitize/quotes";
+import parseSlug from "../url/parseSlug";
+import getWords from "../word/getWords";
+import getImagesInTree from "../image/getImagesInTree";
+import { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from "../../../config/wordBoundariesWithoutPunctuation";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-var _lodash = require("lodash");
-var _getAltAttribute = _interopRequireDefault(require("../image/getAltAttribute"));
-var _quotes = require("../sanitize/quotes");
-var _parseSlug = _interopRequireDefault(require("../url/parseSlug"));
-var _getWords = _interopRequireDefault(require("../word/getWords"));
-var _getImagesInTree = _interopRequireDefault(require("../image/getImagesInTree"));
-var _wordBoundariesWithoutPunctuation = require("../../../config/wordBoundariesWithoutPunctuation");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Gets all words found in the text, title, slug and meta description of a given paper.
  *
@@ -20,16 +14,16 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  *
  * @returns {string[]} All words found.
  */
-function _default(paper, areHyphensWordBoundaries) {
+export default function (paper, areHyphensWordBoundaries) {
   const paperText = paper.getText();
-  const altTagsInText = (0, _getImagesInTree.default)(paper).map(image => (0, _getAltAttribute.default)(image));
-  const paperContent = [paperText, paper.getTitle(), paper.getSlug(), (0, _parseSlug.default)(paper.getSlug()), paper.getDescription(), altTagsInText.join(" ")].join(" ");
+  const altTagsInText = getImagesInTree(paper).map(image => getAltAttribute(image));
+  const paperContent = [paperText, paper.getTitle(), paper.getSlug(), parseSlug(paper.getSlug()), paper.getDescription(), altTagsInText.join(" ")].join(" ");
 
   /*
       * If hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,
       * hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.
   	 */
-  const words = areHyphensWordBoundaries ? (0, _getWords.default)(paperContent, _wordBoundariesWithoutPunctuation.WORD_BOUNDARY_WITH_HYPHEN) : (0, _getWords.default)(paperContent, _wordBoundariesWithoutPunctuation.WORD_BOUNDARY_WITHOUT_HYPHEN);
-  return words.map(word => (0, _quotes.normalizeSingle)((0, _lodash.escapeRegExp)(word)));
+  const words = areHyphensWordBoundaries ? getWords(paperContent, WORD_BOUNDARY_WITH_HYPHEN) : getWords(paperContent, WORD_BOUNDARY_WITHOUT_HYPHEN);
+  return words.map(word => normalizeSingle(escapeRegExp(word)));
 }
 //# sourceMappingURL=getAllWordsFromPaper.js.map

package/build/languageProcessing/helpers/morphology/getAllWordsFromPaper.js.map

@@ -1 +1 @@
-{"version":3,"file":"getAllWordsFromPaper.js","names":["_lodash","require","_getAltAttribute","_interopRequireDefault","_quotes","_parseSlug","_getWords","_getImagesInTree","_wordBoundariesWithoutPunctuation","e","__esModule","default","_default","paper","areHyphensWordBoundaries","paperText","getText","altTagsInText","getImagesInTree","map","image","getAltAttribute","paperContent","getTitle","getSlug","parseSlug","getDescription","join","words","getWords","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","word","normalizeSingle","escapeRegExp"],"sources":["../../../../src/languageProcessing/helpers/morphology/getAllWordsFromPaper.js"],"sourcesContent":["import { escapeRegExp } from \"lodash\";\nimport getAltAttribute from \"../image/getAltAttribute\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport parseSlug from \"../url/parseSlug\";\nimport getWords from \"../word/getWords\";\nimport getImagesInTree from \"../image/getImagesInTree\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"../../../config/wordBoundariesWithoutPunctuation\";\n\n/**\n * Gets all words found in the text, title, slug and meta description of a given paper.\n *\n * @param {Paper} \tpaper     \t\t\t\t\tThe paper for which to get the words.\n * @param {boolean}\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {string[]} All words found.\n */\nexport default function( paper, areHyphensWordBoundaries ) {\n\tconst paperText = paper.getText();\n\tconst altTagsInText = getImagesInTree( paper ).map( image => getAltAttribute( image ) );\n\n\tconst paperContent = [\n\t\tpaperText,\n\t\tpaper.getTitle(),\n\t\tpaper.getSlug(),\n\t\tparseSlug( paper.getSlug() ),\n\t\tpaper.getDescription(),\n\t\taltTagsInText.join( \" \" ),\n\t].join( \" \" );\n\n\t/*\n     * If hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n     * hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n \t */\n\tconst words = areHyphensWordBoundaries ? getWords( paperContent, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( paperContent, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\treturn words.map(\n\t\tword => normalizeSingle( escapeRegExp( word ) ) );\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,SAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,gBAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,iCAAA,GAAAP,OAAA;AAA2H,SAAAE,uBAAAM,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAG,SAAUC,KAAK,EAAEC,wBAAwB,EAAG;EAC1D,MAAMC,SAAS,GAAGF,KAAK,CAACG,OAAO,CAAC,CAAC;EACjC,MAAMC,aAAa,GAAG,IAAAC,wBAAe,EAAEL,KAAM,CAAC,CAACM,GAAG,CAAEC,KAAK,IAAI,IAAAC,wBAAe,EAAED,KAAM,CAAE,CAAC;EAEvF,MAAME,YAAY,GAAG,CACpBP,SAAS,EACTF,KAAK,CAACU,QAAQ,CAAC,CAAC,EAChBV,KAAK,CAACW,OAAO,CAAC,CAAC,EACf,IAAAC,kBAAS,EAAEZ,KAAK,CAACW,OAAO,CAAC,CAAE,CAAC,EAC5BX,KAAK,CAACa,cAAc,CAAC,CAAC,EACtBT,aAAa,CAACU,IAAI,CAAE,GAAI,CAAC,CACzB,CAACA,IAAI,CAAE,GAAI,CAAC;;EAEb;AACD;AACA;AACA;EACC,MAAMC,KAAK,GAAGd,wBAAwB,GAAG,IAAAe,iBAAQ,EAAEP,YAAY,EAAEQ,2DAA0B,CAAC,GACzF,IAAAD,iBAAQ,EAAEP,YAAY,EAAES,8DAA6B,CAAC;EAEzD,OAAOH,KAAK,CAACT,GAAG,CACfa,IAAI,IAAI,IAAAC,uBAAe,EAAE,IAAAC,oBAAY,EAAEF,IAAK,CAAE,CAAE,CAAC;AACnD","ignoreList":[]}
+{"version":3,"file":"getAllWordsFromPaper.js","names":["escapeRegExp","getAltAttribute","normalizeSingle","parseSlug","getWords","getImagesInTree","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","paper","areHyphensWordBoundaries","paperText","getText","altTagsInText","map","image","paperContent","getTitle","getSlug","getDescription","join","words","word"],"sources":["../../../../src/languageProcessing/helpers/morphology/getAllWordsFromPaper.js"],"sourcesContent":["import { escapeRegExp } from \"lodash\";\nimport getAltAttribute from \"../image/getAltAttribute\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport parseSlug from \"../url/parseSlug\";\nimport getWords from \"../word/getWords\";\nimport getImagesInTree from \"../image/getImagesInTree\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"@axyseo/config/wordBoundariesWithoutPunctuation\";\n\n/**\n * Gets all words found in the text, title, slug and meta description of a given paper.\n *\n * @param {Paper} \tpaper     \t\t\t\t\tThe paper for which to get the words.\n * @param {boolean}\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {string[]} All words found.\n */\nexport default function( paper, areHyphensWordBoundaries ) {\n\tconst paperText = paper.getText();\n\tconst altTagsInText = getImagesInTree( paper ).map( image => getAltAttribute( image ) );\n\n\tconst paperContent = [\n\t\tpaperText,\n\t\tpaper.getTitle(),\n\t\tpaper.getSlug(),\n\t\tparseSlug( paper.getSlug() ),\n\t\tpaper.getDescription(),\n\t\taltTagsInText.join( \" \" ),\n\t].join( \" \" );\n\n\t/*\n     * If hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n     * hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n \t */\n\tconst words = areHyphensWordBoundaries ? getWords( paperContent, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( paperContent, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\treturn words.map(\n\t\tword => normalizeSingle( escapeRegExp( word ) ) );\n}\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,QAAQ;AACrC,OAAOC,eAAe;AACtB,SAASC,eAAe;AACxB,OAAOC,SAAS;AAChB,OAAOC,QAAQ;AACf,OAAOC,eAAe;AACtB,SAASC,yBAAyB,EAAEC,4BAA4B;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,KAAK,EAAEC,wBAAwB,EAAG;EAC1D,MAAMC,SAAS,GAAGF,KAAK,CAACG,OAAO,CAAC,CAAC;EACjC,MAAMC,aAAa,GAAGP,eAAe,CAAEG,KAAM,CAAC,CAACK,GAAG,CAAEC,KAAK,IAAIb,eAAe,CAAEa,KAAM,CAAE,CAAC;EAEvF,MAAMC,YAAY,GAAG,CACpBL,SAAS,EACTF,KAAK,CAACQ,QAAQ,CAAC,CAAC,EAChBR,KAAK,CAACS,OAAO,CAAC,CAAC,EACfd,SAAS,CAAEK,KAAK,CAACS,OAAO,CAAC,CAAE,CAAC,EAC5BT,KAAK,CAACU,cAAc,CAAC,CAAC,EACtBN,aAAa,CAACO,IAAI,CAAE,GAAI,CAAC,CACzB,CAACA,IAAI,CAAE,GAAI,CAAC;;EAEb;AACD;AACA;AACA;EACC,MAAMC,KAAK,GAAGX,wBAAwB,GAAGL,QAAQ,CAAEW,YAAY,EAAET,yBAA0B,CAAC,GACzFF,QAAQ,CAAEW,YAAY,EAAER,4BAA6B,CAAC;EAEzD,OAAOa,KAAK,CAACP,GAAG,CACfQ,IAAI,IAAInB,eAAe,CAAEF,YAAY,CAAEqB,IAAK,CAAE,CAAE,CAAC;AACnD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/regexHelpers.js

@@ -1,11 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.applyAllReplacements = applyAllReplacements;
-exports.doesWordMatchRegex = doesWordMatchRegex;
-exports.searchAndReplaceWithRegex = searchAndReplaceWithRegex;
 /**
  * Checks whether a word is matched with a regex.
  *
@@ -14,7 +6,7 @@ exports.searchAndReplaceWithRegex = searchAndReplaceWithRegex;
  *
  * @returns {boolean}		Whether or not there was a match.
  */
-function doesWordMatchRegex(word, regex) {
+export function doesWordMatchRegex(word, regex) {
   const regexObject = RegExp(regex);
   return regexObject.test(word);
 }
@@ -27,7 +19,7 @@ function doesWordMatchRegex(word, regex) {
  *
  * @returns {?string} The modified stem or null if no match was found.
  */
-function searchAndReplaceWithRegex(word, groupOfRegexAndReplacements) {
+export function searchAndReplaceWithRegex(word, groupOfRegexAndReplacements) {
   for (const regexAndReplacement of groupOfRegexAndReplacements) {
     if (word.search(new RegExp(regexAndReplacement[0])) !== -1) {
       word = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);
@@ -44,7 +36,7 @@ function searchAndReplaceWithRegex(word, groupOfRegexAndReplacements) {
  *
  * @returns {string} The modified word.
  */
-function applyAllReplacements(word, listOfRegexAndReplacement) {
+export function applyAllReplacements(word, listOfRegexAndReplacement) {
   listOfRegexAndReplacement.forEach(function (setOfRegexAndReplacement) {
     word = word.replace(new RegExp(setOfRegexAndReplacement[0]), setOfRegexAndReplacement[1]);
   });

package/build/languageProcessing/helpers/morphology/regexHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"regexHelpers.js","names":["doesWordMatchRegex","word","regex","regexObject","RegExp","test","searchAndReplaceWithRegex","groupOfRegexAndReplacements","regexAndReplacement","search","replace","applyAllReplacements","listOfRegexAndReplacement","forEach","setOfRegexAndReplacement"],"sources":["../../../../src/languageProcessing/helpers/morphology/regexHelpers.js"],"sourcesContent":["/**\n * Checks whether a word is matched with a regex.\n *\n * @param {string} word\t\tThe word to check.\n * @param {string} regex\tThe regex.\n *\n * @returns {boolean}\t\tWhether or not there was a match.\n */\nexport function doesWordMatchRegex( word, regex ) {\n\tconst regexObject = RegExp( regex );\n\treturn regexObject.test( word );\n}\n\n/**\n * Loops through a nested array with pairs of regexes and replacements, and performs the needed replacement if a match is found.\n *\n * @param {string} word \t\t\t\t\t\tThe word that may need to be modified.\n * @param {[][]} groupOfRegexAndReplacements \tThe array with the regexes and the required replacements.\n *\n * @returns {?string} The modified stem or null if no match was found.\n */\nexport function searchAndReplaceWithRegex( word, groupOfRegexAndReplacements ) {\n\tfor ( const regexAndReplacement of groupOfRegexAndReplacements ) {\n\t\tif ( word.search( new RegExp( regexAndReplacement[ 0 ] ) ) !== -1 ) {\n\t\t\tword = word.replace( new RegExp( regexAndReplacement[ 0 ] ), regexAndReplacement[ 1 ] );\n\t\t\treturn word;\n\t\t}\n\t}\n}\n\n/**\n * Loops through a nested array of regexes and replacement pairs, and applies all replacements for which a match is found.\n *\n * @param {string}  word                        The word that may need to be modified.\n * @param {[][]}    listOfRegexAndReplacement   The array with the regexes and the replacements.\n *\n * @returns {string} The modified word.\n */\nexport function applyAllReplacements( word, listOfRegexAndReplacement ) {\n\tlistOfRegexAndReplacement.forEach( function( setOfRegexAndReplacement ) {\n\t\tword = word.replace( new RegExp( setOfRegexAndReplacement[ 0 ] ), setOfRegexAndReplacement[ 1 ] );\n\t} );\n\treturn word;\n}\n"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,kBAAkBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACjD,MAAMC,WAAW,GAAGC,MAAM,CAAEF,KAAM,CAAC;EACnC,OAAOC,WAAW,CAACE,IAAI,CAAEJ,IAAK,CAAC;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASK,yBAAyBA,CAAEL,IAAI,EAAEM,2BAA2B,EAAG;EAC9E,KAAM,MAAMC,mBAAmB,IAAID,2BAA2B,EAAG;IAChE,IAAKN,IAAI,CAACQ,MAAM,CAAE,IAAIL,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAE,CAAC,KAAK,CAAC,CAAC,EAAG;MACnEP,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAC,EAAEA,mBAAmB,CAAE,CAAC,CAAG,CAAC;MACvF,OAAOP,IAAI;IACZ;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASU,oBAAoBA,CAAEV,IAAI,EAAEW,yBAAyB,EAAG;EACvEA,yBAAyB,CAACC,OAAO,CAAE,UAAUC,wBAAwB,EAAG;IACvEb,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEU,wBAAwB,CAAE,CAAC,CAAG,CAAC,EAAEA,wBAAwB,CAAE,CAAC,CAAG,CAAC;EAClG,CAAE,CAAC;EACH,OAAOb,IAAI;AACZ","ignoreList":[]}
+{"version":3,"file":"regexHelpers.js","names":["doesWordMatchRegex","word","regex","regexObject","RegExp","test","searchAndReplaceWithRegex","groupOfRegexAndReplacements","regexAndReplacement","search","replace","applyAllReplacements","listOfRegexAndReplacement","forEach","setOfRegexAndReplacement"],"sources":["../../../../src/languageProcessing/helpers/morphology/regexHelpers.js"],"sourcesContent":["/**\n * Checks whether a word is matched with a regex.\n *\n * @param {string} word\t\tThe word to check.\n * @param {string} regex\tThe regex.\n *\n * @returns {boolean}\t\tWhether or not there was a match.\n */\nexport function doesWordMatchRegex( word, regex ) {\n\tconst regexObject = RegExp( regex );\n\treturn regexObject.test( word );\n}\n\n/**\n * Loops through a nested array with pairs of regexes and replacements, and performs the needed replacement if a match is found.\n *\n * @param {string} word \t\t\t\t\t\tThe word that may need to be modified.\n * @param {[][]} groupOfRegexAndReplacements \tThe array with the regexes and the required replacements.\n *\n * @returns {?string} The modified stem or null if no match was found.\n */\nexport function searchAndReplaceWithRegex( word, groupOfRegexAndReplacements ) {\n\tfor ( const regexAndReplacement of groupOfRegexAndReplacements ) {\n\t\tif ( word.search( new RegExp( regexAndReplacement[ 0 ] ) ) !== -1 ) {\n\t\t\tword = word.replace( new RegExp( regexAndReplacement[ 0 ] ), regexAndReplacement[ 1 ] );\n\t\t\treturn word;\n\t\t}\n\t}\n}\n\n/**\n * Loops through a nested array of regexes and replacement pairs, and applies all replacements for which a match is found.\n *\n * @param {string}  word                        The word that may need to be modified.\n * @param {[][]}    listOfRegexAndReplacement   The array with the regexes and the replacements.\n *\n * @returns {string} The modified word.\n */\nexport function applyAllReplacements( word, listOfRegexAndReplacement ) {\n\tlistOfRegexAndReplacement.forEach( function( setOfRegexAndReplacement ) {\n\t\tword = word.replace( new RegExp( setOfRegexAndReplacement[ 0 ] ), setOfRegexAndReplacement[ 1 ] );\n\t} );\n\treturn word;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,kBAAkBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACjD,MAAMC,WAAW,GAAGC,MAAM,CAAEF,KAAM,CAAC;EACnC,OAAOC,WAAW,CAACE,IAAI,CAAEJ,IAAK,CAAC;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASK,yBAAyBA,CAAEL,IAAI,EAAEM,2BAA2B,EAAG;EAC9E,KAAM,MAAMC,mBAAmB,IAAID,2BAA2B,EAAG;IAChE,IAAKN,IAAI,CAACQ,MAAM,CAAE,IAAIL,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAE,CAAC,KAAK,CAAC,CAAC,EAAG;MACnEP,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAC,EAAEA,mBAAmB,CAAE,CAAC,CAAG,CAAC;MACvF,OAAOP,IAAI;IACZ;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASU,oBAAoBA,CAAEV,IAAI,EAAEW,yBAAyB,EAAG;EACvEA,yBAAyB,CAACC,OAAO,CAAE,UAAUC,wBAAwB,EAAG;IACvEb,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEU,wBAAwB,CAAE,CAAC,CAAG,CAAC,EAAEA,wBAAwB,CAAE,CAAC,CAAG,CAAC;EAClG,CAAE,CAAC;EACH,OAAOb,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/stemHelpers.js

@@ -1,10 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.removeSuffixFromFullForm = removeSuffixFromFullForm;
-exports.removeSuffixesFromFullForm = removeSuffixesFromFullForm;
 /**
  * Checks whether the word starts with one of the words in a given list and ends in one of the suffixes
  * in a given suffixes list. If so, deletes the suffix.
@@ -14,7 +7,7 @@ exports.removeSuffixesFromFullForm = removeSuffixesFromFullForm;
  * @param {string}      word        The word to check.
  * @returns {string}	The stemmed word.
  */
-function removeSuffixesFromFullForm(list, suffixes, word) {
+export function removeSuffixesFromFullForm(list, suffixes, word) {
   for (let i = 0; i < list.length; i++) {
     if (word.startsWith(list[i])) {
       const suffixRetrieved = word.substring(list[i].length);
@@ -36,7 +29,7 @@ function removeSuffixesFromFullForm(list, suffixes, word) {
  *
  * @returns {string} The stemmed word.
  */
-function removeSuffixFromFullForm(exceptions, suffix, word) {
+export function removeSuffixFromFullForm(exceptions, suffix, word) {
   for (let i = 0; i < exceptions.length; i++) {
     if (word.endsWith(exceptions[i])) {
       return word.slice(0, -suffix.length);

package/build/languageProcessing/helpers/morphology/stemHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"stemHelpers.js","names":["removeSuffixesFromFullForm","list","suffixes","word","i","length","startsWith","suffixRetrieved","substring","j","slice","removeSuffixFromFullForm","exceptions","suffix","endsWith"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemHelpers.js"],"sourcesContent":["/**\n * Checks whether the word starts with one of the words in a given list and ends in one of the suffixes\n * in a given suffixes list. If so, deletes the suffix.\n *\n * @param {string[]}    list  The list of words to check against.\n * @param {string[]}    suffixes    The suffixes that needs to be deleted.\n * @param {string}      word        The word to check.\n * @returns {string}\tThe stemmed word.\n */\nexport function removeSuffixesFromFullForm( list, suffixes, word ) {\n\tfor ( let i = 0; i < list.length; i++ ) {\n\t\tif ( word.startsWith( list[ i ] ) ) {\n\t\t\tconst suffixRetrieved = word.substring( list[ i ].length );\n\t\t\tfor ( let j = 0; j < suffixes.length; j++ ) {\n\t\t\t\tif ( suffixes[ j ] === suffixRetrieved ) {\n\t\t\t\t\treturn word.slice( 0, -suffixRetrieved.length );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Checks whether the word is in a given list of exceptions and if so, deletes a given suffix.\n *\n * @param {string[]}    exceptions  The exception list.\n * @param {string}      suffix      The suffix that needs to be deleted.\n * @param {string}      word        The word to check.\n *\n * @returns {string} The stemmed word.\n */\nexport function removeSuffixFromFullForm( exceptions, suffix, word ) {\n\tfor ( let i = 0; i < exceptions.length; i++ ) {\n\t\tif ( word.endsWith( exceptions[ i ] ) ) {\n\t\t\treturn word.slice( 0, -suffix.length );\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,0BAA0BA,CAAEC,IAAI,EAAEC,QAAQ,EAAEC,IAAI,EAAG;EAClE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,IAAI,CAACI,MAAM,EAAED,CAAC,EAAE,EAAG;IACvC,IAAKD,IAAI,CAACG,UAAU,CAAEL,IAAI,CAAEG,CAAC,CAAG,CAAC,EAAG;MACnC,MAAMG,eAAe,GAAGJ,IAAI,CAACK,SAAS,CAAEP,IAAI,CAAEG,CAAC,CAAE,CAACC,MAAO,CAAC;MAC1D,KAAM,IAAII,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGP,QAAQ,CAACG,MAAM,EAAEI,CAAC,EAAE,EAAG;QAC3C,IAAKP,QAAQ,CAAEO,CAAC,CAAE,KAAKF,eAAe,EAAG;UACxC,OAAOJ,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACH,eAAe,CAACF,MAAO,CAAC;QAChD;MACD;IACD;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASM,wBAAwBA,CAAEC,UAAU,EAAEC,MAAM,EAAEV,IAAI,EAAG;EACpE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGQ,UAAU,CAACP,MAAM,EAAED,CAAC,EAAE,EAAG;IAC7C,IAAKD,IAAI,CAACW,QAAQ,CAAEF,UAAU,CAAER,CAAC,CAAG,CAAC,EAAG;MACvC,OAAOD,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACG,MAAM,CAACR,MAAO,CAAC;IACvC;EACD;AACD","ignoreList":[]}
+{"version":3,"file":"stemHelpers.js","names":["removeSuffixesFromFullForm","list","suffixes","word","i","length","startsWith","suffixRetrieved","substring","j","slice","removeSuffixFromFullForm","exceptions","suffix","endsWith"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemHelpers.js"],"sourcesContent":["/**\n * Checks whether the word starts with one of the words in a given list and ends in one of the suffixes\n * in a given suffixes list. If so, deletes the suffix.\n *\n * @param {string[]}    list  The list of words to check against.\n * @param {string[]}    suffixes    The suffixes that needs to be deleted.\n * @param {string}      word        The word to check.\n * @returns {string}\tThe stemmed word.\n */\nexport function removeSuffixesFromFullForm( list, suffixes, word ) {\n\tfor ( let i = 0; i < list.length; i++ ) {\n\t\tif ( word.startsWith( list[ i ] ) ) {\n\t\t\tconst suffixRetrieved = word.substring( list[ i ].length );\n\t\t\tfor ( let j = 0; j < suffixes.length; j++ ) {\n\t\t\t\tif ( suffixes[ j ] === suffixRetrieved ) {\n\t\t\t\t\treturn word.slice( 0, -suffixRetrieved.length );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Checks whether the word is in a given list of exceptions and if so, deletes a given suffix.\n *\n * @param {string[]}    exceptions  The exception list.\n * @param {string}      suffix      The suffix that needs to be deleted.\n * @param {string}      word        The word to check.\n *\n * @returns {string} The stemmed word.\n */\nexport function removeSuffixFromFullForm( exceptions, suffix, word ) {\n\tfor ( let i = 0; i < exceptions.length; i++ ) {\n\t\tif ( word.endsWith( exceptions[ i ] ) ) {\n\t\t\treturn word.slice( 0, -suffix.length );\n\t\t}\n\t}\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,0BAA0BA,CAAEC,IAAI,EAAEC,QAAQ,EAAEC,IAAI,EAAG;EAClE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,IAAI,CAACI,MAAM,EAAED,CAAC,EAAE,EAAG;IACvC,IAAKD,IAAI,CAACG,UAAU,CAAEL,IAAI,CAAEG,CAAC,CAAG,CAAC,EAAG;MACnC,MAAMG,eAAe,GAAGJ,IAAI,CAACK,SAAS,CAAEP,IAAI,CAAEG,CAAC,CAAE,CAACC,MAAO,CAAC;MAC1D,KAAM,IAAII,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGP,QAAQ,CAACG,MAAM,EAAEI,CAAC,EAAE,EAAG;QAC3C,IAAKP,QAAQ,CAAEO,CAAC,CAAE,KAAKF,eAAe,EAAG;UACxC,OAAOJ,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACH,eAAe,CAACF,MAAO,CAAC;QAChD;MACD;IACD;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,wBAAwBA,CAAEC,UAAU,EAAEC,MAAM,EAAEV,IAAI,EAAG;EACpE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGQ,UAAU,CAACP,MAAM,EAAED,CAAC,EAAE,EAAG;IAC7C,IAAKD,IAAI,CAACW,QAAQ,CAAEF,UAAU,CAAER,CAAC,CAAG,CAAC,EAAG;MACvC,OAAOD,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACG,MAAM,CAACR,MAAO,CAAC;IACvC;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stemPrefixedFunctionWords = stemPrefixedFunctionWords;
 /**
  * An object containing the stem and the prefix.
  *
@@ -20,7 +14,7 @@ exports.stemPrefixedFunctionWords = stemPrefixedFunctionWords;
  * @returns {StemAndPrefixPair} The word without the function word prefixes that was stripped,
  * or the original word if the word is not prefixed.
  */
-function stemPrefixedFunctionWords(word, regex) {
+export function stemPrefixedFunctionWords(word, regex) {
   /*
   	 * If a word starts with one of the prefixes, we strip it.
    */

package/build/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js.map

@@ -1 +1 @@
-{"version":3,"file":"stemPrefixedFunctionWords.js","names":["stemPrefixedFunctionWords","word","regex","stemmedWord","prefix","isPrefixed","match","slice","length","stem"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js"],"sourcesContent":["/**\n * An object containing the stem and the prefix.\n *\n * @typedef {Object} \tStemAndPrefixPair\n * @property {string}\tstem The word without the basic prefixes.\n * @property {string}\tprefix The prefix that was matched.\n */\n\n/**\n * Strips function word prefixes from the word.\n *\n * @param {string} word The word to strip the basic prefixes from.\n * @param {RegExp} regex The regular expression to match the function word prefixes.\n * @returns {StemAndPrefixPair} The word without the function word prefixes that was stripped,\n * or the original word if the word is not prefixed.\n */\nexport function stemPrefixedFunctionWords( word, regex ) {\n\t/*\n \t * If a word starts with one of the prefixes, we strip it.\n\t */\n\tlet stemmedWord = word;\n\tlet prefix = \"\";\n\tconst isPrefixed = word.match( regex );\n\n\tif ( isPrefixed ) {\n\t\tprefix = isPrefixed[ 0 ];\n\t\tstemmedWord = word.slice( prefix.length );\n\t}\n\n\treturn { stem: stemmedWord, prefix: prefix };\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,yBAAyBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACxD;AACD;AACA;EACC,IAAIC,WAAW,GAAGF,IAAI;EACtB,IAAIG,MAAM,GAAG,EAAE;EACf,MAAMC,UAAU,GAAGJ,IAAI,CAACK,KAAK,CAAEJ,KAAM,CAAC;EAEtC,IAAKG,UAAU,EAAG;IACjBD,MAAM,GAAGC,UAAU,CAAE,CAAC,CAAE;IACxBF,WAAW,GAAGF,IAAI,CAACM,KAAK,CAAEH,MAAM,CAACI,MAAO,CAAC;EAC1C;EAEA,OAAO;IAAEC,IAAI,EAAEN,WAAW;IAAEC,MAAM,EAAEA;EAAO,CAAC;AAC7C","ignoreList":[]}
+{"version":3,"file":"stemPrefixedFunctionWords.js","names":["stemPrefixedFunctionWords","word","regex","stemmedWord","prefix","isPrefixed","match","slice","length","stem"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js"],"sourcesContent":["/**\n * An object containing the stem and the prefix.\n *\n * @typedef {Object} \tStemAndPrefixPair\n * @property {string}\tstem The word without the basic prefixes.\n * @property {string}\tprefix The prefix that was matched.\n */\n\n/**\n * Strips function word prefixes from the word.\n *\n * @param {string} word The word to strip the basic prefixes from.\n * @param {RegExp} regex The regular expression to match the function word prefixes.\n * @returns {StemAndPrefixPair} The word without the function word prefixes that was stripped,\n * or the original word if the word is not prefixed.\n */\nexport function stemPrefixedFunctionWords( word, regex ) {\n\t/*\n \t * If a word starts with one of the prefixes, we strip it.\n\t */\n\tlet stemmedWord = word;\n\tlet prefix = \"\";\n\tconst isPrefixed = word.match( regex );\n\n\tif ( isPrefixed ) {\n\t\tprefix = isPrefixed[ 0 ];\n\t\tstemmedWord = word.slice( prefix.length );\n\t}\n\n\treturn { stem: stemmedWord, prefix: prefix };\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,yBAAyBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACxD;AACD;AACA;EACC,IAAIC,WAAW,GAAGF,IAAI;EACtB,IAAIG,MAAM,GAAG,EAAE;EACf,MAAMC,UAAU,GAAGJ,IAAI,CAACK,KAAK,CAAEJ,KAAM,CAAC;EAEtC,IAAKG,UAAU,EAAG;IACjBD,MAAM,GAAGC,UAAU,CAAE,CAAC,CAAE;IACxBF,WAAW,GAAGF,IAAI,CAACM,KAAK,CAAEH,MAAM,CAACI,MAAO,CAAC;EAC1C;EAEA,OAAO;IAAEC,IAAI,EAAEN,WAAW;IAAEC,MAAM,EAAEA;EAAO,CAAC;AAC7C","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/directPrecedenceException.js

@@ -1,12 +1,6 @@
-"use strict";
+import { includes } from "lodash";
+import getWords from "../../word/getWords";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-var _lodash = require("lodash");
-var _getWords = _interopRequireDefault(require("../../word/getWords"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Checks whether the participle is directly preceded by a word from the direct precedence exception list.
  * If this is the case, the clause is not passive.
@@ -18,9 +12,9 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * @returns {boolean} Returns true if a word from the direct precedence exception list is directly preceding
  *                    the participle, otherwise returns false.
  */
-function _default(clause, participle, cannotDirectlyPrecedePassiveParticipleList = []) {
+export default function (clause, participle, cannotDirectlyPrecedePassiveParticipleList = []) {
   // Break the sentence part up into words and convert to lower case.
-  const wordsInClause = (0, _getWords.default)(clause).map(word => word.toLowerCase());
+  const wordsInClause = getWords(clause).map(word => word.toLowerCase());
 
   // Search the participle in the word list.
   const participleIndex = wordsInClause.indexOf(participle.toLowerCase());
@@ -37,6 +31,6 @@ function _default(clause, participle, cannotDirectlyPrecedePassiveParticipleList
   const wordPrecedingParticiple = wordsInClause[participleIndex - 1];
 
   // Check if the word preceding the participle is in the exceptions list.
-  return (0, _lodash.includes)(cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple);
+  return includes(cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple);
 }
 //# sourceMappingURL=directPrecedenceException.js.map