axyseo 2.0.0-alpha.0.0.37 → 2.0.0-alpha.0.0.39

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

@@ -0,0 +1,110 @@
+import { forEach, isEmpty, map } from "lodash";
+import stripSpaces from "../../../sanitize/stripSpaces.js";
+
+/**
+ * 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 map(matches, function (match) {
+    return stripSpaces(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.
+  forEach(stopwords, function (stopword) {
+    const clause = sentence.split(stopword);
+    if (!isEmpty(clause[0])) {
+      clauses.push(clause[0]);
+    }
+    const startIndex = sentence.indexOf(stopword);
+    const endIndex = sentence.length;
+    sentence = stripSpaces(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 = [];
+  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);
+}
+export 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":["forEach","isEmpty","map","stripSpaces","sanitizeMatches","matches","match","splitOnStopWords","sentence","stopwords","clauses","stopword","clause","split","push","startIndex","indexOf","endIndex","length","substring","splitOnStopCharacter","stopCharacter","i","createClauseObjects","options","clauseObjects","foundAuxiliaries","regexes","auxiliaryRegex","Clause","getClausesSplitOnStopWords","stopwordRegex","stopCharacterRegex"],"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,39 @@
+import { uniq } from "lodash";
+import arrayToRegex from "../../../regex/createRegexFromArray.js";
+import getWordIndices from "../getIndicesWithRegex.js";
+import { getIndicesByWordListSorted } from "../../../word/indices.js";
+
+/**
+ * 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.
+ */
+export default function (clause, participle, auxiliaries, cannotBeBetweenPassiveAuxiliaryAndParticiple) {
+  const auxiliariesUnique = uniq(auxiliaries);
+  const auxiliaryIndices = getIndicesByWordListSorted(auxiliariesUnique, clause);
+  const participleIndex = clause.indexOf(participle);
+  const nonDirectParticiplePrecendenceExceptionRegex = arrayToRegex(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 = getWordIndices(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":["uniq","arrayToRegex","getWordIndices","getIndicesByWordListSorted","clause","participle","auxiliaries","cannotBeBetweenPassiveAuxiliaryAndParticiple","auxiliariesUnique","auxiliaryIndices","participleIndex","indexOf","nonDirectParticiplePrecendenceExceptionRegex","matches","filter","auxiliaryIndex","index","length","participleAuxiliary","precedenceExceptionIndices","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,SAASA,IAAI,QAAQ,QAAQ;AAE7B,OAAOC,YAAY;AACnB,OAAOC,cAAc;AAErB,SAASC,0BAA0B;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,UAAU,EAAEC,WAAW,EAAEC,4CAA4C,EAAG;EACxG,MAAMC,iBAAiB,GAAGR,IAAI,CAAEM,WAAY,CAAC;EAE7C,MAAMG,gBAAgB,GAAGN,0BAA0B,CAAEK,iBAAiB,EAAEJ,MAAO,CAAC;EAEhF,MAAMM,eAAe,GAAGN,MAAM,CAACO,OAAO,CAAEN,UAAW,CAAC;EACpD,MAAMO,4CAA4C,GAAGX,YAAY,CAAEM,4CAA6C,CAAC;;EAEjH;EACA,MAAMM,OAAO,GAAGJ,gBAAgB,CAACK,MAAM,CAAEC,cAAc,IAAIA,cAAc,CAACC,KAAK,GAAGN,eAAgB,CAAC;;EAEnG;EACA,IAAKG,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,GAAGjB,cAAc,CAAEE,MAAM,EAAEQ,4CAA6C,CAAC;;EAEzG;EACA,MAAMQ,mCAAmC,GAAGD,0BAA0B,CAACL,MAAM,CAAEO,wBAAwB,IACpGA,wBAAwB,CAACL,KAAK,GAAGE,mBAAmB,CAACF,KAAK,IAAIK,wBAAwB,CAACL,KAAK,GAAGN,eAAkB,CAAC;EAErH,OAAOU,mCAAmC,CAACH,MAAM,GAAG,CAAC;AACtD","ignoreList":[]}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { flattenDeep } from "lodash";
+
+/**
+ * Returns words that have been determined to be a regular participle.
+ *
+ * @param {string} word         The word to check.
+ * @param {RegExp[]} regexes    The regular participle regexes to match.
+ *
+ * @returns {Array} A list with the matches.
+ */
+export default function regularParticiples(word, regexes) {
+  // Matches word with language-specific participle regexes.
+  let matches = [];
+  regexes.forEach(function (regex) {
+    const match = word.match(regex);
+    if (match !== null) {
+      matches.push(match);
+    }
+  });
+  matches = flattenDeep(matches);
+  return matches;
+}
+//# sourceMappingURL=matchRegularParticiples.js.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"precedenceException.js","names":["includes","getWords","clause","participle","cannotBeBetweenPassiveAuxiliaryAndParticipleList","wordsInClause","map","word","toLowerCase","participleIndex","indexOf","i"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js"],"sourcesContent":["import { includes } from \"lodash\";\nimport getWords from \"../../word/getWords\";\n\n/**\n * Checks whether a word from the precedence exception list occurs anywhere in the clause before the participle.\n * If this is the case, the sentence part is not passive.\n *\n * @param {string} clause \t\tThe clause that contains the participle.\n * @param {string} participle   The participle.\n * @param {Array} cannotBeBetweenPassiveAuxiliaryAndParticipleList  List of words which cannot be between auxiliary and participle.\n *\n * @returns {boolean} Returns true if a word from the precedence exception list occurs anywhere in the\n *                    sentence part before the participle, otherwise returns false.\n */\nexport default function( clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticipleList = [] ) {\n\t// Break the sentence part up into words and convert to lower case.\n\tconst wordsInClause = getWords( clause ).map( word => word.toLowerCase() );\n\n\t// Search the participle in the word list.\n\tconst participleIndex = wordsInClause.indexOf( participle.toLowerCase() );\n\n\t/*\n\t * There can be no exception in the following situations:\n\t *\n\t * -1 The participle is not found.\n\t *  0 There is no word before the participle.\n\t */\n\tif ( participleIndex < 1 ) {\n\t\treturn false;\n\t}\n\n\t// Check if the words preceding the participle are in the exceptions list.\n\tfor ( let i = 0; i < participleIndex; i++ ) {\n\t\tif ( includes( cannotBeBetweenPassiveAuxiliaryAndParticipleList, wordsInClause[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,QAAQ;AACjC,OAAOC,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,UAAU,EAAEC,gDAAgD,GAAG,EAAE,EAAG;EACpG;EACA,MAAMC,aAAa,GAAGJ,QAAQ,CAAEC,MAAO,CAAC,CAACI,GAAG,CAAEC,IAAI,IAAIA,IAAI,CAACC,WAAW,CAAC,CAAE,CAAC;;EAE1E;EACA,MAAMC,eAAe,GAAGJ,aAAa,CAACK,OAAO,CAAEP,UAAU,CAACK,WAAW,CAAC,CAAE,CAAC;;EAEzE;AACD;AACA;AACA;AACA;AACA;EACC,IAAKC,eAAe,GAAG,CAAC,EAAG;IAC1B,OAAO,KAAK;EACb;;EAEA;EACA,KAAM,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,eAAe,EAAEE,CAAC,EAAE,EAAG;IAC3C,IAAKX,QAAQ,CAAEI,gDAAgD,EAAEC,aAAa,CAAEM,CAAC,CAAG,CAAC,EAAG;MACvF,OAAO,IAAI;IACZ;EACD;EAEA,OAAO,KAAK;AACb","ignoreList":[]}