axyseo 2.1.11 → 2.1.13

package/build/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = flattenSortLength;
+var _lodash = require("lodash");
+/**
+ * Returns combined list of strings/words, sorted by length (descending).
+ *
+ * @param {Object} dataWords The words data that is going to be sorted.
+ *
+ * @returns {Array<string>} All words, sorted by length (descending).
+ */
+function flattenSortLength(dataWords) {
+  const allWords = (0, _lodash.flatten)(Object.values(dataWords));
+  return allWords.sort((a, b) => b.length - a.length || a.localeCompare(b));
+}
+//# sourceMappingURL=flattenSortLength.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyAllReplacements = applyAllReplacements;
+exports.doesWordMatchRegex = doesWordMatchRegex;
+exports.searchAndReplaceWithRegex = searchAndReplaceWithRegex;
+/**
+ * Checks whether a word is matched with a regex.
+ *
+ * @param {string} word		The word to check.
+ * @param {string} regex	The regex.
+ *
+ * @returns {boolean}		Whether or not there was a match.
+ */
+function doesWordMatchRegex(word, regex) {
+  const regexObject = RegExp(regex);
+  return regexObject.test(word);
+}
+
+/**
+ * Loops through a nested array with pairs of regexes and replacements, and performs the needed replacement if a match is found.
+ *
+ * @param {string} word 						The word that may need to be modified.
+ * @param {[][]} groupOfRegexAndReplacements 	The array with the regexes and the required replacements.
+ *
+ * @returns {?string} The modified stem or null if no match was found.
+ */
+function searchAndReplaceWithRegex(word, groupOfRegexAndReplacements) {
+  for (const regexAndReplacement of groupOfRegexAndReplacements) {
+    if (word.search(new RegExp(regexAndReplacement[0])) !== -1) {
+      word = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);
+      return word;
+    }
+  }
+}
+
+/**
+ * Loops through a nested array of regexes and replacement pairs, and applies all replacements for which a match is found.
+ *
+ * @param {string}  word                        The word that may need to be modified.
+ * @param {[][]}    listOfRegexAndReplacement   The array with the regexes and the replacements.
+ *
+ * @returns {string} The modified word.
+ */
+function applyAllReplacements(word, listOfRegexAndReplacement) {
+  listOfRegexAndReplacement.forEach(function (setOfRegexAndReplacement) {
+    word = word.replace(new RegExp(setOfRegexAndReplacement[0]), setOfRegexAndReplacement[1]);
+  });
+  return word;
+}
+//# sourceMappingURL=regexHelpers.js.map

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeSuffixFromFullForm = removeSuffixFromFullForm;
+exports.removeSuffixesFromFullForm = removeSuffixesFromFullForm;
+/**
+ * Checks whether the word starts with one of the words in a given list and ends in one of the suffixes
+ * in a given suffixes list. If so, deletes the suffix.
+ *
+ * @param {string[]}    list  The list of words to check against.
+ * @param {string[]}    suffixes    The suffixes that needs to be deleted.
+ * @param {string}      word        The word to check.
+ * @returns {string}	The stemmed word.
+ */
+function removeSuffixesFromFullForm(list, suffixes, word) {
+  for (let i = 0; i < list.length; i++) {
+    if (word.startsWith(list[i])) {
+      const suffixRetrieved = word.substring(list[i].length);
+      for (let j = 0; j < suffixes.length; j++) {
+        if (suffixes[j] === suffixRetrieved) {
+          return word.slice(0, -suffixRetrieved.length);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Checks whether the word is in a given list of exceptions and if so, deletes a given suffix.
+ *
+ * @param {string[]}    exceptions  The exception list.
+ * @param {string}      suffix      The suffix that needs to be deleted.
+ * @param {string}      word        The word to check.
+ *
+ * @returns {string} The stemmed word.
+ */
+function removeSuffixFromFullForm(exceptions, suffix, word) {
+  for (let i = 0; i < exceptions.length; i++) {
+    if (word.endsWith(exceptions[i])) {
+      return word.slice(0, -suffix.length);
+    }
+  }
+}
+//# sourceMappingURL=stemHelpers.js.map

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stemPrefixedFunctionWords = stemPrefixedFunctionWords;
+/**
+ * An object containing the stem and the prefix.
+ *
+ * @typedef {Object} 	StemAndPrefixPair
+ * @property {string}	stem The word without the basic prefixes.
+ * @property {string}	prefix The prefix that was matched.
+ */
+
+/**
+ * Strips function word prefixes from the word.
+ *
+ * @param {string} word The word to strip the basic prefixes from.
+ * @param {RegExp} regex The regular expression to match the function word prefixes.
+ * @returns {StemAndPrefixPair} The word without the function word prefixes that was stripped,
+ * or the original word if the word is not prefixed.
+ */
+function stemPrefixedFunctionWords(word, regex) {
+  /*
+  	 * If a word starts with one of the prefixes, we strip it.
+   */
+  let stemmedWord = word;
+  let prefix = "";
+  const isPrefixed = word.match(regex);
+  if (isPrefixed) {
+    prefix = isPrefixed[0];
+    stemmedWord = word.slice(prefix.length);
+  }
+  return {
+    stem: stemmedWord,
+    prefix: prefix
+  };
+}
+//# sourceMappingURL=stemPrefixedFunctionWords.js.map

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

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

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

@@ -0,0 +1,42 @@
+"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 the participle is directly preceded by a word from the direct precedence exception list.
+ * If this is the case, the clause is not passive.
+ *
+ * @param {string} clause 		The clause that contains the participle.
+ * @param {string} participle   The participle.
+ * @param {Array} cannotDirectlyPrecedePassiveParticipleList List of words which cannot directly precede a passive participle.
+ *
+ * @returns {boolean} Returns true if a word from the direct precedence exception list is directly preceding
+ *                    the participle, otherwise returns false.
+ */
+function _default(clause, participle, cannotDirectlyPrecedePassiveParticipleList = []) {
+  // 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;
+  }
+  const wordPrecedingParticiple = wordsInClause[participleIndex - 1];
+
+  // Check if the word preceding the participle is in the exceptions list.
+  return (0, _lodash.includes)(cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple);
+}
+//# sourceMappingURL=directPrecedenceException.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directPrecedenceException.js","names":["_lodash","require","_getWords","_interopRequireDefault","e","__esModule","default","_default","clause","participle","cannotDirectlyPrecedePassiveParticipleList","wordsInClause","getWords","map","word","toLowerCase","participleIndex","indexOf","wordPrecedingParticiple","includes"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/directPrecedenceException.js"],"sourcesContent":["import { includes } from \"lodash\";\nimport getWords from \"../../word/getWords\";\n\n/**\n * Checks whether the participle is directly preceded by a word from the direct precedence exception list.\n * If this is the case, the clause is not passive.\n *\n * @param {string} clause \t\tThe clause that contains the participle.\n * @param {string} participle   The participle.\n * @param {Array} cannotDirectlyPrecedePassiveParticipleList List of words which cannot directly precede a passive participle.\n *\n * @returns {boolean} Returns true if a word from the direct precedence exception list is directly preceding\n *                    the participle, otherwise returns false.\n */\nexport default function( clause, participle, cannotDirectlyPrecedePassiveParticipleList = [] ) {\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\tconst wordPrecedingParticiple = wordsInClause[ participleIndex - 1 ];\n\n\t// Check if the word preceding the participle is in the exceptions list.\n\treturn includes( cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple );\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,0CAA0C,GAAG,EAAE,EAAG;EAC9F;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,MAAME,uBAAuB,GAAGP,aAAa,CAAEK,eAAe,GAAG,CAAC,CAAE;;EAEpE;EACA,OAAO,IAAAG,gBAAQ,EAAET,0CAA0C,EAAEQ,uBAAwB,CAAC;AACvF","ignoreList":[]}

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

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = require("lodash");
+var _stripSpaces = _interopRequireDefault(require("../../../sanitize/stripSpaces.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Strips spaces from the auxiliary matches.
+ *
+ * @param {Array} matches A list with matches of auxiliaries.
+ * @returns {Array} A list with matches with spaces removed.
+ */
+function sanitizeMatches(matches) {
+  return (0, _lodash.map)(matches, function (match) {
+    return (0, _stripSpaces.default)(match);
+  });
+}
+
+/**
+ * Splits sentences into clauses based on stopwords.
+ *
+ * @param {string} sentence The sentence to split.
+ * @param {Array} stopwords The array with matched stopwords.
+ *
+ * @returns {Array} The array with clauses.
+ */
+function splitOnStopWords(sentence, stopwords) {
+  const clauses = [];
+
+  // Split the sentence on each found stopword and push this part in an array.
+  (0, _lodash.forEach)(stopwords, function (stopword) {
+    const clause = sentence.split(stopword);
+    if (!(0, _lodash.isEmpty)(clause[0])) {
+      clauses.push(clause[0]);
+    }
+    const startIndex = sentence.indexOf(stopword);
+    const endIndex = sentence.length;
+    sentence = (0, _stripSpaces.default)(sentence.substring(startIndex, endIndex));
+  });
+
+  // Push the remainder of the sentence in the clauses array.
+  clauses.push(sentence);
+  return clauses;
+}
+
+/**
+ *
+ * Splits sentences into clauses based on stopCharacter.
+ *
+ * @param {string}  sentence        The sentence to split.
+ * @param {regex}   stopCharacter   The stop characters regex.
+ *
+ * @returns {Array} The array with clauses.
+ */
+function splitOnStopCharacter(sentence, stopCharacter) {
+  const clauses = sentence.split(stopCharacter);
+
+  // Strip space in the beginning of the clause, if any.
+  for (let i = 0; i < clauses.length; i++) {
+    if (clauses[i][0] === " ") {
+      clauses[i] = clauses[i].substring(1, clauses[i].length);
+    }
+  }
+  return clauses;
+}
+
+/**
+ * Creates clauses based on split sentences.
+
+ * @param {Array}   clauses   The array with clauses.
+ * @param {Object}  options    The language-specific regexes and Clause class.
+ *
+ * @returns {Array} The array with sentence parts.
+ */
+function createClauseObjects(clauses, options) {
+  const clauseObjects = [];
+  (0, _lodash.forEach)(clauses, function (clause) {
+    const foundAuxiliaries = sanitizeMatches(clause.match(options.regexes.auxiliaryRegex || []));
+    // If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.
+    if (foundAuxiliaries.length !== 0) {
+      clauseObjects.push(new options.Clause(clause, foundAuxiliaries));
+    }
+  });
+  return clauseObjects;
+}
+
+/**
+ * Splits the sentence into clauses based on stopwords.
+ *
+ * @param {string} sentence The text to split into clauses.
+ * @param {Object} options The language-specific regexes and Clause class.
+ *
+ * @returns {Array} The array with clauses.
+ */
+function getClausesSplitOnStopWords(sentence, options) {
+  const auxiliaryRegex = options.regexes.auxiliaryRegex;
+  // First check if there is an auxiliary in the sentence.
+  if (sentence.match(auxiliaryRegex) === null) {
+    return [];
+  }
+  let clauses;
+  const stopwords = sentence.match(options.regexes.stopwordRegex) || [];
+  // Split sentences based on stop words
+  clauses = splitOnStopWords(sentence, stopwords);
+
+  // 	Split sentences based on stop characters, only if the regex is available and if the sentence is not yet split from the previous check
+  if (typeof options.regexes.stopCharacterRegex !== "undefined" && clauses.length === 1) {
+    clauses = splitOnStopCharacter(sentence, options.regexes.stopCharacterRegex);
+  }
+  return createClauseObjects(clauses, options);
+}
+var _default = exports.default = getClausesSplitOnStopWords;
+//# sourceMappingURL=getClausesSplitOnStopWords.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getClausesSplitOnStopWords.js","names":["_lodash","require","_stripSpaces","_interopRequireDefault","e","__esModule","default","sanitizeMatches","matches","map","match","stripSpaces","splitOnStopWords","sentence","stopwords","clauses","forEach","stopword","clause","split","isEmpty","push","startIndex","indexOf","endIndex","length","substring","splitOnStopCharacter","stopCharacter","i","createClauseObjects","options","clauseObjects","foundAuxiliaries","regexes","auxiliaryRegex","Clause","getClausesSplitOnStopWords","stopwordRegex","stopCharacterRegex","_default","exports"],"sources":["../../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords.js"],"sourcesContent":["import { forEach, isEmpty, map } from \"lodash\";\n\nimport stripSpaces from \"../../../sanitize/stripSpaces.js\";\n\n/**\n * Strips spaces from the auxiliary matches.\n *\n * @param {Array} matches A list with matches of auxiliaries.\n * @returns {Array} A list with matches with spaces removed.\n */\nfunction sanitizeMatches( matches ) {\n\treturn map( matches, function( match ) {\n\t\treturn stripSpaces( match );\n\t} );\n}\n\n/**\n * Splits sentences into clauses based on stopwords.\n *\n * @param {string} sentence The sentence to split.\n * @param {Array} stopwords The array with matched stopwords.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopWords( sentence, stopwords ) {\n\tconst clauses = [];\n\n\t// Split the sentence on each found stopword and push this part in an array.\n\tforEach( stopwords, function( stopword ) {\n\t\tconst clause = sentence.split( stopword );\n\t\tif ( ! isEmpty( clause[ 0 ] ) ) {\n\t\t\tclauses.push( clause[ 0 ] );\n\t\t}\n\t\tconst startIndex = sentence.indexOf( stopword );\n\t\tconst endIndex = sentence.length;\n\t\tsentence = stripSpaces( sentence.substring( startIndex, endIndex ) );\n\t} );\n\n\t// Push the remainder of the sentence in the clauses array.\n\tclauses.push( sentence );\n\treturn clauses;\n}\n\n/**\n *\n * Splits sentences into clauses based on stopCharacter.\n *\n * @param {string}  sentence        The sentence to split.\n * @param {regex}   stopCharacter   The stop characters regex.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopCharacter( sentence, stopCharacter ) {\n\tconst clauses = sentence.split( stopCharacter );\n\n\t// Strip space in the beginning of the clause, if any.\n\tfor ( let i = 0; i < clauses.length; i++ ) {\n\t\tif ( clauses[ i ][ 0 ] === \" \" ) {\n\t\t\tclauses[ i ] = clauses[ i ].substring( 1, clauses[ i ].length );\n\t\t}\n\t}\n\treturn clauses;\n}\n\n/**\n * Creates clauses based on split sentences.\n\n * @param {Array}   clauses   The array with clauses.\n * @param {Object}  options    The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with sentence parts.\n */\nfunction createClauseObjects( clauses, options ) {\n\tconst clauseObjects = [];\n\tforEach( clauses, function( clause ) {\n\t\tconst foundAuxiliaries = sanitizeMatches( clause.match( options.regexes.auxiliaryRegex || [] ) );\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 ( foundAuxiliaries.length !== 0 ) {\n\t\t\tclauseObjects.push( new options.Clause( clause, foundAuxiliaries ) );\n\t\t}\n\t} );\n\treturn clauseObjects;\n}\n\n/**\n * Splits the sentence into clauses based on stopwords.\n *\n * @param {string} sentence The text to split into clauses.\n * @param {Object} options The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with clauses.\n */\nfunction getClausesSplitOnStopWords( sentence, options ) {\n\tconst auxiliaryRegex = options.regexes.auxiliaryRegex;\n\t// First check if there is an auxiliary in the sentence.\n\tif ( sentence.match( auxiliaryRegex ) === null ) {\n\t\treturn [];\n\t}\n\n\tlet clauses;\n\tconst stopwords = sentence.match( options.regexes.stopwordRegex ) || [];\n\t// Split sentences based on stop words\n\tclauses = splitOnStopWords( sentence, stopwords );\n\n\t// \tSplit sentences based on stop characters, only if the regex is available and if the sentence is not yet split from the previous check\n\tif ( typeof( options.regexes.stopCharacterRegex ) !== \"undefined\" && clauses.length === 1 ) {\n\t\tclauses = splitOnStopCharacter( sentence, options.regexes.stopCharacterRegex );\n\t}\n\n\treturn createClauseObjects( clauses, options );\n}\n\nexport default getClausesSplitOnStopWords;\n"],"mappings":"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","ignoreList":[]}