axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.6

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

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

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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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

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

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

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

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

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

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

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

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