axyseo 2.0.0-alpha.1

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

@@ -0,0 +1,162 @@
+"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, 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/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\t// Tokenize word form of the keyphrase.\n\tconst wordFormText = wordForms[ 0 ];\n\n\treturn customSplitIntoTokensHelper ? customSplitIntoTokensHelper( wordFormText ) : 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 = ( sentence, wordForms, locale, customSplitIntoTokensHelper ) => {\n\tconst result = {\n\t\tcount: 0,\n\t\tmatches: [],\n\t};\n\t// Tokenize word forms of the keyphrase.\n\tconst keyphraseTokens = tokenizeKeyphraseFormsForExactMatching( wordForms, customSplitIntoTokensHelper );\n\n\tconst sentenceTokens = sentence.tokens;\n\n\t// Initialize the index of the word token of the keyphrase.\n\tlet indexOfWordInKeyphrase = 0;\n\t// Initialize the index of the word token of the sentence.\n\tlet indexOfWordInSentence = 0;\n\tlet currentMatch = [];\n\n\t// Check if the tokenized word forms occur in the same order in the sentence tokens.\n\twhile ( indexOfWordInSentence < sentenceTokens.length ) {\n\t\t// If the current sentence token matches the current word token of the keyphrase, add it to the current match.\n\t\tconst sentenceTokenText = sentenceTokens[ indexOfWordInSentence ].text;\n\t\tconst keyphraseTokenText = keyphraseTokens[ indexOfWordInKeyphrase ];\n\n\t\tconst foundMatches = matchTextWithTransliteration( sentenceTokenText.toLowerCase(), keyphraseTokenText.toLowerCase(), locale );\n\n\t\tif ( foundMatches.length > 0 ) {\n\t\t\tcurrentMatch.push( sentenceTokens[ indexOfWordInSentence ] );\n\t\t\tindexOfWordInKeyphrase++;\n\t\t} else {\n\t\t\tindexOfWordInKeyphrase = 0;\n\t\t\tcurrentMatch = [];\n\t\t}\n\n\t\t/*\n\t\t * If the current match has the same length as the keyphrase tokens, the keyphrase forms have been matched.\n\t\t * Add the current match to the matches array and reset the index of the word in keyphrase and the current match.\n\t\t */\n\t\tif ( currentMatch.length === keyphraseTokens.length ) {\n\t\t\tresult.matches.push( ...currentMatch );\n\t\t\tresult.count++;\n\t\t\tindexOfWordInKeyphrase = 0;\n\t\t\tcurrentMatch = [];\n\t\t}\n\n\t\tindexOfWordInSentence++;\n\t}\n\treturn 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\tlet matches = [];\n\n\ttokens.forEach( token => {\n\t\tconst occurrence = matchTextWithTransliteration( token.text, wordForm, locale );\n\t\tif ( occurrence.length > 0 ) {\n\t\t\tmatches = matches.concat( token );\n\t\t}\n\t} );\n\n\treturn 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\tconst result = {\n\t\tcount: 0,\n\t\tmatches: [],\n\t};\n\n\twordForms.forEach( wordForm => {\n\t\tlet occurrences = [];\n\t\tif ( matchWordCustomHelper ) {\n\t\t\toccurrences = matchWordCustomHelper( sentence, wordForm );\n\t\t} else {\n\t\t\tconst tokens = sentence.tokens.slice();\n\t\t\toccurrences = matchWordFormInTokens( tokens, wordForm, locale );\n\t\t}\n\t\tresult.count += occurrences.length;\n\t\tresult.matches = result.matches.concat( occurrences );\n\t} );\n\n\treturn 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 = ( sentence, wordForms, locale, matchWordCustomHelper, useExactMatching = false, customSplitIntoTokensHelper ) => {\n\t/*\n\t * Only use `findExactMatchKeyphraseInSentence` when the custom helper is not available.\n\t * When the custom helper is available, the step for the exact matching happens in the helper.\n\t */\n\tif ( useExactMatching && ! matchWordCustomHelper ) {\n\t\treturn findExactMatchKeyphraseInSentence( sentence, wordForms, locale, customSplitIntoTokensHelper );\n\t}\n\treturn matchWordFormsInSentence( sentence, wordForms, locale, matchWordCustomHelper );\n};\n\nexport default matchWordFormsWithSentence;\n"],"mappings":"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","ignoreList":[]}

