axyseo 2.1.12 → 2.1.13

package/build/cjs/languageProcessing/helpers/match/matchTextWithTransliteration.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = require("lodash");
+var _addWordboundary = _interopRequireDefault(require("../word/addWordboundary.js"));
+var _stripSpaces = _interopRequireDefault(require("../sanitize/stripSpaces.js"));
+var _transliterate = _interopRequireDefault(require("../transliterate/transliterate.js"));
+var _transliterateWPstyle = _interopRequireDefault(require("../transliterate/transliterateWPstyle.js"));
+var _specialCharacterMappings = require("../transliterate/specialCharacterMappings");
+var _index = require("../../index");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Creates a regex from the keyword with included wordboundaries.
+ *
+ * @param {string} keyword  The keyword to create a regex from.
+ * @param {string} language The language used to determine the word boundary.
+ *
+ * @returns {RegExp} Regular expression of the keyword with word boundaries.
+ */
+const toRegex = function (keyword, language) {
+  keyword = (0, _addWordboundary.default)(keyword, false, "", language);
+  return new RegExp(keyword, "ig");
+};
+
+/**
+ * Matches a string with and without transliteration.
+ * @param {string} text The text to match.
+ * @param {string} keyword The keyword to match in the text.
+ * @param {string} locale The locale used for transliteration.
+ * @returns {Array} All matches from the original as the transliterated text and keyword.
+ */
+function _default(text, keyword, locale) {
+  const language = (0, _index.getLanguage)(locale);
+  let keywordRegex = toRegex(keyword, language);
+  if (language === "tr") {
+    const turkishMappings = (0, _specialCharacterMappings.replaceTurkishIsMemoized)(keyword);
+    keywordRegex = new RegExp(turkishMappings.map(x => (0, _addWordboundary.default)(x)).join("|"), "ig");
+  }
+  const matches = text.match(keywordRegex) || [];
+  text = text.replace(keywordRegex, "");
+  const transliterateKeyword = (0, _transliterate.default)(keyword, locale);
+  const transliterateKeywordRegex = toRegex(transliterateKeyword, language);
+  const transliterateMatches = text.match(transliterateKeywordRegex) || [];
+  let combinedArray = matches.concat(transliterateMatches);
+  const transliterateWPKeyword = (0, _transliterateWPstyle.default)(keyword, locale);
+  if (!(transliterateWPKeyword === transliterateKeyword)) {
+    const transliterateWPKeywordRegex = toRegex(transliterateWPKeyword, language);
+    const transliterateWPMatches = text.match(transliterateWPKeywordRegex) || [];
+    combinedArray = combinedArray.concat(transliterateWPMatches);
+  }
+  return (0, _lodash.map)(combinedArray, function (match) {
+    return (0, _stripSpaces.default)(match);
+  });
+}
+//# sourceMappingURL=matchTextWithTransliteration.js.map

