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

package/src/languageProcessing/helpers/match/isDoubleQuoted.js

@@ -1,13 +0,0 @@
-import doubleQuotes from "../sanitize/doubleQuotes";
-import { includes } from "lodash";
-
-/**
- * Checks if the keyphrase is double-quoted.
- * @param {string} keyphrase The keyphrase to check.
- * @returns {boolean} Whether the keyphrase is double-quoted.
- */
-const isDoubleQuoted = ( keyphrase ) => {
-	return ( includes( doubleQuotes, keyphrase[ 0 ] ) && includes( doubleQuotes, keyphrase[ keyphrase.length - 1 ] ) );
-};
-
-export default isDoubleQuoted;

package/src/languageProcessing/helpers/match/matchTextWithArray.js

@@ -1,36 +0,0 @@
-/** @module stringProcessing/matchTextWithArray */
-
-import matchTextWithWord from "./matchTextWithWord";
-import { uniq as unique } from "lodash";
-
-/**
- * Matches strings from an array against a given text.
- *
- * @param {String}      text                    The text to match.
- * @param {Array}       array                   The array with strings to match.
- * @param {String}      [locale = "en_EN"]      The locale of the text to get transliterations.
- * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
- *
- * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.
- */
-export default function( text, array, locale = "en_EN", matchWordCustomHelper ) {
-	let count = 0;
-	let matches = [];
-	let positions = [];
-
-	unique( array ).forEach( function( wordToMatch ) {
-		const occurrence = matchTextWithWord( text, wordToMatch, locale, matchWordCustomHelper );
-		count += occurrence.count;
-		matches = matches.concat( occurrence.matches );
-		positions.push( occurrence.position );
-	} );
-
-	// Filtered out negative number, i.e. -1.
-	positions = positions.filter( position => position >= 0 );
-
-	return {
-		count: count,
-		matches: matches,
-		position: positions.length === 0 ? -1 : Math.min( ...positions ),
-	};
-}

package/src/languageProcessing/helpers/match/matchTextWithTransliteration.js

@@ -1,58 +0,0 @@
-import { map } from "lodash";
-import addWordBoundary from "../word/addWordboundary.js";
-import stripSpaces from "../sanitize/stripSpaces.js";
-import transliterate from "../transliterate/transliterate.js";
-import transliterateWP from "../transliterate/transliterateWPstyle.js";
-import { replaceTurkishIsMemoized } from "../transliterate/specialCharacterMappings";
-import { getLanguage } from "../../index";
-
-/**
- * Creates a regex from the keyword with included wordboundaries.
- *
- * @param {string} keyword  The keyword to create a regex from.
- * @param {string} language The language used to determine the word boundary.
- *
- * @returns {RegExp} Regular expression of the keyword with word boundaries.
- */
-const toRegex = function( keyword, language ) {
-	keyword = addWordBoundary( keyword, false, "", language );
-	return new RegExp( keyword, "ig" );
-};
-
-/**
- * Matches a string with and without transliteration.
- * @param {string} text The text to match.
- * @param {string} keyword The keyword to match in the text.
- * @param {string} locale The locale used for transliteration.
- * @returns {Array} All matches from the original as the transliterated text and keyword.
- */
-export default function( text, keyword, locale ) {
-	const language = getLanguage( locale );
-	let keywordRegex = toRegex( keyword, language );
-
-	if ( language === "tr" ) {
-		const turkishMappings = replaceTurkishIsMemoized( keyword );
-		keywordRegex = new RegExp( turkishMappings.map( x => addWordBoundary( x ) ).join( "|" ), "ig" );
-	}
-	const matches = text.match( keywordRegex ) || [];
-
-	text = text.replace( keywordRegex, "" );
-
-	const transliterateKeyword = transliterate( keyword, locale );
-	const transliterateKeywordRegex = toRegex( transliterateKeyword, language );
-	const transliterateMatches = text.match( transliterateKeywordRegex ) || [];
-	let combinedArray = matches.concat( transliterateMatches );
-
-	const transliterateWPKeyword = transliterateWP( keyword, locale );
-
-	if ( ! ( transliterateWPKeyword === transliterateKeyword ) ) {
-		const transliterateWPKeywordRegex = toRegex( transliterateWPKeyword, language );
-		const transliterateWPMatches = text.match( transliterateWPKeywordRegex ) || [];
-
-		combinedArray = combinedArray.concat( transliterateWPMatches );
-	}
-
-	return map( combinedArray, function( match ) {
-		return stripSpaces( match );
-	} );
-}

