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

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

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

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

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

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

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

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

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

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

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

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

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

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