axyseo 2.0.0-alpha.0.0.19 → 2.0.0-alpha.0.0.2

package/src/languageProcessing/helpers/morphology/flattenSortLength.js

@@ -0,0 +1,14 @@
+import { flatten } from "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).
+ */
+export default function flattenSortLength( dataWords ) {
+	const allWords = flatten( Object.values( dataWords ) );
+
+	return allWords.sort( ( a, b ) => b.length - a.length || a.localeCompare( b ) );
+}

package/src/languageProcessing/helpers/morphology/getAllWordsFromPaper.js

@@ -0,0 +1,39 @@
+import { escapeRegExp } from "lodash";
+import getAltAttribute from "../image/getAltAttribute";
+import { normalizeSingle } from "../sanitize/quotes";
+import parseSlug from "../url/parseSlug";
+import getWords from "../word/getWords";
+import getImagesInTree from "../image/getImagesInTree";
+import { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from "../../../config/wordBoundariesWithoutPunctuation";
+
+/**
+ * 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.
+ */
+export default function( paper, areHyphensWordBoundaries ) {
+	const paperText = paper.getText();
+	const altTagsInText = getImagesInTree( paper ).map( image => getAltAttribute( image ) );
+
+	const paperContent = [
+		paperText,
+		paper.getTitle(),
+		paper.getSlug(),
+		parseSlug( 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 ? getWords( paperContent, WORD_BOUNDARY_WITH_HYPHEN )
+		: getWords( paperContent, WORD_BOUNDARY_WITHOUT_HYPHEN );
+
+	return words.map(
+		word => normalizeSingle( escapeRegExp( word ) ) );
+}

package/src/languageProcessing/helpers/morphology/regexHelpers.js

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export function applyAllReplacements( word, listOfRegexAndReplacement ) {
+	listOfRegexAndReplacement.forEach( function( setOfRegexAndReplacement ) {
+		word = word.replace( new RegExp( setOfRegexAndReplacement[ 0 ] ), setOfRegexAndReplacement[ 1 ] );
+	} );
+	return word;
+}

package/src/languageProcessing/helpers/morphology/stemHelpers.js

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+export 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.
+ */
+export function removeSuffixFromFullForm( exceptions, suffix, word ) {
+	for ( let i = 0; i < exceptions.length; i++ ) {
+		if ( word.endsWith( exceptions[ i ] ) ) {
+			return word.slice( 0, -suffix.length );
+		}
+	}
+}

package/src/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+export 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 };
+}

package/src/languageProcessing/helpers/passiveVoice/periphrastic/directPrecedenceException.js

@@ -0,0 +1,36 @@
+import { includes } from "lodash";
+import getWords from "../../word/getWords";
+
+/**
+ * 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.
+ */
+export default function( clause, participle, cannotDirectlyPrecedePassiveParticipleList = [] ) {
+	// 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;
+	}
+
+	const wordPrecedingParticiple = wordsInClause[ participleIndex - 1 ];
+
+	// Check if the word preceding the participle is in the exceptions list.
+	return includes( cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple );
+}

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

@@ -0,0 +1,113 @@
+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;

package/src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js

@@ -0,0 +1,45 @@
+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;
+}

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

@@ -0,0 +1,231 @@
+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 );
+}

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

@@ -0,0 +1,20 @@
+/**
+ * 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;
+}

package/src/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;
+}

package/src/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;
+}