axyseo 2.0.0-alpha.1

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

package/build/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/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/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/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/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/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/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/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/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/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":[]}

package/build/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/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":[]}