package/src/languageProcessing/helpers/match/matchTextWithWord.js

@@ -1,45 +0,0 @@
-/** @module stringProcessing/matchTextWithWord */
-
-import stripSomeTags from "../sanitize/stripNonTextTags.js";
-import stripSpaces from "../sanitize/stripSpaces.js";
-import removePunctuation from "../sanitize/removePunctuation.js";
-import { unifyAllSpaces as unifyWhitespace } from "../sanitize/unifyWhitespace.js";
-import matchStringWithTransliteration from "./matchTextWithTransliteration.js";
-import { normalize as normalizeQuotes } from "../sanitize/quotes.js";
-import { map } from "lodash";
-
-/**
- * Returns the number of matches in a given string
- *
- * @param {string}      text                    The text to use for matching the wordToMatch.
- * @param {string}      wordToMatch             The word to match in the text.
- * @param {string}      locale   				The locale used for transliteration.
- * @param {function}    matchWordCustomHelper  	The helper function to match word in text.
- *
- * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.
- */
-export default function( text, wordToMatch, locale, matchWordCustomHelper ) {
-	text = stripSomeTags( text );
-	text = unifyWhitespace( text );
-	text = normalizeQuotes( text );
-
-	wordToMatch = normalizeQuotes( wordToMatch );
-	let matches = matchWordCustomHelper
-		? matchWordCustomHelper( text, wordToMatch )
-		: matchStringWithTransliteration( text, wordToMatch, locale );
-
-	matches = map( matches, function( keyword ) {
-		return stripSpaces( removePunctuation( keyword ) );
-	} );
-
-	// Create an array of positions of matches to determine where in the text the wordToMatch occurred first.
-	const positions = map( matches, function( keyword ) {
-		return text.indexOf( keyword );
-	} );
-
-	return {
-		count: matches.length,
-		matches: matches,
-		position: positions.length === 0 ? -1 : Math.min( ...positions ),
-	};
-}

package/src/languageProcessing/helpers/match/matchWordFormsWithSentence.js