package/build/cjs/languageProcessing/helpers/match/matchTextWithTransliteration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchTextWithTransliteration.js","names":["_lodash","require","_addWordboundary","_interopRequireDefault","_stripSpaces","_transliterate","_transliterateWPstyle","_specialCharacterMappings","_index","e","__esModule","default","toRegex","keyword","language","addWordBoundary","RegExp","_default","text","locale","getLanguage","keywordRegex","turkishMappings","replaceTurkishIsMemoized","map","x","join","matches","match","replace","transliterateKeyword","transliterate","transliterateKeywordRegex","transliterateMatches","combinedArray","concat","transliterateWPKeyword","transliterateWP","transliterateWPKeywordRegex","transliterateWPMatches","stripSpaces"],"sources":["../../../../../src/languageProcessing/helpers/match/matchTextWithTransliteration.js"],"sourcesContent":["import { map } from \"lodash\";\nimport addWordBoundary from \"../word/addWordboundary.js\";\nimport stripSpaces from \"../sanitize/stripSpaces.js\";\nimport transliterate from \"../transliterate/transliterate.js\";\nimport transliterateWP from \"../transliterate/transliterateWPstyle.js\";\nimport { replaceTurkishIsMemoized } from \"../transliterate/specialCharacterMappings\";\nimport { getLanguage } from \"../../index\";\n\n/**\n * Creates a regex from the keyword with included wordboundaries.\n *\n * @param {string} keyword  The keyword to create a regex from.\n * @param {string} language The language used to determine the word boundary.\n *\n * @returns {RegExp} Regular expression of the keyword with word boundaries.\n */\nconst toRegex = function( keyword, language ) {\n\tkeyword = addWordBoundary( keyword, false, \"\", language );\n\treturn new RegExp( keyword, \"ig\" );\n};\n\n/**\n * Matches a string with and without transliteration.\n * @param {string} text The text to match.\n * @param {string} keyword The keyword to match in the text.\n * @param {string} locale The locale used for transliteration.\n * @returns {Array} All matches from the original as the transliterated text and keyword.\n */\nexport default function( text, keyword, locale ) {\n\tconst language = getLanguage( locale );\n\tlet keywordRegex = toRegex( keyword, language );\n\n\tif ( language === \"tr\" ) {\n\t\tconst turkishMappings = replaceTurkishIsMemoized( keyword );\n\t\tkeywordRegex = new RegExp( turkishMappings.map( x => addWordBoundary( x ) ).join( \"|\" ), \"ig\" );\n\t}\n\tconst matches = text.match( keywordRegex ) || [];\n\n\ttext = text.replace( keywordRegex, \"\" );\n\n\tconst transliterateKeyword = transliterate( keyword, locale );\n\tconst transliterateKeywordRegex = toRegex( transliterateKeyword, language );\n\tconst transliterateMatches = text.match( transliterateKeywordRegex ) || [];\n\tlet combinedArray = matches.concat( transliterateMatches );\n\n\tconst transliterateWPKeyword = transliterateWP( keyword, locale );\n\n\tif ( ! ( transliterateWPKeyword === transliterateKeyword ) ) {\n\t\tconst transliterateWPKeywordRegex = toRegex( transliterateWPKeyword, language );\n\t\tconst transliterateWPMatches = text.match( transliterateWPKeywordRegex ) || [];\n\n\t\tcombinedArray = combinedArray.concat( transliterateWPMatches );\n\t}\n\n\treturn map( combinedArray, function( match ) {\n\t\treturn stripSpaces( match );\n\t} );\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,YAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,cAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,qBAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,yBAAA,GAAAN,OAAA;AACA,IAAAO,MAAA,GAAAP,OAAA;AAA0C,SAAAE,uBAAAM,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,OAAO,GAAG,SAAAA,CAAUC,OAAO,EAAEC,QAAQ,EAAG;EAC7CD,OAAO,GAAG,IAAAE,wBAAe,EAAEF,OAAO,EAAE,KAAK,EAAE,EAAE,EAAEC,QAAS,CAAC;EACzD,OAAO,IAAIE,MAAM,CAAEH,OAAO,EAAE,IAAK,CAAC;AACnC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAI,SAAUC,IAAI,EAAEL,OAAO,EAAEM,MAAM,EAAG;EAChD,MAAML,QAAQ,GAAG,IAAAM,kBAAW,EAAED,MAAO,CAAC;EACtC,IAAIE,YAAY,GAAGT,OAAO,CAAEC,OAAO,EAAEC,QAAS,CAAC;EAE/C,IAAKA,QAAQ,KAAK,IAAI,EAAG;IACxB,MAAMQ,eAAe,GAAG,IAAAC,kDAAwB,EAAEV,OAAQ,CAAC;IAC3DQ,YAAY,GAAG,IAAIL,MAAM,CAAEM,eAAe,CAACE,GAAG,CAAEC,CAAC,IAAI,IAAAV,wBAAe,EAAEU,CAAE,CAAE,CAAC,CAACC,IAAI,CAAE,GAAI,CAAC,EAAE,IAAK,CAAC;EAChG;EACA,MAAMC,OAAO,GAAGT,IAAI,CAACU,KAAK,CAAEP,YAAa,CAAC,IAAI,EAAE;EAEhDH,IAAI,GAAGA,IAAI,CAACW,OAAO,CAAER,YAAY,EAAE,EAAG,CAAC;EAEvC,MAAMS,oBAAoB,GAAG,IAAAC,sBAAa,EAAElB,OAAO,EAAEM,MAAO,CAAC;EAC7D,MAAMa,yBAAyB,GAAGpB,OAAO,CAAEkB,oBAAoB,EAAEhB,QAAS,CAAC;EAC3E,MAAMmB,oBAAoB,GAAGf,IAAI,CAACU,KAAK,CAAEI,yBAA0B,CAAC,IAAI,EAAE;EAC1E,IAAIE,aAAa,GAAGP,OAAO,CAACQ,MAAM,CAAEF,oBAAqB,CAAC;EAE1D,MAAMG,sBAAsB,GAAG,IAAAC,6BAAe,EAAExB,OAAO,EAAEM,MAAO,CAAC;EAEjE,IAAK,EAAIiB,sBAAsB,KAAKN,oBAAoB,CAAE,EAAG;IAC5D,MAAMQ,2BAA2B,GAAG1B,OAAO,CAAEwB,sBAAsB,EAAEtB,QAAS,CAAC;IAC/E,MAAMyB,sBAAsB,GAAGrB,IAAI,CAACU,KAAK,CAAEU,2BAA4B,CAAC,IAAI,EAAE;IAE9EJ,aAAa,GAAGA,aAAa,CAACC,MAAM,CAAEI,sBAAuB,CAAC;EAC/D;EAEA,OAAO,IAAAf,WAAG,EAAEU,aAAa,EAAE,UAAUN,KAAK,EAAG;IAC5C,OAAO,IAAAY,oBAAW,EAAEZ,KAAM,CAAC;EAC5B,CAAE,CAAC;AACJ","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/match/matchTextWithWord.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _stripNonTextTags = _interopRequireDefault(require("../sanitize/stripNonTextTags.js"));
+var _stripSpaces = _interopRequireDefault(require("../sanitize/stripSpaces.js"));
+var _removePunctuation = _interopRequireDefault(require("../sanitize/removePunctuation.js"));
+var _unifyWhitespace = require("../sanitize/unifyWhitespace.js");
+var _matchTextWithTransliteration = _interopRequireDefault(require("./matchTextWithTransliteration.js"));
+var _quotes = require("../sanitize/quotes.js");
+var _lodash = require("lodash");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module stringProcessing/matchTextWithWord */
+
+/**
+ * Returns the number of matches in a given string
+ *
+ * @param {string}      text                    The text to use for matching the wordToMatch.
+ * @param {string}      wordToMatch             The word to match in the text.
+ * @param {string}      locale   				The locale used for transliteration.
+ * @param {function}    matchWordCustomHelper  	The helper function to match word in text.
+ *
+ * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.
+ */
+function _default(text, wordToMatch, locale, matchWordCustomHelper) {
+  text = (0, _stripNonTextTags.default)(text);
+  text = (0, _unifyWhitespace.unifyAllSpaces)(text);
+  text = (0, _quotes.normalize)(text);
+  wordToMatch = (0, _quotes.normalize)(wordToMatch);
+  let matches = matchWordCustomHelper ? matchWordCustomHelper(text, wordToMatch) : (0, _matchTextWithTransliteration.default)(text, wordToMatch, locale);
+  matches = (0, _lodash.map)(matches, function (keyword) {
+    return (0, _stripSpaces.default)((0, _removePunctuation.default)(keyword));
+  });
+
+  // Create an array of positions of matches to determine where in the text the wordToMatch occurred first.
+  const positions = (0, _lodash.map)(matches, function (keyword) {
+    return text.indexOf(keyword);
+  });
+  return {
+    count: matches.length,
+    matches: matches,
+    position: positions.length === 0 ? -1 : Math.min(...positions)
+  };
+}
+//# sourceMappingURL=matchTextWithWord.js.map