package/build/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/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/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/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/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/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/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/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 \"../../../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

@@ -0,0 +1,48 @@
+"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.
+ *
+ * @param {Array}   rule        A pair or triplet of strings of which the first one is the regex to match
+ *                              and the second (and the third) is the replacement.
+ * @param {string}  [flags=i]   The regex flags to use.
+ *
+ * @returns {{ reg: RegExp, repl: string }|{ reg: RegExp, repl1: string, repl2: string }|null} Object to be used in the regex-based rules.
+ */
+const createSingleRuleFromArray = function (rule, flags = "i") {
+  if (rule.length === 2) {
+    return {
+      reg: new RegExp(rule[0], flags),
+      repl: rule[1]
+    };
+  }
+  if (rule.length === 3) {
+    return {
+      reg: new RegExp(rule[0], flags),
+      repl1: rule[1],
+      repl2: rule[2]
+    };
+  }
+  return null;
+};
+
+/**
+ * Creates an array of objects with a regex and a replacement pair to be processed.
+ *
+ * @param {Array}   rules       An array with pairs or triplets of strings of which the first one is the regex to match
+ *                              and the second (and the third) is the replacement.
+ * @param {string} [flags=i]    The regex flags to use.
+ *
+ * @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;
+//# sourceMappingURL=createRulesFromArrays.js.map

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+
+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.
+ *
+ * @param {string}	    word            The word to check.
+ * @param {string[]}	exceptionList	The list of exceptions.
+ *
+ * @returns {boolean}	Whether the checked word ends in one of the words in the exception list.
+ */
+function checkIfWordEndingIsOnExceptionList(word, exceptionList) {
+  for (let i = 0; i < exceptionList.length; i++) {
+    if (word.endsWith(exceptionList[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 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
+ * and if it does, removes it.
+ *
+ * @param {string}	 	word					The word to check.
+ * @param {string[]}	exceptionList			The list of exceptions.
+ * @param {Object}		prefixesObject	        An Object that contains the arrays of prefixes.
+ *
+ * @returns {boolean}	Whether the word was found on the exception list or not.
+ */
+function checkIfWordIsOnListThatCanHavePrefix(word, exceptionList, prefixesObject) {
+  const prefixes = (0, _flattenSortLength.default)(prefixesObject);
+
+  // Check whether the inputted word starts with one of the prefixes
+  const foundPrefix = prefixes.find(prefix => word.startsWith(prefix));
+  let stemmedWordWithoutPrefix = "";
+  if (typeof foundPrefix === "string") {
+    stemmedWordWithoutPrefix = word.slice(foundPrefix.length);
+    // 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".
+    if (stemmedWordWithoutPrefix.length > 2) {
+      word = stemmedWordWithoutPrefix;
+    }
+  }
+  return exceptionList.includes(word);
+}
+
+/**
+ * Checks whether the word ends in one of the words in an exception list with two stems.
+ *
+ * @param {Array} exceptionListWithTwoStems The exception list with two stems.
+ * @param {string} word	The word to check.
+ *
+ * @returns {string} The stem.
+ */
+function checkExceptionListWithTwoStems(exceptionListWithTwoStems, word) {
+  for (const stemSet of exceptionListWithTwoStems) {
+    const foundStem = stemSet.find(stemWord => word.endsWith(stemWord));
+    if (foundStem) {
+      const precedingLexicalMaterial = word.slice(0, word.length - foundStem.length);
+      return precedingLexicalMaterial + stemSet[0];
+    }
+  }
+}
+//# sourceMappingURL=exceptionListHelpers.js.map

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

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

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

@@ -0,0 +1,29 @@
+"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.
+ *
+ * @param {string}      string       The string to check.
+ * @param {string[]}    endings    The word endings to check.
+ * @returns {string}    The longest matched ending.
+ */
+function findMatchingEndingInArray(string, endings) {
+  const matches = [];
+  for (const i in endings) {
+    if (string.endsWith(endings[i])) {
+      matches.push(endings[i]);
+    }
+  }
+  const longest = matches.sort(function (a, b) {
+    return b.length - a.length;
+  })[0];
+  if (longest) {
+    return longest;
+  }
+  return "";
+}
+//# sourceMappingURL=findMatchingEndingInArray.js.map