@@ -1,164 +0,0 @@
-import matchTextWithTransliteration from "./matchTextWithTransliteration";
-import splitIntoTokens from "../word/splitIntoTokens";
-
-/**
- * Tokenizes the word form of the keyphrase for exact matching. This function gets the word form and tokenizes it.
- * This function assumes that if a keyphrase needs to be matched exactly, there will be only one word form.
- * This is the result of how the focus keyphrase is processed in buildTopicStems.js in the buildStems function.
- *
- * @param {(string[])}  wordForms 					The word forms to tokenize.
- * @param {function}	customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
- *
- * @returns {string[]} The tokenized word forms.
- */
-export const tokenizeKeyphraseFormsForExactMatching = ( wordForms, customSplitIntoTokensHelper ) => {
-	// Tokenize word form of the keyphrase.
-	const wordFormText = wordForms[ 0 ];
-
-	return customSplitIntoTokensHelper ? customSplitIntoTokensHelper( wordFormText ) : splitIntoTokens( wordFormText );
-};
-
-/**
- * Gets the exact matches of the keyphrase.
- * Exact matching happens when the user puts the keyphrase in double quotes.
- *
- * @param {Sentence}	sentence					The sentence to match the word forms with.
- * @param {string[]}	wordForms					The word forms to match.
- * @param {string}		locale						The locale used in the analysis.
- * @param {function}	customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
- *
- * @returns {{count: number, matches: Token[]}} Object containing the number of the exact matches and the matched tokens.
- */
-const findExactMatchKeyphraseInSentence = ( sentence, wordForms, locale, customSplitIntoTokensHelper ) => {
-	const result = {
-		count: 0,
-		matches: [],
-	};
-	// Tokenize word forms of the keyphrase.
-	const keyphraseTokens = tokenizeKeyphraseFormsForExactMatching( wordForms, customSplitIntoTokensHelper );
-
-	const sentenceTokens = sentence.tokens;
-
-	// Initialize the index of the word token of the keyphrase.
-	let indexOfWordInKeyphrase = 0;
-	// Initialize the index of the word token of the sentence.
-	let indexOfWordInSentence = 0;
-	let currentMatch = [];
-
-	// Check if the tokenized word forms occur in the same order in the sentence tokens.
-	while ( indexOfWordInSentence < sentenceTokens.length ) {
-		// If the current sentence token matches the current word token of the keyphrase, add it to the current match.
-		const sentenceTokenText = sentenceTokens[ indexOfWordInSentence ].text;
-		const keyphraseTokenText = keyphraseTokens[ indexOfWordInKeyphrase ];
-
-		const foundMatches = matchTextWithTransliteration( sentenceTokenText.toLowerCase(), keyphraseTokenText.toLowerCase(), locale );
-
-		if ( foundMatches.length > 0 ) {
-			currentMatch.push( sentenceTokens[ indexOfWordInSentence ] );
-			indexOfWordInKeyphrase++;
-		} else {
-			indexOfWordInKeyphrase = 0;
-			currentMatch = [];
-		}
-
-		/*
-		 * If the current match has the same length as the keyphrase tokens, the keyphrase forms have been matched.
-		 * Add the current match to the matches array and reset the index of the word in keyphrase and the current match.
-		 */
-		if ( currentMatch.length === keyphraseTokens.length ) {
-			result.matches.push( ...currentMatch );
-			result.count++;
-			indexOfWordInKeyphrase = 0;
-			currentMatch = [];
-		}
-
-		indexOfWordInSentence++;
-	}
-	return result;
-};
-
-/**
- * Matches a word form of the keyphrase with the tokens from the sentence.
- *
- * With this approach, we transliterate the word form of the keyphrase before matching it with the sentence tokens.
- * However, we don't do the transliteration step for the sentence tokens.
- * As a result, for example, the word form "acción" from the keyphrase will match the word "accion" in the sentence.
- * But, the word form "accion" from the keyphrase will NOT match the word "acción" in the sentence.
- *
- * @param {Token[]}	tokens		The array of tokens to check.
- * @param {string}	wordForm	The word form of the keyphrase.
- * @param {string}	locale		The locale used in the analysis.
- *
- * @returns {Token[]}	The array of the matched tokens.
- */
-const matchWordFormInTokens = ( tokens, wordForm, locale ) => {
-	let matches = [];
-
-	tokens.forEach( token => {
-		const occurrence = matchTextWithTransliteration( token.text, wordForm, locale );
-		if ( occurrence.length > 0 ) {
-			matches = matches.concat( token );
-		}
-	} );
-
-	return matches;
-};
-
-/**
- * Finds keyphrase forms in a sentence.
- *
- * @param {Sentence|string}	sentence				The sentence to check.
- * @param {string[]}		wordForms				The word forms of the keyphrase to check.
- * @param {string}			locale					The locale used in the analysis.
- * @param {function}		matchWordCustomHelper	Custom function to match a word form with sentence.
- *
- * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.
- */
-const matchWordFormsInSentence = ( sentence, wordForms, locale, matchWordCustomHelper ) => {
-	const result = {
-		count: 0,
-		matches: [],
-	};
-
-	wordForms.forEach( wordForm => {
-		let occurrences = [];
-		if ( matchWordCustomHelper ) {
-			occurrences = matchWordCustomHelper( sentence, wordForm );
-		} else {
-			const tokens = sentence.tokens.slice();
-			occurrences = matchWordFormInTokens( tokens, wordForm, locale );
-		}
-		result.count += occurrences.length;
-		result.matches = result.matches.concat( occurrences );
-	} );
-
-	return result;
-};
-
-/**
- * Matches the word forms of a keyphrase with a sentence object from the html parser.
- *
- * @param {Sentence|string}	sentence					The sentence to match against the word forms of a keyphrase.
- * @param {string[]}		wordForms					The array of word forms of the keyphrase.
- * E.g. If the keyphrase is "key word", then (if Premium is activated) this will be [ "key", "keys" ] OR [ "word", "words" ]
- * The forms are retrieved higher up (among others in keywordCount.js) with researcher.getResearch( "morphology" ).
- * @param {string}			locale						The locale used for transliteration.
- * @param {function}		matchWordCustomHelper		Custom function to match a word form with sentence.
- * @param {boolean}			useExactMatching			Whether to match the keyphrase forms exactly or not.
- * 														Exact match is used when the keyphrase is enclosed in double quotes.
- * @param {function}		customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
- *
- * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.
- */
-const matchWordFormsWithSentence = ( sentence, wordForms, locale, matchWordCustomHelper, useExactMatching = false, customSplitIntoTokensHelper ) => {
-	/*
-	 * Only use `findExactMatchKeyphraseInSentence` when the custom helper is not available.
-	 * When the custom helper is available, the step for the exact matching happens in the helper.
-	 */
-	if ( useExactMatching && ! matchWordCustomHelper ) {
-		return findExactMatchKeyphraseInSentence( sentence, wordForms, locale, customSplitIntoTokensHelper );
-	}
-	return matchWordFormsInSentence( sentence, wordForms, locale, matchWordCustomHelper );
-};
-
-export default matchWordFormsWithSentence;