package/build/cjs/languageProcessing/helpers/match/matchTextWithWord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchTextWithWord.js","names":["_stripNonTextTags","_interopRequireDefault","require","_stripSpaces","_removePunctuation","_unifyWhitespace","_matchTextWithTransliteration","_quotes","_lodash","e","__esModule","default","_default","text","wordToMatch","locale","matchWordCustomHelper","stripSomeTags","unifyWhitespace","normalizeQuotes","matches","matchStringWithTransliteration","map","keyword","stripSpaces","removePunctuation","positions","indexOf","count","length","position","Math","min"],"sources":["../../../../../src/languageProcessing/helpers/match/matchTextWithWord.js"],"sourcesContent":["/** @module stringProcessing/matchTextWithWord */\n\nimport stripSomeTags from '../sanitize/stripNonTextTags.js';\nimport stripSpaces from '../sanitize/stripSpaces.js';\nimport removePunctuation from '../sanitize/removePunctuation.js';\nimport {unifyAllSpaces as unifyWhitespace} from '../sanitize/unifyWhitespace.js';\nimport matchStringWithTransliteration from './matchTextWithTransliteration.js';\nimport {normalize as normalizeQuotes} from '../sanitize/quotes.js';\nimport {map} from 'lodash';\n\n/**\n * Returns the number of matches in a given string\n *\n * @param {string}      text                    The text to use for matching the wordToMatch.\n * @param {string}      wordToMatch             The word to match in the text.\n * @param {string}      locale   \t\t\t\tThe locale used for transliteration.\n * @param {function}    matchWordCustomHelper  \tThe helper function to match word in text.\n *\n * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.\n */\nexport default function(text, wordToMatch, locale, matchWordCustomHelper) {\n  text = stripSomeTags(text);\n  text = unifyWhitespace(text);\n  text = normalizeQuotes(text);\n\n  wordToMatch = normalizeQuotes(wordToMatch);\n  let matches = matchWordCustomHelper\n    ? matchWordCustomHelper(text, wordToMatch)\n    : matchStringWithTransliteration(text, wordToMatch, locale);\n  matches = map(matches, function(keyword) {\n    return stripSpaces(removePunctuation(keyword));\n  });\n\n  // Create an array of positions of matches to determine where in the text the wordToMatch occurred first.\n  const positions = map(matches, function(keyword) {\n    return text.indexOf(keyword);\n  });\n\n  return {\n    count: matches.length,\n    matches: matches,\n    position: positions.length === 0 ? -1 : Math.min(...positions)\n  };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,iBAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,YAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,kBAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,gBAAA,GAAAH,OAAA;AACA,IAAAI,6BAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AAA2B,SAAAD,uBAAAQ,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAR3B;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAG,SAASC,IAAI,EAAEC,WAAW,EAAEC,MAAM,EAAEC,qBAAqB,EAAE;EACxEH,IAAI,GAAG,IAAAI,yBAAa,EAACJ,IAAI,CAAC;EAC1BA,IAAI,GAAG,IAAAK,+BAAe,EAACL,IAAI,CAAC;EAC5BA,IAAI,GAAG,IAAAM,iBAAe,EAACN,IAAI,CAAC;EAE5BC,WAAW,GAAG,IAAAK,iBAAe,EAACL,WAAW,CAAC;EAC1C,IAAIM,OAAO,GAAGJ,qBAAqB,GAC/BA,qBAAqB,CAACH,IAAI,EAAEC,WAAW,CAAC,GACxC,IAAAO,qCAA8B,EAACR,IAAI,EAAEC,WAAW,EAAEC,MAAM,CAAC;EAC7DK,OAAO,GAAG,IAAAE,WAAG,EAACF,OAAO,EAAE,UAASG,OAAO,EAAE;IACvC,OAAO,IAAAC,oBAAW,EAAC,IAAAC,0BAAiB,EAACF,OAAO,CAAC,CAAC;EAChD,CAAC,CAAC;;EAEF;EACA,MAAMG,SAAS,GAAG,IAAAJ,WAAG,EAACF,OAAO,EAAE,UAASG,OAAO,EAAE;IAC/C,OAAOV,IAAI,CAACc,OAAO,CAACJ,OAAO,CAAC;EAC9B,CAAC,CAAC;EAEF,OAAO;IACLK,KAAK,EAAER,OAAO,CAACS,MAAM;IACrBT,OAAO,EAAEA,OAAO;IAChBU,QAAQ,EAAEJ,SAAS,CAACG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC,GAAGE,IAAI,CAACC,GAAG,CAAC,GAAGN,SAAS;EAC/D,CAAC;AACH","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/match/matchWordFormsWithSentence.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tokenizeKeyphraseFormsForExactMatching = exports.default = void 0;
+var _matchTextWithTransliteration = _interopRequireDefault(require("./matchTextWithTransliteration"));
+var _splitIntoTokens = _interopRequireDefault(require("../word/splitIntoTokens"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Tokenizes the word form of the keyphrase for exact matching. This function gets the word form and tokenizes it.
+ * This function assumes that if a keyphrase needs to be matched exactly, there will be only one word form.
+ * This is the result of how the focus keyphrase is processed in buildTopicStems.js in the buildStems function.
+ *
+ * @param {(string[])}  wordForms 					The word forms to tokenize.
+ * @param {function}	customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
+ *
+ * @returns {string[]} The tokenized word forms.
+ */
+const tokenizeKeyphraseFormsForExactMatching = (wordForms, customSplitIntoTokensHelper) => {
+  // Tokenize word form of the keyphrase.
+  const wordFormText = wordForms[0];
+  return customSplitIntoTokensHelper ? customSplitIntoTokensHelper(wordFormText) : (0, _splitIntoTokens.default)(wordFormText);
+};
+
+/**
+ * Gets the exact matches of the keyphrase.
+ * Exact matching happens when the user puts the keyphrase in double quotes.
+ *
+ * @param {Sentence}	sentence					The sentence to match the word forms with.
+ * @param {string[]}	wordForms					The word forms to match.
+ * @param {string}		locale						The locale used in the analysis.
+ * @param {function}	customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
+ *
+ * @returns {{count: number, matches: Token[]}} Object containing the number of the exact matches and the matched tokens.
+ */
+exports.tokenizeKeyphraseFormsForExactMatching = tokenizeKeyphraseFormsForExactMatching;
+const findExactMatchKeyphraseInSentence = (sentence, wordForms, locale, customSplitIntoTokensHelper) => {
+  const result = {
+    count: 0,
+    matches: []
+  };
+  // Tokenize word forms of the keyphrase.
+  const keyphraseTokens = tokenizeKeyphraseFormsForExactMatching(wordForms, customSplitIntoTokensHelper);
+  const sentenceTokens = sentence.tokens;
+
+  // Initialize the index of the word token of the keyphrase.
+  let indexOfWordInKeyphrase = 0;
+  // Initialize the index of the word token of the sentence.
+  let indexOfWordInSentence = 0;
+  let currentMatch = [];
+  // Check if the tokenized word forms occur in the same order in the sentence tokens.
+  while (indexOfWordInSentence < sentenceTokens.length) {
+    // If the current sentence token matches the current word token of the keyphrase, add it to the current match.
+    const sentenceTokenText = sentenceTokens[indexOfWordInSentence].text;
+    const keyphraseTokenText = keyphraseTokens[indexOfWordInKeyphrase];
+    const foundMatches = (0, _matchTextWithTransliteration.default)(sentenceTokenText.toLowerCase(), keyphraseTokenText.toLowerCase(), locale);
+    if (foundMatches.length > 0) {
+      currentMatch.push(sentenceTokens[indexOfWordInSentence]);
+      indexOfWordInKeyphrase++;
+    } else {
+      indexOfWordInKeyphrase = 0;
+      currentMatch = [];
+    }
+
+    /*
+     * If the current match has the same length as the keyphrase tokens, the keyphrase forms have been matched.
+     * Add the current match to the matches array and reset the index of the word in keyphrase and the current match.
+     */
+    if (currentMatch.length === keyphraseTokens.length) {
+      result.matches.push(...currentMatch);
+      result.count++;
+      indexOfWordInKeyphrase = 0;
+      currentMatch = [];
+    }
+    indexOfWordInSentence++;
+  }
+  return result;
+};
+
+/**
+ * Matches a word form of the keyphrase with the tokens from the sentence.
+ *
+ * With this approach, we transliterate the word form of the keyphrase before matching it with the sentence tokens.
+ * However, we don't do the transliteration step for the sentence tokens.
+ * As a result, for example, the word form "acción" from the keyphrase will match the word "accion" in the sentence.
+ * But, the word form "accion" from the keyphrase will NOT match the word "acción" in the sentence.
+ *
+ * @param {Token[]}	tokens		The array of tokens to check.
+ * @param {string}	wordForm	The word form of the keyphrase.
+ * @param {string}	locale		The locale used in the analysis.
+ *
+ * @returns {Token[]}	The array of the matched tokens.
+ */
+const matchWordFormInTokens = (tokens, wordForm, locale) => {
+  let matches = [];
+  tokens.forEach(token => {
+    const occurrence = (0, _matchTextWithTransliteration.default)(token.text.toLowerCase(), wordForm, locale);
+    if (occurrence.length > 0) {
+      matches = matches.concat(token);
+    }
+  });
+  return matches;
+};
+
+/**
+ * Finds keyphrase forms in a sentence.
+ *
+ * @param {Sentence|string}	sentence				The sentence to check.
+ * @param {string[]}		wordForms				The word forms of the keyphrase to check.
+ * @param {string}			locale					The locale used in the analysis.
+ * @param {function}		matchWordCustomHelper	Custom function to match a word form with sentence.
+ *
+ * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.
+ */
+const matchWordFormsInSentence = (sentence, wordForms, locale, matchWordCustomHelper) => {
+  const result = {
+    count: 0,
+    matches: []
+  };
+  wordForms.forEach(wordForm => {
+    let occurrences = [];
+    if (matchWordCustomHelper) {
+      occurrences = matchWordCustomHelper(sentence, wordForm);
+    } else {
+      const tokens = sentence.tokens.slice();
+      occurrences = matchWordFormInTokens(tokens, wordForm, locale);
+    }
+    result.count += occurrences.length;
+    result.matches = result.matches.concat(occurrences);
+  });
+  return result;
+};
+
+/**
+ * Matches the word forms of a keyphrase with a sentence object from the html parser.
+ *
+ * @param {Sentence|string}	sentence					The sentence to match against the word forms of a keyphrase.
+ * @param {string[]}		wordForms					The array of word forms of the keyphrase.
+ * E.g. If the keyphrase is "key word", then (if Premium is activated) this will be [ "key", "keys" ] OR [ "word", "words" ]
+ * The forms are retrieved higher up (among others in keywordCount.js) with researcher.getResearch( "morphology" ).
+ * @param {string}			locale						The locale used for transliteration.
+ * @param {function}		matchWordCustomHelper		Custom function to match a word form with sentence.
+ * @param {boolean}			useExactMatching			Whether to match the keyphrase forms exactly or not.
+ * 														Exact match is used when the keyphrase is enclosed in double quotes.
+ * @param {function}		customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
+ *
+ * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.
+ */
+const matchWordFormsWithSentence = (sentence, wordForms, locale, matchWordCustomHelper, useExactMatching = false, customSplitIntoTokensHelper) => {
+  /*
+   * Only use `findExactMatchKeyphraseInSentence` when the custom helper is not available.
+   * When the custom helper is available, the step for the exact matching happens in the helper.
+   */
+  if (useExactMatching && !matchWordCustomHelper) {
+    return findExactMatchKeyphraseInSentence(sentence, wordForms, locale, customSplitIntoTokensHelper);
+  }
+  return matchWordFormsInSentence(sentence, wordForms, locale, matchWordCustomHelper);
+};
+var _default = exports.default = matchWordFormsWithSentence;
+//# sourceMappingURL=matchWordFormsWithSentence.js.map

package/build/cjs/languageProcessing/helpers/match/matchWordFormsWithSentence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchWordFormsWithSentence.js","names":["_matchTextWithTransliteration","_interopRequireDefault","require","_splitIntoTokens","e","__esModule","default","tokenizeKeyphraseFormsForExactMatching","wordForms","customSplitIntoTokensHelper","wordFormText","splitIntoTokens","exports","findExactMatchKeyphraseInSentence","sentence","locale","result","count","matches","keyphraseTokens","sentenceTokens","tokens","indexOfWordInKeyphrase","indexOfWordInSentence","currentMatch","length","sentenceTokenText","text","keyphraseTokenText","foundMatches","matchTextWithTransliteration","toLowerCase","push","matchWordFormInTokens","wordForm","forEach","token","occurrence","concat","matchWordFormsInSentence","matchWordCustomHelper","occurrences","slice","matchWordFormsWithSentence","useExactMatching","_default"],"sources":["../../../../../src/languageProcessing/helpers/match/matchWordFormsWithSentence.js"],"sourcesContent":["import matchTextWithTransliteration from './matchTextWithTransliteration';\nimport splitIntoTokens from '../word/splitIntoTokens';\n\n/**\n * Tokenizes the word form of the keyphrase for exact matching. This function gets the word form and tokenizes it.\n * This function assumes that if a keyphrase needs to be matched exactly, there will be only one word form.\n * This is the result of how the focus keyphrase is processed in buildTopicStems.js in the buildStems function.\n *\n * @param {(string[])}  wordForms \t\t\t\t\tThe word forms to tokenize.\n * @param {function}\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {string[]} The tokenized word forms.\n */\nexport const tokenizeKeyphraseFormsForExactMatching = (wordForms, customSplitIntoTokensHelper) => {\n  // Tokenize word form of the keyphrase.\n  const wordFormText = wordForms[0];\n\n  return customSplitIntoTokensHelper\n    ? customSplitIntoTokensHelper(wordFormText)\n    : splitIntoTokens(wordFormText);\n};\n\n/**\n * Gets the exact matches of the keyphrase.\n * Exact matching happens when the user puts the keyphrase in double quotes.\n *\n * @param {Sentence}\tsentence\t\t\t\t\tThe sentence to match the word forms with.\n * @param {string[]}\twordForms\t\t\t\t\tThe word forms to match.\n * @param {string}\t\tlocale\t\t\t\t\t\tThe locale used in the analysis.\n * @param {function}\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {{count: number, matches: Token[]}} Object containing the number of the exact matches and the matched tokens.\n */\nconst findExactMatchKeyphraseInSentence = (\n  sentence,\n  wordForms,\n  locale,\n  customSplitIntoTokensHelper\n) => {\n  const result = {\n    count: 0,\n    matches: []\n  };\n  // Tokenize word forms of the keyphrase.\n  const keyphraseTokens = tokenizeKeyphraseFormsForExactMatching(\n    wordForms,\n    customSplitIntoTokensHelper\n  );\n  const sentenceTokens = sentence.tokens;\n\n  // Initialize the index of the word token of the keyphrase.\n  let indexOfWordInKeyphrase = 0;\n  // Initialize the index of the word token of the sentence.\n  let indexOfWordInSentence = 0;\n  let currentMatch = [];\n  // Check if the tokenized word forms occur in the same order in the sentence tokens.\n  while (indexOfWordInSentence < sentenceTokens.length) {\n    // If the current sentence token matches the current word token of the keyphrase, add it to the current match.\n    const sentenceTokenText = sentenceTokens[indexOfWordInSentence].text;\n    const keyphraseTokenText = keyphraseTokens[indexOfWordInKeyphrase];\n\n    const foundMatches = matchTextWithTransliteration(\n      sentenceTokenText.toLowerCase(),\n      keyphraseTokenText.toLowerCase(),\n      locale\n    );\n\n    if (foundMatches.length > 0) {\n      currentMatch.push(sentenceTokens[indexOfWordInSentence]);\n      indexOfWordInKeyphrase++;\n    } else {\n      indexOfWordInKeyphrase = 0;\n      currentMatch = [];\n    }\n\n    /*\n     * If the current match has the same length as the keyphrase tokens, the keyphrase forms have been matched.\n     * Add the current match to the matches array and reset the index of the word in keyphrase and the current match.\n     */\n    if (currentMatch.length === keyphraseTokens.length) {\n      result.matches.push(...currentMatch);\n      result.count++;\n      indexOfWordInKeyphrase = 0;\n      currentMatch = [];\n    }\n\n    indexOfWordInSentence++;\n  }\n  return result;\n};\n\n/**\n * Matches a word form of the keyphrase with the tokens from the sentence.\n *\n * With this approach, we transliterate the word form of the keyphrase before matching it with the sentence tokens.\n * However, we don't do the transliteration step for the sentence tokens.\n * As a result, for example, the word form \"acción\" from the keyphrase will match the word \"accion\" in the sentence.\n * But, the word form \"accion\" from the keyphrase will NOT match the word \"acción\" in the sentence.\n *\n * @param {Token[]}\ttokens\t\tThe array of tokens to check.\n * @param {string}\twordForm\tThe word form of the keyphrase.\n * @param {string}\tlocale\t\tThe locale used in the analysis.\n *\n * @returns {Token[]}\tThe array of the matched tokens.\n */\nconst matchWordFormInTokens = (tokens, wordForm, locale) => {\n  let matches = [];\n\n  tokens.forEach(token => {\n    const occurrence = matchTextWithTransliteration(token.text.toLowerCase(), wordForm, locale);\n    if (occurrence.length > 0) {\n      matches = matches.concat(token);\n    }\n  });\n\n  return matches;\n};\n\n/**\n * Finds keyphrase forms in a sentence.\n *\n * @param {Sentence|string}\tsentence\t\t\t\tThe sentence to check.\n * @param {string[]}\t\twordForms\t\t\t\tThe word forms of the keyphrase to check.\n * @param {string}\t\t\tlocale\t\t\t\t\tThe locale used in the analysis.\n * @param {function}\t\tmatchWordCustomHelper\tCustom function to match a word form with sentence.\n *\n * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.\n */\nconst matchWordFormsInSentence = (sentence, wordForms, locale, matchWordCustomHelper) => {\n  const result = {\n    count: 0,\n    matches: []\n  };\n\n  wordForms.forEach(wordForm => {\n    let occurrences = [];\n    if (matchWordCustomHelper) {\n      occurrences = matchWordCustomHelper(sentence, wordForm);\n    } else {\n      const tokens = sentence.tokens.slice();\n      occurrences = matchWordFormInTokens(tokens, wordForm, locale);\n    }\n    result.count += occurrences.length;\n    result.matches = result.matches.concat(occurrences);\n  });\n\n  return result;\n};\n\n/**\n * Matches the word forms of a keyphrase with a sentence object from the html parser.\n *\n * @param {Sentence|string}\tsentence\t\t\t\t\tThe sentence to match against the word forms of a keyphrase.\n * @param {string[]}\t\twordForms\t\t\t\t\tThe array of word forms of the keyphrase.\n * E.g. If the keyphrase is \"key word\", then (if Premium is activated) this will be [ \"key\", \"keys\" ] OR [ \"word\", \"words\" ]\n * The forms are retrieved higher up (among others in keywordCount.js) with researcher.getResearch( \"morphology\" ).\n * @param {string}\t\t\tlocale\t\t\t\t\t\tThe locale used for transliteration.\n * @param {function}\t\tmatchWordCustomHelper\t\tCustom function to match a word form with sentence.\n * @param {boolean}\t\t\tuseExactMatching\t\t\tWhether to match the keyphrase forms exactly or not.\n * \t\t\t\t\t\t\t\t\t\t\t\t\t\tExact match is used when the keyphrase is enclosed in double quotes.\n * @param {function}\t\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.\n */\nconst matchWordFormsWithSentence = (\n  sentence,\n  wordForms,\n  locale,\n  matchWordCustomHelper,\n  useExactMatching = false,\n  customSplitIntoTokensHelper\n) => {\n  /*\n   * Only use `findExactMatchKeyphraseInSentence` when the custom helper is not available.\n   * When the custom helper is available, the step for the exact matching happens in the helper.\n   */\n  if (useExactMatching && !matchWordCustomHelper) {\n    return findExactMatchKeyphraseInSentence(\n      sentence,\n      wordForms,\n      locale,\n      customSplitIntoTokensHelper\n    );\n  }\n  return matchWordFormsInSentence(sentence, wordForms, locale, matchWordCustomHelper);\n};\n\nexport default matchWordFormsWithSentence;\n"],"mappings":"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","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/match/processExactMatchRequest.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = processExactMatchRequest;
+var _isDoubleQuoted = _interopRequireDefault(require("./isDoubleQuoted"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Checks if exact match functionality is requested by enclosing the keyphrase in double quotation marks.
+ *
+ * @param {string}  keyphrase       The keyphrase to check. This must be the keyphrase accessed directly from the Paper.
+ *
+ * @returns {Object} Whether the exact match functionality is requested and the keyword stripped from double quotes.
+ */
+function processExactMatchRequest(keyphrase) {
+  const exactMatchRequest = {
+    exactMatchRequested: false,
+    keyphrase: keyphrase
+  };
+
+  // Check if only exact match processing is requested by the user. If so, strip the quotation marks from the keyphrase.
+  if ((0, _isDoubleQuoted.default)(keyphrase)) {
+    exactMatchRequest.keyphrase = keyphrase.substring(1, keyphrase.length - 1);
+    exactMatchRequest.exactMatchRequested = true;
+  }
+  return exactMatchRequest;
+}
+//# sourceMappingURL=processExactMatchRequest.js.map

package/build/cjs/languageProcessing/helpers/match/processExactMatchRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processExactMatchRequest.js","names":["_isDoubleQuoted","_interopRequireDefault","require","e","__esModule","default","processExactMatchRequest","keyphrase","exactMatchRequest","exactMatchRequested","isDoubleQuoted","substring","length"],"sources":["../../../../../src/languageProcessing/helpers/match/processExactMatchRequest.js"],"sourcesContent":["import isDoubleQuoted from \"./isDoubleQuoted\";\n\n/**\n * Checks if exact match functionality is requested by enclosing the keyphrase in double quotation marks.\n *\n * @param {string}  keyphrase       The keyphrase to check. This must be the keyphrase accessed directly from the Paper.\n *\n * @returns {Object} Whether the exact match functionality is requested and the keyword stripped from double quotes.\n */\nexport default function processExactMatchRequest( keyphrase ) {\n\tconst exactMatchRequest = { exactMatchRequested: false, keyphrase: keyphrase };\n\n\t// Check if only exact match processing is requested by the user. If so, strip the quotation marks from the keyphrase.\n\tif ( isDoubleQuoted( keyphrase ) ) {\n\t\texactMatchRequest.keyphrase = keyphrase.substring( 1, keyphrase.length - 1 );\n\t\texactMatchRequest.exactMatchRequested = true;\n\t}\n\n\treturn exactMatchRequest;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,eAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA8C,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE9C;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASG,wBAAwBA,CAAEC,SAAS,EAAG;EAC7D,MAAMC,iBAAiB,GAAG;IAAEC,mBAAmB,EAAE,KAAK;IAAEF,SAAS,EAAEA;EAAU,CAAC;;EAE9E;EACA,IAAK,IAAAG,uBAAc,EAAEH,SAAU,CAAC,EAAG;IAClCC,iBAAiB,CAACD,SAAS,GAAGA,SAAS,CAACI,SAAS,CAAE,CAAC,EAAEJ,SAAS,CAACK,MAAM,GAAG,CAAE,CAAC;IAC5EJ,iBAAiB,CAACC,mBAAmB,GAAG,IAAI;EAC7C;EAEA,OAAOD,iBAAiB;AACzB","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/morphology/baseStemmer.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = baseStemmer;
+/**
+ * Base stemmer that does not stem.
+ * This is exported to allow for comparing if a stemmer is the base stemmer.
+ *
+ * @param {string} word The word to stem.
+ *
+ * @returns {string} The stemmed word.
+ */
+function baseStemmer(word) {
+  return word;
+}
+//# sourceMappingURL=baseStemmer.js.map

package/build/cjs/languageProcessing/helpers/morphology/baseStemmer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseStemmer.js","names":["baseStemmer","word"],"sources":["../../../../../src/languageProcessing/helpers/morphology/baseStemmer.js"],"sourcesContent":["/**\n * Base stemmer that does not stem.\n * This is exported to allow for comparing if a stemmer is the base stemmer.\n *\n * @param {string} word The word to stem.\n *\n * @returns {string} The stemmed word.\n */\nexport default function baseStemmer( word ) {\n\treturn word;\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,WAAWA,CAAEC,IAAI,EAAG;EAC3C,OAAOA,IAAI;AACZ","ignoreList":[]}

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

@@ -0,0 +1,26 @@
+"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.
+ *
+ * @param {string} word The word to build forms for.
+ * @param {Array} regexes The regex-based array of rules to compare the word against.
+ *
+ * @returns {string} The newly built form of the word.
+ */
+function buildFormRule(word, regexes) {
+  if (regexes.includes(null)) {
+    return word;
+  }
+  for (let i = 0; i < regexes.length; i++) {
+    if (regexes[i].reg.test(word) === true) {
+      return word.replace(regexes[i].reg, regexes[i].repl);
+    }
+  }
+}
+//# sourceMappingURL=buildFormRule.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,164 @@
+"use strict";
+
+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.
+ */
+class TopicPhrase {
+  /**
+   * Constructs a new TopicPhrase.
+   *
+   * @param {StemOriginalPair[]} stemOriginalPairs The stem-original pairs for the words in the topic phrase.
+   * @param {boolean}            exactMatch        Whether the topic phrase is an exact match.
+   *
+   * @constructor
+   */
+  constructor(stemOriginalPairs = [], exactMatch = false) {
+    this.stemOriginalPairs = stemOriginalPairs;
+    this.exactMatch = exactMatch;
+  }
+
+  /**
+   * Returns all stems in the topic phrase.
+   *
+   * @returns {string[]|[]} The stems in the topic phrase or empty array if the topic phrase is exact match.
+   */
+  getStems() {
+    // An exact match keyphrase doesn't have stems.
+    if (this.exactMatch) {
+      return [];
+    }
+    return this.stemOriginalPairs.map(stemOriginalPair => stemOriginalPair.stem);
+  }
+}
+
+/**
+ * A stem-original pair ƒor a word in a topic phrase.
+ *
+ * @param {string} stem     The stem of the topic phrase word.
+ * @param {string} original The original word form the topic phrase (unsanitized)
+ *
+ * @constructor
+ */
+exports.TopicPhrase = TopicPhrase;
+function StemOriginalPair(stem, original) {
+  this.stem = stem;
+  this.original = original;
+}
+
+/**
+ * Analyzes the focus keyword string or one synonym phrase.
+ * Checks if morphology is requested or if the user wants to match the exact string.
+ * If morphology is required, the module finds a stem for all words (if no function words list is available), or
+ * for all content words (i.e., excluding prepositions, articles, conjunctions, if the function words list is available).
+ *
+ * @param {string}   keyphrase     				The keyphrase of the paper (or a synonym phrase) to get stem for.
+ * @param {function} stemmer       				The language-specific stemmer.
+ * @param {string[]} functionWords 				The language-specific function words.
+ * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
+ *
+ * @returns {TopicPhrase} Object with an array of StemOriginalPairs of all (content) words in the keyphrase or synonym
+ * 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 === "") {
+    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)) {
+    keyphrase = keyphrase.substring(1, keyphrase.length - 1);
+    return new TopicPhrase([new StemOriginalPair((0, _lodash.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);
+
+  // 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));
+  if (wordsWithoutFunctionWords.length > 0) {
+    keyphraseWords = wordsWithoutFunctionWords;
+  }
+
+  // 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 TopicPhrase(stemOriginalPairs);
+};
+
+/**
+ * Builds stems of words of the keyphrase and of each synonym phrase.
+ *
+ * @param {string}   keyphrase     				The paper's keyphrase.
+ * @param {string[]} synonyms     				The paper's synonyms.
+ * @param {function} stemmer       				The language-specific stemmer (if available).
+ * @param {string[]} functionWords 				The language-specific function words.
+ * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
+ *
+ * @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));
+  return {
+    keyphraseStems,
+    synonymsStems
+  };
+};
+
+/**
+ * Caches stems depending on the currently available stemmer and functionWords and (separately) keyphrase and synonyms.
+ * In this way, if the stemmer and functionWords remain the same in multiple calls of this function, the function
+ * that collects actual stems only needs to check if the keyphrase and synonyms also remain the
+ * same to return the cached result. The joining of keyphrase and synonyms for this function is needed,
+ * because by default memoize caches by the first key only, which in the current case would mean that the function would
+ * return the cached forms if the keyphrase has not changed (without checking if synonyms were changed).
+ *
+ * @param {function} stemmer       				The language-specific stemmer (if available).
+ * @param {string[]} functionWords 				The language-specific function words.
+ * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
+ *
+ * @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) => {
+    return collectKeyphraseAndSynonymsStems(keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries);
+  }, (keyphrase, synonyms) => {
+    return keyphrase + "," + synonyms.join(",");
+  });
+});
+
+/**
+ * Retrieves stems of words of the keyphrase and of each synonym phrase using the function that caches
+ * the results of previous calls of this function.
+ *
+ * @param {string}      keyphrase       			The paper's keyphrase.
+ * @param {string[]}    synonyms        			The paper's synonyms.
+ * @param {function}    stemmer         			The language-specific stemmer (if available).
+ * @param {string[]}    functionWords   			The language-specific function words.
+ * @param {boolean}		areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
+ *
+ * @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.
+ */
+function collectStems(keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries) {
+  const collectStemsWithLanguageSpecificData = primeLanguageSpecificData(stemmer, functionWords, areHyphensWordBoundaries);
+  return collectStemsWithLanguageSpecificData(keyphrase, synonyms);
+}
+//# sourceMappingURL=buildTopicStems.js.map

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

@@ -0,0 +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 \"@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":[]}