axyseo 2.1.12 → 2.1.19

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = require("lodash");
+var _createRegexFromArray = _interopRequireDefault(require("../../../regex/createRegexFromArray.js"));
+var _getIndicesWithRegex = _interopRequireDefault(require("../getIndicesWithRegex.js"));
+var _indices = require("../../../word/indices.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Checks whether there are any exception words in between the auxiliary and participle. If there are, it doesn't return a passive.
+ *
+ * @param {string} clause 											The clause that contains the participle.
+ * @param {string} participle 										The participle in the clause.
+ * @param {string[]} auxiliaries 									One or more auxiliaries in the clause.
+ * @param {string[]} cannotBeBetweenPassiveAuxiliaryAndParticiple 	The list of words that cannot be between the auxiliary and participle.
+ *
+ * @returns {boolean} Returns true if a word from the 'cannot be between passive auxiliary and participle' exception list
+ * appears anywhere in between the last (closest to participle) auxiliary and the participle.
+ */
+function _default(clause, participle, auxiliaries, cannotBeBetweenPassiveAuxiliaryAndParticiple) {
+  const auxiliariesUnique = (0, _lodash.uniq)(auxiliaries);
+  const auxiliaryIndices = (0, _indices.getIndicesByWordListSorted)(auxiliariesUnique, clause);
+  const participleIndex = clause.indexOf(participle);
+  const nonDirectParticiplePrecendenceExceptionRegex = (0, _createRegexFromArray.default)(cannotBeBetweenPassiveAuxiliaryAndParticiple);
+
+  // This exception is only applicable for passive constructions in which the auxiliary precedes the participle.
+  const matches = auxiliaryIndices.filter(auxiliaryIndex => auxiliaryIndex.index < participleIndex);
+
+  // If there are no auxiliaries before the participle, this exception is not applicable.
+  if (matches.length === 0) {
+    return false;
+  }
+
+  // We pick the auxiliary closest to the participle, since that is most likely the one belonging to the participle.
+  const participleAuxiliary = matches[matches.length - 1];
+  const precedenceExceptionIndices = (0, _getIndicesWithRegex.default)(clause, nonDirectParticiplePrecendenceExceptionRegex);
+
+  // Check whether there are any precendence words between the auxiliary and the participle.
+  const remainingPrecedenceExceptionIndices = precedenceExceptionIndices.filter(precedenceExceptionIndex => precedenceExceptionIndex.index > participleAuxiliary.index && precedenceExceptionIndex.index < participleIndex);
+  return remainingPrecedenceExceptionIndices.length > 0;
+}
+//# sourceMappingURL=nonDirectParticiplePrecedenceException.js.map

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonDirectParticiplePrecedenceException.js","names":["_lodash","require","_createRegexFromArray","_interopRequireDefault","_getIndicesWithRegex","_indices","e","__esModule","default","_default","clause","participle","auxiliaries","cannotBeBetweenPassiveAuxiliaryAndParticiple","auxiliariesUnique","uniq","auxiliaryIndices","getIndicesByWordListSorted","participleIndex","indexOf","nonDirectParticiplePrecendenceExceptionRegex","arrayToRegex","matches","filter","auxiliaryIndex","index","length","participleAuxiliary","precedenceExceptionIndices","getWordIndices","remainingPrecedenceExceptionIndices","precedenceExceptionIndex"],"sources":["../../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js"],"sourcesContent":["import { uniq } from \"lodash\";\n\nimport arrayToRegex from \"../../../regex/createRegexFromArray.js\";\nimport getWordIndices from \"../getIndicesWithRegex.js\";\n\nimport { getIndicesByWordListSorted } from \"../../../word/indices.js\";\n\n/**\n * Checks whether there are any exception words in between the auxiliary and participle. If there are, it doesn't return a passive.\n *\n * @param {string} clause \t\t\t\t\t\t\t\t\t\t\tThe clause that contains the participle.\n * @param {string} participle \t\t\t\t\t\t\t\t\t\tThe participle in the clause.\n * @param {string[]} auxiliaries \t\t\t\t\t\t\t\t\tOne or more auxiliaries in the clause.\n * @param {string[]} cannotBeBetweenPassiveAuxiliaryAndParticiple \tThe list of words that cannot be between the auxiliary and participle.\n *\n * @returns {boolean} Returns true if a word from the 'cannot be between passive auxiliary and participle' exception list\n * appears anywhere in between the last (closest to participle) auxiliary and the participle.\n */\nexport default function( clause, participle, auxiliaries, cannotBeBetweenPassiveAuxiliaryAndParticiple ) {\n\tconst auxiliariesUnique = uniq( auxiliaries );\n\n\tconst auxiliaryIndices = getIndicesByWordListSorted( auxiliariesUnique, clause );\n\n\tconst participleIndex = clause.indexOf( participle );\n\tconst nonDirectParticiplePrecendenceExceptionRegex = arrayToRegex( cannotBeBetweenPassiveAuxiliaryAndParticiple );\n\n\t// This exception is only applicable for passive constructions in which the auxiliary precedes the participle.\n\tconst matches = auxiliaryIndices.filter( auxiliaryIndex => auxiliaryIndex.index < participleIndex );\n\n\t// If there are no auxiliaries before the participle, this exception is not applicable.\n\tif ( matches.length === 0 ) {\n\t\treturn false;\n\t}\n\n\t// We pick the auxiliary closest to the participle, since that is most likely the one belonging to the participle.\n\tconst participleAuxiliary = matches[ matches.length - 1 ];\n\n\tconst precedenceExceptionIndices = getWordIndices( clause, nonDirectParticiplePrecendenceExceptionRegex );\n\n\t// Check whether there are any precendence words between the auxiliary and the participle.\n\tconst remainingPrecedenceExceptionIndices = precedenceExceptionIndices.filter( precedenceExceptionIndex =>\n\t\t( precedenceExceptionIndex.index > participleAuxiliary.index && precedenceExceptionIndex.index < participleIndex ) );\n\n\treturn remainingPrecedenceExceptionIndices.length > 0;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,qBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,oBAAA,GAAAD,sBAAA,CAAAF,OAAA;AAEA,IAAAI,QAAA,GAAAJ,OAAA;AAAsE,SAAAE,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAG,SAAUC,MAAM,EAAEC,UAAU,EAAEC,WAAW,EAAEC,4CAA4C,EAAG;EACxG,MAAMC,iBAAiB,GAAG,IAAAC,YAAI,EAAEH,WAAY,CAAC;EAE7C,MAAMI,gBAAgB,GAAG,IAAAC,mCAA0B,EAAEH,iBAAiB,EAAEJ,MAAO,CAAC;EAEhF,MAAMQ,eAAe,GAAGR,MAAM,CAACS,OAAO,CAAER,UAAW,CAAC;EACpD,MAAMS,4CAA4C,GAAG,IAAAC,6BAAY,EAAER,4CAA6C,CAAC;;EAEjH;EACA,MAAMS,OAAO,GAAGN,gBAAgB,CAACO,MAAM,CAAEC,cAAc,IAAIA,cAAc,CAACC,KAAK,GAAGP,eAAgB,CAAC;;EAEnG;EACA,IAAKI,OAAO,CAACI,MAAM,KAAK,CAAC,EAAG;IAC3B,OAAO,KAAK;EACb;;EAEA;EACA,MAAMC,mBAAmB,GAAGL,OAAO,CAAEA,OAAO,CAACI,MAAM,GAAG,CAAC,CAAE;EAEzD,MAAME,0BAA0B,GAAG,IAAAC,4BAAc,EAAEnB,MAAM,EAAEU,4CAA6C,CAAC;;EAEzG;EACA,MAAMU,mCAAmC,GAAGF,0BAA0B,CAACL,MAAM,CAAEQ,wBAAwB,IACpGA,wBAAwB,CAACN,KAAK,GAAGE,mBAAmB,CAACF,KAAK,IAAIM,wBAAwB,CAACN,KAAK,GAAGP,eAAkB,CAAC;EAErH,OAAOY,mCAAmC,CAACJ,MAAM,GAAG,CAAC;AACtD","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/getClauses.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _indices = require("../../word/indices");
+var _stripSpaces = _interopRequireDefault(require("../../sanitize/stripSpaces.js"));
+var _quotes = require("../../sanitize/quotes.js");
+var _getIndicesWithRegex = _interopRequireDefault(require("./getIndicesWithRegex.js"));
+var _includesIndex = _interopRequireDefault(require("../../word/includesIndex"));
+var _followsIndex = _interopRequireDefault(require("../../word/followsIndex"));
+var _lodash = require("lodash");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Gets stop characters to determine sentence breakers.
+ *
+ * @param {string} sentence The sentence to get the stop characters from.
+ * @param {RegExp} stopCharacterRegex Regex to match the stop characters.
+ *
+ * @returns {Array} The array with stop characters.
+ */
+const getStopCharacters = function (sentence, stopCharacterRegex) {
+  let match;
+  const matches = [];
+  stopCharacterRegex.lastIndex = 0;
+  while ((match = stopCharacterRegex.exec(sentence)) !== null) {
+    matches.push({
+      index: match.index,
+      match: match[0]
+    });
+  }
+  return matches;
+};
+
+/**
+ * Filters auxiliaries preceded by a reflexive pronoun.
+ *
+ * @param {string} text The text part in which to check.
+ * @param {Array} auxiliaryMatches The auxiliary matches for which to check.
+ * @param {RegExp} directPrecedenceExceptionRegex The regex needed to find the right auxiliaries.
+ *
+ * @returns {Array} The filtered list of auxiliary indices.
+ */
+const auxiliaryPrecedenceExceptionFilter = function (text, auxiliaryMatches, directPrecedenceExceptionRegex) {
+  const directPrecedenceExceptionMatches = (0, _getIndicesWithRegex.default)(text, directPrecedenceExceptionRegex);
+  (0, _lodash.forEach)(auxiliaryMatches, function (auxiliaryMatch) {
+    if ((0, _includesIndex.default)(directPrecedenceExceptionMatches, auxiliaryMatch.index)) {
+      auxiliaryMatches = auxiliaryMatches.filter(function (auxiliaryObject) {
+        return auxiliaryObject.index !== auxiliaryMatch.index;
+      });
+    }
+  });
+  return auxiliaryMatches;
+};
+
+/**
+ * Filters auxiliaries followed by a word on the followingAuxiliaryExceptionWords list.
+ *
+ * @param {string} text The text part in which to check.
+ * @param {Array} auxiliaryMatches The auxiliary matches for which to check.
+ * @param {RegExp} followingAuxiliaryExceptionRegex The regex needed to find the right auxiliaries.
+ *
+ * @returns {Array} The filtered list of auxiliary indices.
+ */
+const followingAuxiliaryExceptionFilter = function (text, auxiliaryMatches, followingAuxiliaryExceptionRegex) {
+  const followingAuxiliaryExceptionMatches = (0, _getIndicesWithRegex.default)(text, followingAuxiliaryExceptionRegex);
+  (0, _lodash.forEach)(auxiliaryMatches, function (auxiliaryMatch) {
+    if ((0, _followsIndex.default)(followingAuxiliaryExceptionMatches, auxiliaryMatch)) {
+      auxiliaryMatches = auxiliaryMatches.filter(function (auxiliaryObject) {
+        return auxiliaryObject.index !== auxiliaryMatch.index;
+      });
+    }
+  });
+  return auxiliaryMatches;
+};
+
+/**
+ * Filters auxiliaries preceded by an elided word (e.g., s') on the elisionAuxiliaryExceptionWords list.
+ *
+ * @param {string} text The text part in which to check.
+ * @param {Array} auxiliaryMatches The auxiliary matches for which to check.
+ * @param {RegExp} elisionAuxiliaryExceptionRegex Regex to match the elisionAuxiliary exception.
+ *
+ * @returns {Array} The filtered list of auxiliary indices.
+ */
+const elisionAuxiliaryExceptionFilter = function (text, auxiliaryMatches, elisionAuxiliaryExceptionRegex) {
+  const elisionAuxiliaryExceptionMatches = (0, _getIndicesWithRegex.default)(text, elisionAuxiliaryExceptionRegex);
+  (0, _lodash.forEach)(auxiliaryMatches, function (auxiliaryMatch) {
+    if ((0, _includesIndex.default)(elisionAuxiliaryExceptionMatches, auxiliaryMatch.index, false)) {
+      auxiliaryMatches = auxiliaryMatches.filter(function (auxiliaryObject) {
+        return auxiliaryObject.index !== auxiliaryMatch.index;
+      });
+    }
+  });
+  return auxiliaryMatches;
+};
+
+/**
+ * Gets the indices of sentence breakers (auxiliaries, stopwords and stop characters;
+ * in English also active verbs) to determine clauses.
+ * Indices are filtered because there could be duplicate matches, like "even though" and "though".
+ * In addition, 'having' will be matched both as a -ing verb as well as an auxiliary.
+ *
+ * @param {string} sentence The sentence to check for indices of sentence breakers.
+ * @param {Object} options The language options for which to match the sentence breakers.
+ *
+ * @returns {Array} The array with valid indices to use for determining clauses.
+ */
+const getSentenceBreakers = function (sentence, options) {
+  sentence = sentence.toLocaleLowerCase();
+  const {
+    regexes
+  } = options;
+  let auxiliaryIndices = (0, _indices.getIndicesByWordList)(options.auxiliaries, sentence);
+  const stopCharacterIndices = getStopCharacters(sentence, regexes.stopCharacterRegex);
+  let stopwordIndices = (0, _indices.getIndicesByWordList)(options.stopwords, sentence);
+
+  // Check in options if there are other stopword indices created based on language-specific rules.
+  if (options.otherStopWordIndices && options.otherStopWordIndices.length > 0) {
+    stopwordIndices = stopwordIndices.concat(options.otherStopWordIndices);
+  }
+  if (typeof regexes.directPrecedenceExceptionRegex !== "undefined") {
+    // Filters auxiliaries matched in the sentence based on a precedence exception filter.
+    auxiliaryIndices = auxiliaryPrecedenceExceptionFilter(sentence, auxiliaryIndices, regexes.directPrecedenceExceptionRegex);
+  }
+  if (typeof regexes.elisionAuxiliaryExceptionRegex !== "undefined") {
+    // Filters auxiliaries matched in the sentence based on a elision exception filter.
+    auxiliaryIndices = elisionAuxiliaryExceptionFilter(sentence, auxiliaryIndices, regexes.elisionAuxiliaryExceptionRegex);
+  }
+  let totalIndices = auxiliaryIndices.concat(stopwordIndices, stopCharacterIndices);
+  totalIndices = (0, _indices.filterIndices)(totalIndices);
+  return (0, _indices.sortIndices)(totalIndices);
+};
+
+/**
+ * Gets the auxiliaries from a sentence.
+ *
+ * @param {string} sentencePart The part of the sentence to match for auxiliaries.
+ * @param {object} regexes The regexes needed to find the auxiliaries.
+ *
+ * @returns {Array} All formatted matches from the sentence part.
+ */
+const getAuxiliaryMatches = function (sentencePart, regexes) {
+  const {
+    auxiliaryRegex,
+    directPrecedenceExceptionRegex,
+    followingAuxiliaryExceptionRegex
+  } = regexes;
+  let auxiliaryMatches = sentencePart.match(auxiliaryRegex) || [];
+  if (typeof directPrecedenceExceptionRegex !== "undefined" || typeof followingAuxiliaryExceptionRegex !== "undefined") {
+    // An array with the matched auxiliaries and their indices.
+    let auxiliaryMatchIndices = (0, _indices.getIndicesByWordList)(auxiliaryMatches, sentencePart);
+    if (typeof directPrecedenceExceptionRegex !== "undefined") {
+      // Filters auxiliaries matched in the sentence part based on a precedence exception filter.
+      auxiliaryMatchIndices = auxiliaryPrecedenceExceptionFilter(sentencePart, auxiliaryMatchIndices, directPrecedenceExceptionRegex);
+    }
+    // Filters auxiliaries matched in the sentence part based on a exception filter for words following the auxiliary.
+    auxiliaryMatchIndices = followingAuxiliaryExceptionFilter(sentencePart, auxiliaryMatchIndices, followingAuxiliaryExceptionRegex);
+
+    // An array with the matched auxiliary verbs (without indices).
+    auxiliaryMatches = [];
+    (0, _lodash.forEach)(auxiliaryMatchIndices, function (auxiliaryMatchIndex) {
+      auxiliaryMatches.push(auxiliaryMatchIndex.match);
+    });
+  }
+  return (0, _lodash.map)(auxiliaryMatches, function (auxiliaryMatch) {
+    return (0, _stripSpaces.default)(auxiliaryMatch);
+  });
+};
+
+/**
+ * Gets the clauses from a sentence by determining sentence breakers.
+ *
+ * @param {string} sentence The sentence to split up into clauses.
+ * @param {object} options The language options for which to get the clauses.
+ *
+ * @returns {Array} The array with all clauses that have an auxiliary.
+ */
+const getClauses = function (sentence, options) {
+  const clauses = [];
+  const auxiliaryRegex = options.regexes.auxiliaryRegex;
+  sentence = (0, _quotes.normalizeSingle)(sentence);
+
+  // First check if there is an auxiliary in the sentence.
+  if (sentence.match(auxiliaryRegex) === null) {
+    return clauses;
+  }
+  const indices = getSentenceBreakers(sentence, options);
+  // Get the words after the found auxiliary.
+  for (let i = 0; i < indices.length; i++) {
+    let endIndex = sentence.length;
+    if (!(0, _lodash.isUndefined)(indices[i + 1])) {
+      endIndex = indices[i + 1].index;
+    }
+
+    // Cut the sentence from the current index to the endIndex (start of next breaker, of end of sentence).
+    const clause = (0, _stripSpaces.default)(sentence.substring(indices[i].index, endIndex));
+    const auxiliaryMatches = getAuxiliaryMatches(clause, options.regexes);
+    // If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.
+    if (auxiliaryMatches.length !== 0) {
+      const foundClause = new options.Clause(clause, auxiliaryMatches);
+      clauses.push(foundClause);
+    }
+  }
+  return clauses;
+};
+
+/**
+ * Split the sentence into clauses based on auxiliaries.
+ *
+ * @param {string} sentence The sentence to split in parts.
+ * @param {Object} options The language options for which to get the clauses.
+ *
+ * @returns {Array} A list with clauses.
+ */
+function _default(sentence, options) {
+  return getClauses(sentence, options);
+}
+//# sourceMappingURL=getClauses.js.map

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/getClauses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClauses.js","names":["_indices","require","_stripSpaces","_interopRequireDefault","_quotes","_getIndicesWithRegex","_includesIndex","_followsIndex","_lodash","e","__esModule","default","getStopCharacters","sentence","stopCharacterRegex","match","matches","lastIndex","exec","push","index","auxiliaryPrecedenceExceptionFilter","text","auxiliaryMatches","directPrecedenceExceptionRegex","directPrecedenceExceptionMatches","getWordIndices","forEach","auxiliaryMatch","includesIndex","filter","auxiliaryObject","followingAuxiliaryExceptionFilter","followingAuxiliaryExceptionRegex","followingAuxiliaryExceptionMatches","followsIndex","elisionAuxiliaryExceptionFilter","elisionAuxiliaryExceptionRegex","elisionAuxiliaryExceptionMatches","getSentenceBreakers","options","toLocaleLowerCase","regexes","auxiliaryIndices","getIndicesOfList","auxiliaries","stopCharacterIndices","stopwordIndices","stopwords","otherStopWordIndices","length","concat","totalIndices","filterIndices","sortIndices","getAuxiliaryMatches","sentencePart","auxiliaryRegex","auxiliaryMatchIndices","auxiliaryMatchIndex","map","stripSpaces","getClauses","clauses","normalizeSingleQuotes","indices","i","endIndex","isUndefined","clause","substring","foundClause","Clause","_default"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/getClauses.js"],"sourcesContent":["import { getIndicesByWordList as getIndicesOfList, filterIndices, sortIndices } from \"../../word/indices\";\nimport stripSpaces from \"../../sanitize/stripSpaces.js\";\nimport { normalizeSingle as normalizeSingleQuotes } from \"../../sanitize/quotes.js\";\nimport getWordIndices from \"./getIndicesWithRegex.js\";\nimport includesIndex from \"../../word/includesIndex\";\nimport followsIndex from \"../../word/followsIndex\";\n\nimport { forEach, isUndefined, map } from \"lodash\";\n\n/**\n * Gets stop characters to determine sentence breakers.\n *\n * @param {string} sentence The sentence to get the stop characters from.\n * @param {RegExp} stopCharacterRegex Regex to match the stop characters.\n *\n * @returns {Array} The array with stop characters.\n */\nconst getStopCharacters = function( sentence, stopCharacterRegex ) {\n\tlet match;\n\tconst matches = [];\n\n\tstopCharacterRegex.lastIndex = 0;\n\n\twhile ( ( match = stopCharacterRegex.exec( sentence ) ) !== null ) {\n\t\tmatches.push(\n\t\t\t{\n\t\t\t\tindex: match.index,\n\t\t\t\tmatch: match[ 0 ],\n\t\t\t}\n\t\t);\n\t}\n\treturn matches;\n};\n\n/**\n * Filters auxiliaries preceded by a reflexive pronoun.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} directPrecedenceExceptionRegex The regex needed to find the right auxiliaries.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst auxiliaryPrecedenceExceptionFilter = function( text, auxiliaryMatches, directPrecedenceExceptionRegex ) {\n\tconst directPrecedenceExceptionMatches = getWordIndices( text, directPrecedenceExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( includesIndex( directPrecedenceExceptionMatches, auxiliaryMatch.index ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Filters auxiliaries followed by a word on the followingAuxiliaryExceptionWords list.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} followingAuxiliaryExceptionRegex The regex needed to find the right auxiliaries.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst followingAuxiliaryExceptionFilter = function( text, auxiliaryMatches, followingAuxiliaryExceptionRegex ) {\n\tconst followingAuxiliaryExceptionMatches = getWordIndices( text, followingAuxiliaryExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( followsIndex( followingAuxiliaryExceptionMatches, auxiliaryMatch ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Filters auxiliaries preceded by an elided word (e.g., s') on the elisionAuxiliaryExceptionWords list.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} elisionAuxiliaryExceptionRegex Regex to match the elisionAuxiliary exception.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst elisionAuxiliaryExceptionFilter = function( text, auxiliaryMatches, elisionAuxiliaryExceptionRegex ) {\n\tconst elisionAuxiliaryExceptionMatches = getWordIndices( text, elisionAuxiliaryExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( includesIndex( elisionAuxiliaryExceptionMatches, auxiliaryMatch.index, false ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Gets the indices of sentence breakers (auxiliaries, stopwords and stop characters;\n * in English also active verbs) to determine clauses.\n * Indices are filtered because there could be duplicate matches, like \"even though\" and \"though\".\n * In addition, 'having' will be matched both as a -ing verb as well as an auxiliary.\n *\n * @param {string} sentence The sentence to check for indices of sentence breakers.\n * @param {Object} options The language options for which to match the sentence breakers.\n *\n * @returns {Array} The array with valid indices to use for determining clauses.\n */\nconst getSentenceBreakers = function( sentence, options ) {\n\tsentence = sentence.toLocaleLowerCase();\n\tconst { regexes } = options;\n\tlet auxiliaryIndices = getIndicesOfList( options.auxiliaries, sentence );\n\tconst stopCharacterIndices = getStopCharacters( sentence, regexes.stopCharacterRegex );\n\tlet stopwordIndices = getIndicesOfList( options.stopwords, sentence );\n\n\t// Check in options if there are other stopword indices created based on language-specific rules.\n\tif ( options.otherStopWordIndices && options.otherStopWordIndices.length > 0 ) {\n\t\tstopwordIndices = stopwordIndices.concat( options.otherStopWordIndices );\n\t}\n\n\tif ( typeof regexes.directPrecedenceExceptionRegex !== \"undefined\" ) {\n\t\t// Filters auxiliaries matched in the sentence based on a precedence exception filter.\n\t\tauxiliaryIndices = auxiliaryPrecedenceExceptionFilter( sentence, auxiliaryIndices, regexes.directPrecedenceExceptionRegex );\n\t}\n\n\tif ( typeof regexes.elisionAuxiliaryExceptionRegex !== \"undefined\" ) {\n\t\t// Filters auxiliaries matched in the sentence based on a elision exception filter.\n\t\tauxiliaryIndices = elisionAuxiliaryExceptionFilter( sentence, auxiliaryIndices, regexes.elisionAuxiliaryExceptionRegex );\n\t}\n\n\tlet totalIndices = auxiliaryIndices.concat( stopwordIndices, stopCharacterIndices );\n\n\ttotalIndices = filterIndices( totalIndices );\n\n\treturn sortIndices( totalIndices );\n};\n\n/**\n * Gets the auxiliaries from a sentence.\n *\n * @param {string} sentencePart The part of the sentence to match for auxiliaries.\n * @param {object} regexes The regexes needed to find the auxiliaries.\n *\n * @returns {Array} All formatted matches from the sentence part.\n */\nconst getAuxiliaryMatches = function( sentencePart, regexes ) {\n\tconst { auxiliaryRegex, directPrecedenceExceptionRegex, followingAuxiliaryExceptionRegex } = regexes;\n\tlet auxiliaryMatches = sentencePart.match( auxiliaryRegex ) || [];\n\n\tif ( typeof directPrecedenceExceptionRegex !== \"undefined\" || typeof followingAuxiliaryExceptionRegex !== \"undefined\" ) {\n\t\t// An array with the matched auxiliaries and their indices.\n\t\tlet auxiliaryMatchIndices = getIndicesOfList( auxiliaryMatches, sentencePart );\n\n\t\tif ( typeof directPrecedenceExceptionRegex !== \"undefined\" ) {\n\t\t\t// Filters auxiliaries matched in the sentence part based on a precedence exception filter.\n\t\t\tauxiliaryMatchIndices = auxiliaryPrecedenceExceptionFilter( sentencePart, auxiliaryMatchIndices, directPrecedenceExceptionRegex );\n\t\t}\n\t\t// Filters auxiliaries matched in the sentence part based on a exception filter for words following the auxiliary.\n\t\tauxiliaryMatchIndices = followingAuxiliaryExceptionFilter( sentencePart, auxiliaryMatchIndices, followingAuxiliaryExceptionRegex );\n\n\t\t// An array with the matched auxiliary verbs (without indices).\n\t\tauxiliaryMatches = [];\n\n\t\tforEach( auxiliaryMatchIndices, function( auxiliaryMatchIndex ) {\n\t\t\tauxiliaryMatches.push( auxiliaryMatchIndex.match );\n\t\t} );\n\t}\n\n\treturn map( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\treturn stripSpaces( auxiliaryMatch );\n\t} );\n};\n\n/**\n * Gets the clauses from a sentence by determining sentence breakers.\n *\n * @param {string} sentence The sentence to split up into clauses.\n * @param {object} options The language options for which to get the clauses.\n *\n * @returns {Array} The array with all clauses that have an auxiliary.\n */\nconst getClauses = function( sentence, options ) {\n\tconst clauses = [];\n\tconst auxiliaryRegex = options.regexes.auxiliaryRegex;\n\n\tsentence = normalizeSingleQuotes( sentence );\n\n\t// First check if there is an auxiliary in the sentence.\n\tif ( sentence.match( auxiliaryRegex ) === null ) {\n\t\treturn clauses;\n\t}\n\n\tconst indices = getSentenceBreakers( sentence, options );\n\t// Get the words after the found auxiliary.\n\tfor ( let i = 0; i < indices.length; i++ ) {\n\t\tlet endIndex = sentence.length;\n\t\tif ( ! isUndefined( indices[ i + 1 ] ) ) {\n\t\t\tendIndex = indices[ i + 1 ].index;\n\t\t}\n\n\t\t// Cut the sentence from the current index to the endIndex (start of next breaker, of end of sentence).\n\t\tconst clause = stripSpaces( sentence.substring( indices[ i ].index, endIndex ) );\n\n\t\tconst auxiliaryMatches = getAuxiliaryMatches( clause, options.regexes );\n\t\t// If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.\n\t\tif ( auxiliaryMatches.length !== 0 ) {\n\t\t\tconst foundClause = new options.Clause( clause, auxiliaryMatches );\n\t\t\tclauses.push( foundClause );\n\t\t}\n\t}\n\n\treturn clauses;\n};\n\n/**\n * Split the sentence into clauses based on auxiliaries.\n *\n * @param {string} sentence The sentence to split in parts.\n * @param {Object} options The language options for which to get the clauses.\n *\n * @returns {Array} A list with clauses.\n */\nexport default function( sentence, options ) {\n\treturn getClauses( sentence, options );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/getIndicesWithRegex.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+/**
+ * Matches words from a list in sentence parts and returns them and their indices.
+ *
+ * @param {string} sentencePart The sentence part to match the words in.
+ * @param {RegExp} regex The regex used for matching.
+ * @returns {Array} The list of result objects.
+ */
+function _default(sentencePart, regex) {
+  const results = [];
+  /* Decided to use a for loop here so that we could retrieve all matches while keeping result objects intact.
+  For every match there is in the sentence part, an object with the match and its index will be pushed into
+  the results array. */
+  for (let match = regex.exec(sentencePart); match !== null; match = regex.exec(sentencePart)) {
+    results.push({
+      match: match[0],
+      index: match.index
+    });
+  }
+  return results;
+}
+//# sourceMappingURL=getIndicesWithRegex.js.map

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/getIndicesWithRegex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIndicesWithRegex.js","names":["_default","sentencePart","regex","results","match","exec","push","index"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/getIndicesWithRegex.js"],"sourcesContent":["/**\n * Matches words from a list in sentence parts and returns them and their indices.\n *\n * @param {string} sentencePart The sentence part to match the words in.\n * @param {RegExp} regex The regex used for matching.\n * @returns {Array} The list of result objects.\n */\nexport default function( sentencePart, regex ) {\n\tconst results = [];\n\t/* Decided to use a for loop here so that we could retrieve all matches while keeping result objects intact.\n\tFor every match there is in the sentence part, an object with the match and its index will be pushed into\n\tthe results array. */\n\tfor ( let match = regex.exec( sentencePart ); match !== null; match = regex.exec( sentencePart ) ) {\n\t\tresults.push( {\n\t\t\tmatch: match[ 0 ],\n\t\t\tindex: match.index,\n\t\t} );\n\t}\n\treturn results;\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAA,SAAUC,YAAY,EAAEC,KAAK,EAAG;EAC9C,MAAMC,OAAO,GAAG,EAAE;EAClB;AACD;AACA;EACC,KAAM,IAAIC,KAAK,GAAGF,KAAK,CAACG,IAAI,CAAEJ,YAAa,CAAC,EAAEG,KAAK,KAAK,IAAI,EAAEA,KAAK,GAAGF,KAAK,CAACG,IAAI,CAAEJ,YAAa,CAAC,EAAG;IAClGE,OAAO,CAACG,IAAI,CAAE;MACbF,KAAK,EAAEA,KAAK,CAAE,CAAC,CAAE;MACjBG,KAAK,EAAEH,KAAK,CAACG;IACd,CAAE,CAAC;EACJ;EACA,OAAOJ,OAAO;AACf","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/matchRegularParticiples.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = regularParticiples;
+var _lodash = require("lodash");
+/**
+ * Returns words that have been determined to be a regular participle.
+ *
+ * @param {string} word         The word to check.
+ * @param {RegExp[]} regexes    The regular participle regexes to match.
+ *
+ * @returns {Array} A list with the matches.
+ */
+function regularParticiples(word, regexes) {
+  // Matches word with language-specific participle regexes.
+  let matches = [];
+  regexes.forEach(function (regex) {
+    const match = word.match(regex);
+    if (match !== null) {
+      matches.push(match);
+    }
+  });
+  matches = (0, _lodash.flattenDeep)(matches);
+  return matches;
+}
+//# sourceMappingURL=matchRegularParticiples.js.map

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/matchRegularParticiples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchRegularParticiples.js","names":["_lodash","require","regularParticiples","word","regexes","matches","forEach","regex","match","push","flattenDeep"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/matchRegularParticiples.js"],"sourcesContent":["import { flattenDeep } from \"lodash\";\n\n/**\n * Returns words that have been determined to be a regular participle.\n *\n * @param {string} word         The word to check.\n * @param {RegExp[]} regexes    The regular participle regexes to match.\n *\n * @returns {Array} A list with the matches.\n */\nexport default function regularParticiples( word, regexes ) {\n\t// Matches word with language-specific participle regexes.\n\tlet matches = [];\n\n\tregexes.forEach( function( regex ) {\n\t\tconst match = word.match( regex );\n\t\tif ( match !== null ) {\n\t\t\tmatches.push( match );\n\t\t}\n\t} );\n\tmatches = flattenDeep( matches );\n\treturn matches;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,kBAAkBA,CAAEC,IAAI,EAAEC,OAAO,EAAG;EAC3D;EACA,IAAIC,OAAO,GAAG,EAAE;EAEhBD,OAAO,CAACE,OAAO,CAAE,UAAUC,KAAK,EAAG;IAClC,MAAMC,KAAK,GAAGL,IAAI,CAACK,KAAK,CAAED,KAAM,CAAC;IACjC,IAAKC,KAAK,KAAK,IAAI,EAAG;MACrBH,OAAO,CAACI,IAAI,CAAED,KAAM,CAAC;IACtB;EACD,CAAE,CAAC;EACHH,OAAO,GAAG,IAAAK,mBAAW,EAAEL,OAAQ,CAAC;EAChC,OAAOA,OAAO;AACf","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = require("lodash");
+var _getWords = _interopRequireDefault(require("../../word/getWords"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Checks whether a word from the precedence exception list occurs anywhere in the clause before the participle.
+ * If this is the case, the sentence part is not passive.
+ *
+ * @param {string} clause 		The clause that contains the participle.
+ * @param {string} participle   The participle.
+ * @param {Array} cannotBeBetweenPassiveAuxiliaryAndParticipleList  List of words which cannot be between auxiliary and participle.
+ *
+ * @returns {boolean} Returns true if a word from the precedence exception list occurs anywhere in the
+ *                    sentence part before the participle, otherwise returns false.
+ */
+function _default(clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticipleList = []) {
+  // Break the sentence part up into words and convert to lower case.
+  const wordsInClause = (0, _getWords.default)(clause).map(word => word.toLowerCase());
+
+  // Search the participle in the word list.
+  const participleIndex = wordsInClause.indexOf(participle.toLowerCase());
+
+  /*
+   * There can be no exception in the following situations:
+   *
+   * -1 The participle is not found.
+   *  0 There is no word before the participle.
+   */
+  if (participleIndex < 1) {
+    return false;
+  }
+
+  // Check if the words preceding the participle are in the exceptions list.
+  for (let i = 0; i < participleIndex; i++) {
+    if ((0, _lodash.includes)(cannotBeBetweenPassiveAuxiliaryAndParticipleList, wordsInClause[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+//# sourceMappingURL=precedenceException.js.map

package/build/cjs/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precedenceException.js","names":["_lodash","require","_getWords","_interopRequireDefault","e","__esModule","default","_default","clause","participle","cannotBeBetweenPassiveAuxiliaryAndParticipleList","wordsInClause","getWords","map","word","toLowerCase","participleIndex","indexOf","i","includes"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js"],"sourcesContent":["import { includes } from \"lodash\";\nimport getWords from \"../../word/getWords\";\n\n/**\n * Checks whether a word from the precedence exception list occurs anywhere in the clause before the participle.\n * If this is the case, the sentence part is not passive.\n *\n * @param {string} clause \t\tThe clause that contains the participle.\n * @param {string} participle   The participle.\n * @param {Array} cannotBeBetweenPassiveAuxiliaryAndParticipleList  List of words which cannot be between auxiliary and participle.\n *\n * @returns {boolean} Returns true if a word from the precedence exception list occurs anywhere in the\n *                    sentence part before the participle, otherwise returns false.\n */\nexport default function( clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticipleList = [] ) {\n\t// Break the sentence part up into words and convert to lower case.\n\tconst wordsInClause = getWords( clause ).map( word => word.toLowerCase() );\n\n\t// Search the participle in the word list.\n\tconst participleIndex = wordsInClause.indexOf( participle.toLowerCase() );\n\n\t/*\n\t * There can be no exception in the following situations:\n\t *\n\t * -1 The participle is not found.\n\t *  0 There is no word before the participle.\n\t */\n\tif ( participleIndex < 1 ) {\n\t\treturn false;\n\t}\n\n\t// Check if the words preceding the participle are in the exceptions list.\n\tfor ( let i = 0; i < participleIndex; i++ ) {\n\t\tif ( includes( cannotBeBetweenPassiveAuxiliaryAndParticipleList, wordsInClause[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA2C,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAAG,SAAUC,MAAM,EAAEC,UAAU,EAAEC,gDAAgD,GAAG,EAAE,EAAG;EACpG;EACA,MAAMC,aAAa,GAAG,IAAAC,iBAAQ,EAAEJ,MAAO,CAAC,CAACK,GAAG,CAAEC,IAAI,IAAIA,IAAI,CAACC,WAAW,CAAC,CAAE,CAAC;;EAE1E;EACA,MAAMC,eAAe,GAAGL,aAAa,CAACM,OAAO,CAAER,UAAU,CAACM,WAAW,CAAC,CAAE,CAAC;;EAEzE;AACD;AACA;AACA;AACA;AACA;EACC,IAAKC,eAAe,GAAG,CAAC,EAAG;IAC1B,OAAO,KAAK;EACb;;EAEA;EACA,KAAM,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,eAAe,EAAEE,CAAC,EAAE,EAAG;IAC3C,IAAK,IAAAC,gBAAQ,EAAET,gDAAgD,EAAEC,aAAa,CAAEO,CAAC,CAAG,CAAC,EAAG;MACvF,OAAO,IAAI;IACZ;EACD;EAEA,OAAO,KAAK;AACb","ignoreList":[]}

package/build/cjs/languageProcessing/helpers/prominentWords/determineProminentWords.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collapseProminentWordsOnStem = collapseProminentWordsOnStem;
+exports.default = void 0;
+exports.filterProminentWords = filterProminentWords;
+exports.getProminentWords = getProminentWords;
+exports.getProminentWordsFromPaperAttributes = getProminentWordsFromPaperAttributes;
+exports.retrieveAbbreviations = retrieveAbbreviations;
+exports.sortProminentWords = sortProminentWords;
+var _lodash = require("lodash");
+var _getWords = _interopRequireDefault(require("../word/getWords"));
+var _quotes = require("../sanitize/quotes");
+var _ProminentWord = _interopRequireDefault(require("../../values/ProminentWord"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const specialCharacters = /[1234567890‘’“”"'.…?!:;,¿¡«»&*@#±^%$|~=+§`[\](){}⟨⟩<>/\\–\-\u2014\u00d7\s]/g;
+
+/**
+ * Returns only those prominent words that occur more than a certain number of times and do not consist of special characters.
+ *
+ * @param {ProminentWord[]} prominentWords A list of prominent words.
+ * @param {int} [minimalNumberOfOccurrences] A minimal number of occurrences that is needed for a relevant prominentWord, default 2.
+ *
+ * @returns {ProminentWord[]} Only relevant words.
+ */
+function filterProminentWords(prominentWords, minimalNumberOfOccurrences = 2) {
+  prominentWords = prominentWords.filter(function (word) {
+    return word.getOccurrences() >= minimalNumberOfOccurrences && word.getWord().replace(specialCharacters, "") !== "";
+  });
+  return prominentWords;
+}
+
+/**
+ * Sorts prominent words based on their number of occurrences and length.
+ *
+ * @param {ProminentWord[]} prominentWords The prominent words to sort.
+ *
+ * @returns {void}
+ */
+function sortProminentWords(prominentWords) {
+  prominentWords.sort(function (wordA, wordB) {
+    const difference = wordB.getOccurrences() - wordA.getOccurrences();
+    // The word with the highest number of occurrences comes first.
+    if (difference !== 0) {
+      return difference;
+    }
+
+    // In case of a tie on occurrence number, the alphabetically first word comes first.
+    return wordA.getStem().localeCompare(wordB.getStem());
+  });
+}
+
+/**
+ * Collapses prominent words that have the same stem.
+ *
+ * @param {ProminentWord[]} prominentWords All prominentWords.
+ *
+ * @returns {ProminentWord[]} The original array with collapsed duplicates.
+ */
+function collapseProminentWordsOnStem(prominentWords) {
+  if (prominentWords.length === 0) {
+    return [];
+  }
+
+  // Sort the input array by stem
+  prominentWords.sort(function (wordA, wordB) {
+    return wordA.getStem().localeCompare(wordB.getStem());
+  });
+  const collapsedProminentWords = [];
+  let previousWord = new _ProminentWord.default(prominentWords[0].getWord(), prominentWords[0].getStem(), prominentWords[0].getOccurrences());
+  for (let i = 1; i < prominentWords.length; i++) {
+    const currentWord = new _ProminentWord.default(prominentWords[i].getWord(), prominentWords[i].getStem(), prominentWords[i].getOccurrences());
+
+    /*
+     * Compare the stem of the current word in the loop with the previously available stem.
+     * If they are equal, the word should be collapsed.
+     * When collapsing, the numbers of occurrences get summed.
+     * If the stem happens to equal the real word that occurred in the text, we can be sure it's ok to display it
+     * to the customer. So, the stem reassigns the word.
+     */
+    if (currentWord.getStem() === previousWord.getStem()) {
+      previousWord.setOccurrences(previousWord.getOccurrences() + currentWord.getOccurrences());
+      if (currentWord.getWord() === previousWord.getStem() || currentWord.getWord().toLocaleLowerCase() === previousWord.getStem()) {
+        previousWord.setWord(currentWord.getWord());
+      }
+    } else {
+      collapsedProminentWords.push(previousWord);
+      previousWord = currentWord;
+    }
+  }
+  collapsedProminentWords.push(previousWord);
+  return collapsedProminentWords;
+}
+
+/**
+ * Retrieves a list of all abbreviations from the text. Returns an empty array if the input text is empty.
+ *
+ * @param {string} text A text.
+ *
+ * @returns {string[]} A list of abbreviations from the list.
+ */
+function retrieveAbbreviations(text) {
+  const words = (0, _getWords.default)((0, _quotes.normalizeSingle)(text));
+  const abbreviations = [];
+  words.forEach(function (word) {
+    if (word.length > 1 && word.length < 5 && word === word.toLocaleUpperCase()) {
+      abbreviations.push(word.toLocaleLowerCase());
+    }
+  });
+  return (0, _lodash.uniq)(abbreviations);
+}
+
+/**
+ * Computes prominent words from an array of words. In order to do so, checks whether the word is included in the list of
+ * function words and determines the number of occurrences for every word. Then checks if any two words have the same stem
+ * and if so collapses over them.
+ *
+ * @param {string[]} words          The words to determine relevance for.
+ * @param {string[]} abbreviations  Abbreviations that should not be stemmed.
+ * @param {Function} stemmer        The available stemmer.
+ * @param {Array} functionWords     The available function words list.
+ *
+ * @returns {ProminentWord[]} All prominent words sorted and filtered for this text.
+ */
+function computeProminentWords(words, abbreviations, stemmer, functionWords) {
+  if (words.length === 0) {
+    return [];
+  }
+  const uniqueContentWords = (0, _lodash.uniq)(words.filter(word => !functionWords.includes(word.trim())));
+  const prominentWords = [];
+  uniqueContentWords.forEach(function (word) {
+    if (abbreviations.includes(word)) {
+      prominentWords.push(new _ProminentWord.default(word.toLocaleUpperCase(), word, words.filter(element => element === word).length));
+    } else {
+      prominentWords.push(new _ProminentWord.default(word, stemmer(word), words.filter(element => element === word).length));
+    }
+  });
+  return collapseProminentWordsOnStem(prominentWords);
+}
+
+/**
+ * Caches prominent words depending on text words.
+ * Only the words and abbreviations are used as the cache key as the stemmer and function words
+ * are config and shouldn't change in the scope of one request.
+ *
+ * @param {string[]} words          The words to determine relevance for.
+ * @param {string[]} abbreviations  Abbreviations that should not be stemmed.
+ * @param {Function} stemmer        The available stemmer.
+ * @param {Array} functionWords     The available function words list.
+ *
+ * @returns {function} The function that collects prominent words for a given set of text words, language and morphologyData.
+ */
+const computeProminentWordsMemoized = (0, _lodash.memoize)((words, abbreviations, stemmer, functionWords) => {
+  return computeProminentWords(words, abbreviations, stemmer, functionWords);
+}, (words, abbreviations) => {
+  return words.join(",") + "," + abbreviations.join(",");
+});
+
+/**
+ * Gets prominent words from the paper text.
+ *
+ * @param {string} text             The text to retrieve the prominent words from.
+ * @param {string[]} abbreviations  The abbreviations that occur in the text and attributes of the paper.
+ * @param {Function} stemmer        The available stemmer.
+ * @param {Array} functionWords     The available function words list.
+ * @param {function} getWordsCustomHelper   The custom helper to get words.
+ *
+ * @returns {ProminentWord[]} All prominent words sorted and filtered for this text.
+ */
+function getProminentWords(text, abbreviations, stemmer, functionWords, getWordsCustomHelper) {
+  if (text === "") {
+    return [];
+  }
+  const words = getWordsCustomHelper ? getWordsCustomHelper((0, _quotes.normalizeSingle)(text).toLocaleLowerCase()) : (0, _getWords.default)((0, _quotes.normalizeSingle)(text).toLocaleLowerCase());
+  return computeProminentWordsMemoized(words, abbreviations, stemmer, functionWords);
+}
+
+/**
+ * Gets prominent words from keyphrase and synonyms, metadescription, title, and subheadings.
+ *
+ * @param {string[]} attributes     The array with attributes to process.
+ * @param {string[]} abbreviations  The abbreviations that occur in the text and attributes of the paper.
+ * @param {Function} stemmer        The available stemmer.
+ * @param {Array} functionWords     The available function words list.
+ * @param {function} getWordsCustomHelper   The custom helper to get words.
+ *
+ * @returns {ProminentWord[]} Prominent words from the paper attributes.
+ */
+function getProminentWordsFromPaperAttributes(attributes, abbreviations, stemmer, functionWords, getWordsCustomHelper) {
+  const wordsFromAttributes = getWordsCustomHelper ? getWordsCustomHelper(attributes.join(" ").toLocaleLowerCase()) : (0, _getWords.default)(attributes.join(" ").toLocaleLowerCase());
+  return computeProminentWords(wordsFromAttributes, abbreviations, stemmer, functionWords);
+}
+var _default = exports.default = {
+  getProminentWords,
+  getProminentWordsFromPaperAttributes,
+  filterProminentWords,
+  sortProminentWords,
+  collapseProminentWordsOnStem,
+  retrieveAbbreviations
+};
+//# sourceMappingURL=determineProminentWords.js.map