package/src/languageProcessing/helpers/match/processExactMatchRequest.js

@@ -1,20 +0,0 @@
-import isDoubleQuoted from "./isDoubleQuoted";
-
-/**
- * Checks if exact match functionality is requested by enclosing the keyphrase in double quotation marks.
- *
- * @param {string}  keyphrase       The keyphrase to check. This must be the keyphrase accessed directly from the Paper.
- *
- * @returns {Object} Whether the exact match functionality is requested and the keyword stripped from double quotes.
- */
-export default function processExactMatchRequest( keyphrase ) {
-	const exactMatchRequest = { exactMatchRequested: false, keyphrase: keyphrase };
-
-	// Check if only exact match processing is requested by the user. If so, strip the quotation marks from the keyphrase.
-	if ( isDoubleQuoted( keyphrase ) ) {
-		exactMatchRequest.keyphrase = keyphrase.substring( 1, keyphrase.length - 1 );
-		exactMatchRequest.exactMatchRequested = true;
-	}
-
-	return exactMatchRequest;
-}

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

@@ -1,11 +0,0 @@
-/**
- * Base stemmer that does not stem.
- * This is exported to allow for comparing if a stemmer is the base stemmer.
- *
- * @param {string} word The word to stem.
- *
- * @returns {string} The stemmed word.
- */
-export default function baseStemmer( word ) {
-	return word;
-}

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

@@ -1,19 +0,0 @@
-/**
- * Checks if the input word qualifies for the input regex and if so builds a required form.
- * This function is used for other more specific functions.
- *
- * @param {string} word The word to build forms for.
- * @param {Array} regexes The regex-based array of rules to compare the word against.
- *
- * @returns {string} The newly built form of the word.
- */
-export default function buildFormRule( word, regexes ) {
-	if ( regexes.includes( null ) ) {
-		return word;
-	}
-	for ( let i = 0; i < regexes.length; i++ ) {
-		if ( regexes[ i ].reg.test( word ) === true ) {
-			return word.replace( regexes[ i ].reg, regexes[ i ].repl );
-		}
-	}
-}

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

@@ -1,169 +0,0 @@
-import getWords from "../word/getWords.js";
-import { normalizeSingle } from "../sanitize/quotes";
-import { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from "../../../config/wordBoundariesWithoutPunctuation";
-
-import { isUndefined, escapeRegExp, memoize } from "lodash";
-import isDoubleQuoted from "../match/isDoubleQuoted";
-
-/**
- * A TopicPhrase (i.e., a keyphrase or synonym) with stem-original pairs for the words in the topic phrase.
- */
-class TopicPhrase {
-	/**
-	 * Constructs a new TopicPhrase.
-	 *
-	 * @param {StemOriginalPair[]} stemOriginalPairs The stem-original pairs for the words in the topic phrase.
-	 * @param {boolean}            exactMatch        Whether the topic phrase is an exact match.
-	 *
-	 * @constructor
-	 */
-	constructor( stemOriginalPairs = [], exactMatch = false ) {
-		this.stemOriginalPairs = stemOriginalPairs;
-		this.exactMatch = exactMatch;
-	}
-
-	/**
-	 * Returns all stems in the topic phrase.
-	 *
-	 * @returns {string[]|[]} The stems in the topic phrase or empty array if the topic phrase is exact match.
-	 */
-	getStems() {
-		// An exact match keyphrase doesn't have stems.
-		if ( this.exactMatch ) {
-			return [];
-		}
-
-		return this.stemOriginalPairs.map( stemOriginalPair => stemOriginalPair.stem );
-	}
-}
-
-/**
- * A stem-original pair ƒor a word in a topic phrase.
- *
- * @param {string} stem     The stem of the topic phrase word.
- * @param {string} original The original word form the topic phrase (unsanitized)
- *
- * @constructor
- */
-function StemOriginalPair( stem, original ) {
-	this.stem = stem;
-	this.original = original;
-}
-
-/**
- * Analyzes the focus keyword string or one synonym phrase.
- * Checks if morphology is requested or if the user wants to match the exact string.
- * If morphology is required, the module finds a stem for all words (if no function words list is available), or
- * for all content words (i.e., excluding prepositions, articles, conjunctions, if the function words list is available).
- *
- * @param {string}   keyphrase     				The keyphrase of the paper (or a synonym phrase) to get stem for.
- * @param {function} stemmer       				The language-specific stemmer.
- * @param {string[]} functionWords 				The language-specific function words.
- * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
- *
- * @returns {TopicPhrase} Object with an array of StemOriginalPairs of all (content) words in the keyphrase or synonym
- * phrase and information about whether the keyphrase/synonym should be matched exactly.
- */
-const buildStems = function( keyphrase, stemmer, functionWords, areHyphensWordBoundaries ) {
-	if ( isUndefined( keyphrase ) || keyphrase === "" ) {
-		return new TopicPhrase();
-	}
-
-	// If the keyphrase is embedded in double quotation marks, return the keyphrase itself, without the outermost quotation marks.
-	if ( isDoubleQuoted( keyphrase ) ) {
-		keyphrase = keyphrase.substring( 1, keyphrase.length - 1 );
-		return new TopicPhrase(
-			[ new StemOriginalPair( escapeRegExp( keyphrase ), keyphrase ) ],
-			true
-		);
-	}
-
-	/*
-	 * 	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.
-	 */
-	let keyphraseWords = areHyphensWordBoundaries ? getWords( keyphrase, WORD_BOUNDARY_WITH_HYPHEN )
-		: getWords( keyphrase, WORD_BOUNDARY_WITHOUT_HYPHEN );
-
-	// Filter function words from the keyphrase. Don't filter if the keyphrase only consists of function words.
-	const wordsWithoutFunctionWords = keyphraseWords.filter( ( word ) => ! functionWords.includes( word ) );
-	if ( wordsWithoutFunctionWords.length > 0 ) {
-		keyphraseWords = wordsWithoutFunctionWords;
-	}
-
-	// Return a stem-original pair with a stem.
-	const stemOriginalPairs = keyphraseWords.map( word => {
-		return new StemOriginalPair( stemmer( normalizeSingle( escapeRegExp( word ) ) ), word );
-	} );
-
-	return new TopicPhrase( stemOriginalPairs );
-};
-
-/**
- * Builds stems of words of the keyphrase and of each synonym phrase.
- *
- * @param {string}   keyphrase     				The paper's keyphrase.
- * @param {string[]} synonyms     				The paper's synonyms.
- * @param {function} stemmer       				The language-specific stemmer (if available).
- * @param {string[]} functionWords 				The language-specific function words.
- * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
- *
- * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.
- */
-const collectKeyphraseAndSynonymsStems = function( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {
-	const keyphraseStems = buildStems( keyphrase, stemmer, functionWords, areHyphensWordBoundaries );
-	const synonymsStems = synonyms.map( synonym => buildStems( synonym, stemmer, functionWords, areHyphensWordBoundaries ) );
-
-	return {
-		keyphraseStems,
-		synonymsStems,
-	};
-};
-
-/**
- * Caches stems depending on the currently available stemmer and functionWords and (separately) keyphrase and synonyms.
- * In this way, if the stemmer and functionWords remain the same in multiple calls of this function, the function
- * that collects actual stems only needs to check if the keyphrase and synonyms also remain the
- * same to return the cached result. The joining of keyphrase and synonyms for this function is needed,
- * because by default memoize caches by the first key only, which in the current case would mean that the function would
- * return the cached forms if the keyphrase has not changed (without checking if synonyms were changed).
- *
- * @param {function} stemmer       				The language-specific stemmer (if available).
- * @param {string[]} functionWords 				The language-specific function words.
- * @param {boolean}	 areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
- *
- * @returns {function} The function that collects the stems for a given set of keyphrase, synonyms, stemmer and functionWords.
- */
-const primeLanguageSpecificData = memoize( ( stemmer, functionWords, areHyphensWordBoundaries ) => {
-	return memoize( ( keyphrase, synonyms ) => {
-		return collectKeyphraseAndSynonymsStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries );
-	}, ( keyphrase, synonyms ) => {
-		return keyphrase + "," + synonyms.join( "," );
-	} );
-} );
-
-/**
- * Retrieves stems of words of the keyphrase and of each synonym phrase using the function that caches
- * the results of previous calls of this function.
- *
- * @param {string}      keyphrase       			The paper's keyphrase.
- * @param {string[]}    synonyms        			The paper's synonyms.
- * @param {function}    stemmer         			The language-specific stemmer (if available).
- * @param {string[]}    functionWords   			The language-specific function words.
- * @param {boolean}		areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
- *
- * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.
- */
-function collectStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {
-	const collectStemsWithLanguageSpecificData = primeLanguageSpecificData( stemmer, functionWords, areHyphensWordBoundaries );
-
-	return collectStemsWithLanguageSpecificData( keyphrase, synonyms );
-}
-
-export {
-	buildStems,
-	collectStems,
-	TopicPhrase,
-	StemOriginalPair,
-	primeLanguageSpecificData,
-};

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

@@ -1,45 +0,0 @@
-/**
- * Creates an object with a regex and a replacement pair to be processed.
- *
- * @param {Array}   rule        A pair or triplet of strings of which the first one is the regex to match
- *                              and the second (and the third) is the replacement.
- * @param {string}  [flags=i]   The regex flags to use.
- *
- * @returns {{ reg: RegExp, repl: string }|{ reg: RegExp, repl1: string, repl2: string }|null} Object to be used in the regex-based rules.
- */
-const createSingleRuleFromArray = function( rule, flags = "i" ) {
-	if ( rule.length === 2 ) {
-		return {
-			reg: new RegExp( rule[ 0 ], flags ),
-			repl: rule[ 1 ],
-		};
-	}
-	if ( rule.length === 3 ) {
-		return {
-			reg: new RegExp( rule[ 0 ], flags ),
-			repl1: rule[ 1 ],
-			repl2: rule[ 2 ],
-		};
-	}
-	return null;
-};
-
-/**
- * Creates an array of objects with a regex and a replacement pair to be processed.
- *
- * @param {Array}   rules       An array with pairs or triplets of strings of which the first one is the regex to match
- *                              and the second (and the third) is the replacement.
- * @param {string} [flags=i]    The regex flags to use.
- *
- * @returns {Array} Array of objects to be used in the regex-based rules.
- */
-const createRulesFromArrays = function( rules, flags = "i" ) {
-	return rules.map( rule => createSingleRuleFromArray( rule, flags ) );
-};
-
-export {
-	createSingleRuleFromArray,
-	createRulesFromArrays,
-};
-
-export default createRulesFromArrays;

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

@@ -1,65 +0,0 @@
-import flattenSortLength from "./flattenSortLength";
-
-/**
- * Checks whether the word ends in one of the words in an exception list that is a simple array.
- *
- * @param {string}	    word            The word to check.
- * @param {string[]}	exceptionList	The list of exceptions.
- *
- * @returns {boolean}	Whether the checked word ends in one of the words in the exception list.
- */
-export function checkIfWordEndingIsOnExceptionList( word, exceptionList ) {
-	for ( let i = 0; i < exceptionList.length; i++ ) {
-		if ( word.endsWith( exceptionList[ i ] ) ) {
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * Checks whether a word is on the list of words that can have a prefix or not. Before checking the list, checks whether the word has a prefix
- * and if it does, removes it.
- *
- * @param {string}	 	word					The word to check.
- * @param {string[]}	exceptionList			The list of exceptions.
- * @param {Object}		prefixesObject	        An Object that contains the arrays of prefixes.
- *
- * @returns {boolean}	Whether the word was found on the exception list or not.
- */
-export function checkIfWordIsOnListThatCanHavePrefix( word, exceptionList, prefixesObject ) {
-	const prefixes = flattenSortLength( prefixesObject );
-
-	// Check whether the inputted word starts with one of the prefixes
-	const foundPrefix = prefixes.find( prefix => word.startsWith( prefix ) );
-	let stemmedWordWithoutPrefix = "";
-
-	if ( typeof( foundPrefix ) === "string" ) {
-		stemmedWordWithoutPrefix = word.slice( foundPrefix.length );
-		// At least 3 characters left after prefix deletion so that e.g. "be" is not treated as a prefix if found in the word "berg".
-		if ( stemmedWordWithoutPrefix.length > 2 ) {
-			word = stemmedWordWithoutPrefix;
-		}
-	}
-
-	return exceptionList.includes( word );
-}
-
-/**
- * Checks whether the word ends in one of the words in an exception list with two stems.
- *
- * @param {Array} exceptionListWithTwoStems The exception list with two stems.
- * @param {string} word	The word to check.
- *
- * @returns {string} The stem.
- */
-export function checkExceptionListWithTwoStems( exceptionListWithTwoStems, word ) {
-	for ( const stemSet of exceptionListWithTwoStems ) {
-		const foundStem =  stemSet.find( stemWord => word.endsWith( stemWord ) );
-		if ( foundStem ) {
-			const precedingLexicalMaterial = word.slice( 0, word.length - foundStem.length );
-
-			return precedingLexicalMaterial + stemSet[ 0 ];
-		}
-	}
-}

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

@@ -1,24 +0,0 @@
-/**
- * Loops through an array of word endings and returns the longest ending that was matched at the end of the string.
- *
- * @param {string}      string       The string to check.
- * @param {string[]}    endings    The word endings to check.
- * @returns {string}    The longest matched ending.
- */
-export default function findMatchingEndingInArray( string, endings ) {
-	const matches = [];
-	for ( const i in endings ) {
-		if ( string.endsWith( endings[ i ] ) ) {
-			matches.push( endings[ i ] );
-		}
-	}
-
-	const longest = matches.sort( function( a, b ) {
-		return b.length - a.length;
-	} )[ 0 ];
-
-	if ( longest ) {
-		return longest;
-	}
-	return "";
-}