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

package/src/languageProcessing/languages/ar/helpers/internal/stem.js

@@ -0,0 +1,632 @@
+/**
+ * Copyright (c) 2015 Mouaffak A. Sarhan
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Tries to match a word with a regex. If matched, modifies the string according to the indicated pattern.
+ *
+ * @param {string}		word				The word to check.
+ * @param {string[]}	regexAndReplacement	The regex to match the word with and what the word should be replaced with if it is matched.
+ *
+ * @returns {string}	The modified word or the original word if it was not matched.
+ */
+const matchWithRegexAndReplace = function( word, regexAndReplacement ) {
+	return word.replace( new RegExp( regexAndReplacement[ 0 ] ),
+		regexAndReplacement[ 1 ] );
+};
+
+/**
+ * Check if the word is on the list of three-letter roots which had the last weak letter removed (so are now two letters long).
+ * If the word is on the list, add back the removed last letter and return the three-letter root.
+ * Examples: طر -> طري (word with last weak letter ي (yeh) removed) , حص -> حصا (word with last weak letter ا (alef) removed)
+ *
+ * @param {string}	word			The two-letter word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string|null}	The word with the last weak letter added back or null if the word was not found on a list.
+ */
+const checkWordsWithRemovedLastLetter = function( word, morphologyData ) {
+	const externalStemmer = morphologyData.externalStemmer;
+	const characters = externalStemmer.characters;
+
+	if ( externalStemmer.wordsWithLastAlefRemoved.includes( word ) ) {
+		return word + characters.alef;
+	}
+	if ( externalStemmer.wordsWithLastHamzaRemoved.includes( word ) ) {
+		return word + characters.alef_hamza_above;
+	}
+	if ( externalStemmer.wordsWithLastMaksoraRemoved.includes( word ) ) {
+		return word + characters.yeh_maksorah;
+	}
+	if ( externalStemmer.wordsWithLastYehRemoved.includes( word ) ) {
+		return word + characters.yeh;
+	}
+};
+
+/**
+ * Check if the word is on the list of three-letter roots which had the first weak letter removed (so are now two letters long).
+ * If the word is on the list, add back the removed first letter and return the three-letter root.
+ * Examples: مض -> ومض (word with first weak letter و (waw) removed) , سن -> يسن (word with first weak letter ي (yeh) removed)
+ *
+ * @param {string}	word			The two-letter word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string|null}	The word with the first weak letter added back or null if the word was not found on any list.
+ */
+const checkWordsWithRemovedFirstLetter = function( word, morphologyData ) {
+	const externalStemmer = morphologyData.externalStemmer;
+	const characters = externalStemmer.characters;
+
+	if ( externalStemmer.wordsWithFirstWawRemoved.includes( word ) ) {
+		return characters.waw + word;
+	}
+	if ( externalStemmer.wordsWithFirstYehRemoved.includes( word ) ) {
+		return characters.yeh + word;
+	}
+};
+
+/**
+ * Check if the word is on the list of three-letter roots which had the middle weak letter removed (so are now two letters long).
+ * If the word is on the list, add back the removed middle letter and return the three-letter root.
+ * Examples: غز -> غوز (word with middle weak letter و (waw) removed), لن -> لين (word with middle weak letter ي (yeh) removed)
+ *
+ * @param {string}	word			The two-letter word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string|null}	The word with the middle weak letter added back or null if the word was not found on a list.
+ */
+const checkWordsWithRemovedMiddleLetter = function( word, morphologyData ) {
+	const externalStemmer = morphologyData.externalStemmer;
+	const characters = externalStemmer.characters;
+
+	if ( externalStemmer.wordsWithMiddleWawRemoved.includes( word ) ) {
+		return word[ 0 ] + characters.waw + word[ 1 ];
+	}
+	if ( externalStemmer.wordsWithMiddleYehRemoved.includes( word ) ) {
+		return word[ 0 ] + characters.yeh + word[ 1 ];
+	}
+};
+
+
+/**
+ * Find the root of two-letter words. Two-letter words usually come from three-letter roots for which a letter was deleted
+ * as it is a duplicated last letter or a weak letter.
+ *
+ * @param {string}	word			The two-letter word to process.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string}	The three-letter root or the input word if no root was found.
+ */
+const processTwoLetterWords = function( word, morphologyData ) {
+	// Check whether the word is on the list of words with removed duplicate last letter. If it is, add back the removed letter to get the root.
+	if ( morphologyData.externalStemmer.wordsWithRemovedDuplicateLetter.includes( word ) ) {
+		return word + word.substring( 1 );
+	}
+	// Check whether the word is on one of the lists of words with removed weak letter or hamza.
+	const wordAfterLastLetterCheck = checkWordsWithRemovedLastLetter( word, morphologyData );
+	if ( wordAfterLastLetterCheck ) {
+		return wordAfterLastLetterCheck;
+	}
+	const wordAfterFirstLetterCheck = checkWordsWithRemovedFirstLetter( word, morphologyData );
+	if ( wordAfterFirstLetterCheck ) {
+		return wordAfterFirstLetterCheck;
+	}
+	const wordAfterMiddleLetterCheck = checkWordsWithRemovedMiddleLetter( word, morphologyData );
+	if ( wordAfterMiddleLetterCheck ) {
+		return wordAfterMiddleLetterCheck;
+	}
+
+	return word;
+};
+
+/**
+ * Remove the middle/last weak letter or hamza in a three letter word. Find its root by checking the appropriate exception lists
+ * (words with middle letter removed or words with last letter removed) and attaching the removed letter back.
+ * Example: بدء -> بد -> بدأ (three letter word with (ء) hamza ending,
+ * which is found on the list of words with last letter removed after removing the suffix)
+ *
+ * @param {string}		word					The three-letter word to check.
+ * @param {Object}		morphologyData			The Arabic morphology data.
+ * @param {string[]}	replacementPattern		The regex to find and remove middle or last weak letter/hamza in three letter words
+ * @param {function}	functionToRunToGetRoot	The function that checks lists of words with either middle or last letter removed
+ * 												and attaches it back.
+ *
+ * @returns {string|null}	The root or null if no root was found.
+ */
+const processThreeLetterWordsWithWeakLetterOrHamza = function( word, morphologyData, replacementPattern, functionToRunToGetRoot ) {
+	// Find and remove middle or last weak letter or hamza
+	const wordAfterRemovingWeakLetterOrHamza = word.replace( new RegExp( replacementPattern[ 0 ] ),
+		replacementPattern[ 1 ] );
+	if ( wordAfterRemovingWeakLetterOrHamza !== word ) {
+		/*
+		 * If the weak letter or hamza was removed, get the root by checking lists of words with middle/last weak letter
+		 * or hamza removed and attaching it back.
+		 */
+		return functionToRunToGetRoot( wordAfterRemovingWeakLetterOrHamza, morphologyData );
+	}
+};
+
+/**
+ * Get the root of three letter words.
+ * Examples: ؤكد -> أكد (three letter word with ؤ (waw_hamza) beginning, قدّ -> قدد (three letter word which has a shadda on the second letter)
+ *
+ * @param {string}	word			The three-letter word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string|null}	The root or the original input word (which may already be the root).
+ */
+const processThreeLetterWords = function( word, morphologyData ) {
+	const characters = morphologyData.externalStemmer.characters;
+
+	// If the word exists on the list of three letter roots, return the word.
+	if ( morphologyData.externalStemmer.threeLetterRoots.includes( word ) ) {
+		return word;
+	}
+	// If the first letter is ا/ ؤ/ ئ (yeh_hamza/waw_hamza/alef), change it to أ (alef_hamza_above).
+	if ( word[ 0 ] === characters.alef || word[ 0 ] === characters.waw_hamza ||
+			word[ 0 ] === characters.yeh_hamza ) {
+		word = characters.alef_hamza_above + word.slice( 1 );
+	}
+
+	// If the last letter is a weak letter or a hamza, check if the word is a root that may get the last weak letter/hamza removed.
+	const wordAfterLastWeakLetterOrHamzaCheck = processThreeLetterWordsWithWeakLetterOrHamza( word, morphologyData,
+		morphologyData.externalStemmer.regexRemoveLastWeakLetterOrHamza, checkWordsWithRemovedLastLetter );
+	if ( wordAfterLastWeakLetterOrHamzaCheck ) {
+		return wordAfterLastWeakLetterOrHamzaCheck;
+	}
+
+	// If the middle letter is a waw, yeh, alef or a yeh_hamza, check if the word is a root that may get the middle weak letter/hamza removed..
+	const wordAfterMiddleWeakLetterOrHamzaCheck = processThreeLetterWordsWithWeakLetterOrHamza( word, morphologyData,
+		morphologyData.externalStemmer.regexRemoveMiddleWeakLetterOrHamza, checkWordsWithRemovedMiddleLetter );
+	if ( wordAfterMiddleWeakLetterOrHamzaCheck ) {
+		return wordAfterMiddleWeakLetterOrHamzaCheck;
+	}
+
+	const regexReplaceMiddleLetterWithAlef = morphologyData.externalStemmer.regexReplaceMiddleLetterWithAlef;
+	const regexReplaceMiddleLetterWithAlefWithHamza = morphologyData.externalStemmer.regexReplaceMiddleLetterWithAlefWithHamza;
+
+	// If the word has ئ/ؤ (yeh_hamza/waw_hamza) as the second letter and ends in ر/ز/ن (noon/zai/reh), change ئ/ؤ (yeh_hamza/waw_hamza) to ا (alef).
+	const wordAfterReplacingMiddleLetterWithAlef = word.replace( new RegExp( regexReplaceMiddleLetterWithAlef[ 0 ] ),
+		regexReplaceMiddleLetterWithAlef[ 1 ] );
+	if ( wordAfterReplacingMiddleLetterWithAlef === word ) {
+		// If the second letter is a ئ/ؤ (yeh_hamza/waw_hamza) and it doesn't end in noon/zai/reh, change ئ/ؤ d to أ (alef_hamza_above).
+		word = word.replace( new RegExp( regexReplaceMiddleLetterWithAlefWithHamza[ 0 ] ),
+			regexReplaceMiddleLetterWithAlefWithHamza[ 1 ] );
+	} else {
+		word = wordAfterReplacingMiddleLetterWithAlef;
+	}
+	// If the last letter is a shadda, remove it and duplicate the last letter.
+	const regexRemoveShaddaAndDuplicateLastLetter = morphologyData.externalStemmer.regexRemoveShaddaAndDuplicateLastLetter;
+	word = word.replace( new RegExp( regexRemoveShaddaAndDuplicateLastLetter[ 0 ] ),
+		regexRemoveShaddaAndDuplicateLastLetter[ 1 ] );
+
+	return word;
+};
+
+/**
+ * Check whether the word matches the pattern (it is a 6 letter-word, the fourth and sixth letter are the same, and the pattern
+ * and the word share two same letters at the same index). If it does, remove the first character and the two last characters and
+ * get the root.
+ * Example: احولال -> حول (the stem is the 2nd to 4th character)
+ *
+ * @param {string}	word				The word to check.
+ * @param {number}	numberSameLetters	The number of letters the word and the pattern share at the same index.
+ * @param {Object}	morphologyData		The Arabic morphology data.
+ *
+ * @returns {string} The root or the original word if word was not matched by the pattern.
+ */
+const checkFirstPatternAndGetRoot = function( word, numberSameLetters, morphologyData ) {
+	if ( word.length === 6 && word[ 3 ] === word[ 5 ] && numberSameLetters === 2 ) {
+		return processThreeLetterWords( word.substring( 1, 4 ), morphologyData );
+	}
+	return word;
+};
+
+/**
+ * Checks whether the word matches the pattern (the word shares three characters with the pattern) and get the root if it does.
+ * Example: استكتب -> كتب (A word that matches pattern (استفعل))
+ *
+ * @param {string}	word				The word to check.
+ * @param {string}	pattern				The pattern to check.
+ * @param {number}	numberSameLetters	The number of letters the word and the pattern share at the same index.
+ * @param {Object}	morphologyData		The Arabic morphology data.
+ *
+ * @returns {string} The root or the original word if no root was found.
+ */
+const checkSecondPatternAndGetRoot = function( word, pattern, numberSameLetters, morphologyData ) {
+	const characters = morphologyData.externalStemmer.characters;
+	// If the word length minus three is equal to or less than the number of same letters found in the checkPatterns function.
+	if ( word.length - 3 <= numberSameLetters ) {
+		let root = "";
+		for ( let i = 0; i < word.length; i++ ) {
+			if ( pattern[ i ] === characters.feh ||
+				pattern[ i ] === characters.aen ||
+				pattern[ i ] === characters.lam ) {
+				root = root.concat( word[ i ] );
+			}
+		}
+
+		return processThreeLetterWords( root, morphologyData );
+	}
+	return word;
+};
+
+/**
+ * Count the number of letters the word and the pattern to match with share at the same index.
+ *
+ * @param {string}	word			The word to check.
+ * @param {string}	pattern			The pattern to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {number}	The number of shared letters between the word and the pattern at the same index.
+ */
+const countSharedLettersBetweenWordAndPattern = function( word, pattern, morphologyData ) {
+	const characters = morphologyData.externalStemmer.characters;
+
+	let numberSameLetters = 0;
+	for ( let i = 0; i < word.length; i++ ) {
+		if ( pattern[ i ] === word[ i ] &&
+			pattern[ i ] !== characters.feh &&
+			pattern[ i ] !== characters.aen &&
+			pattern[ i ] !== characters.lam ) {
+			numberSameLetters++;
+		}
+	}
+	return numberSameLetters;
+};
+
+/**
+ * Check if a word matches a specific pattern of letters, and if it does, modify the word to get the root.
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null} An object with either the root or the modified word and the information whether the root was found,
+ * 						  or null if the word was not modified and the root was not found.
+ */
+const checkPatterns = function( word, morphologyData ) {
+	// If the first letter is an alef_madda, alef_hamza_above, or alef_hamza_below (أ/إ/آ), change it to an alef (ا)
+	const wordAfterModification = matchWithRegexAndReplace( word, morphologyData.externalStemmer.regexReplaceFirstHamzaWithAlef );
+
+	// Try and find a pattern that matches the word
+	for ( const pattern of morphologyData.externalStemmer.patterns ) {
+		if ( pattern.length === wordAfterModification.length ) {
+			// Count the number of letters the word and the pattern share at the same index.
+			const numberSameLetters = countSharedLettersBetweenWordAndPattern( wordAfterModification, pattern, morphologyData );
+
+			const wordAfterCheckingFirstPattern = checkFirstPatternAndGetRoot( wordAfterModification, numberSameLetters, morphologyData );
+			if ( wordAfterCheckingFirstPattern !== wordAfterModification ) {
+				return { word: wordAfterCheckingFirstPattern, rootFound: true };
+			}
+
+			const wordAfterCheckingSecondPattern = checkSecondPatternAndGetRoot( wordAfterModification, pattern, numberSameLetters, morphologyData );
+			if ( wordAfterCheckingSecondPattern !== wordAfterModification ) {
+				return { word: wordAfterCheckingSecondPattern, rootFound: true };
+			}
+		}
+	}
+
+	// If a pattern was not matched but the word was modified, return the modified word.
+	if ( wordAfterModification !== word ) {
+		return { word: wordAfterModification, rootFound: false };
+	}
+};
+
+/**
+ * Tries to find the root of two-, three- and four-letter words by checking lists and/or applying modifications to the word.
+ *
+ * Example: the word أبطر is on the list of four-letter roots.
+ *
+ * @param {string} 	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string|null} The root or null if the root was not found.
+ */
+const checkIfWordIsRoot = function( word, morphologyData ) {
+	// Check if the word consists of two letters and find its root.
+	if ( word.length === 2 ) {
+		return processTwoLetterWords( word, morphologyData );
+	}
+	// Check if the word consists of three letters.
+	if ( word.length === 3 ) {
+		return processThreeLetterWords( word, morphologyData );
+	}
+	// If the word consists of four letters, check if it is on the list of four-letter roots.
+	if ( word.length === 4 ) {
+		if ( morphologyData.externalStemmer.fourLetterRoots.includes( word ) ) {
+			return word;
+		}
+	}
+};
+
+/**
+ * Checks whether the word ends in a suffix, and removes it if it does.
+ *
+ * @param {string}		word		The word to check.
+ * @param {string[]}	suffixes	The suffixes to check.
+ *
+ * @returns {string}	The word with the suffix removed or the input word if no suffix was found.
+ */
+const removeSuffix = function( word, suffixes ) {
+	for ( const suffix of suffixes ) {
+		if ( word.endsWith( suffix ) ) {
+			return word.slice( 0, -suffix.length );
+		}
+	}
+	return word;
+};
+
+/**
+ * Checks whether the word starts with a prefix, and removes it if it does.
+ *
+ * @param {string}		word		The word to check.
+ * @param {string[]}	prefixes	The prefixes to check.
+ *
+ * @returns {string}	The word with the prefix removed or the input word if no prefix was found.
+ */
+const removePrefix = function( word, prefixes ) {
+	for ( const prefix of prefixes ) {
+		if ( word.startsWith( prefix ) ) {
+			return word.substring( prefix.length, word.length );
+		}
+	}
+	return word;
+};
+
+/**
+ * Searches for a suffix, removes it if found, and tries to find the root of the stemmed word. If the root is not found, the
+ * function returns null, with one exception: it is possible that in the checkPatterns function that is ran inside of this one,
+ * the word is modified but no root is found. In this case, the function returns the modified word.
+ *
+ * Example: جمعكم -> جمع (word with suffix كم which is found on the list of three-letter roots after removing the suffix).
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null} An object with the root/modified word and information about whether the root was found, or null if
+ * 						  the word is not modified and no root is found.
+ */
+const processWordWithSuffix = function( word, morphologyData ) {
+	// Find and remove suffix.
+	const wordAfterRemovingSuffix = removeSuffix( word, morphologyData.externalStemmer.suffixes );
+	if ( wordAfterRemovingSuffix !== word ) {
+		// If suffix was removed, check if the stemmed word is a root.
+		const root = checkIfWordIsRoot( wordAfterRemovingSuffix, morphologyData );
+		if ( root ) {
+			return { word: root, rootFound: true };
+		}
+		// If no root was found, try to get the root by matching with a pattern.
+		const outputAfterCheckingPatterns = checkPatterns( wordAfterRemovingSuffix, morphologyData );
+		if ( outputAfterCheckingPatterns ) {
+			return outputAfterCheckingPatterns;
+		}
+	}
+};
+
+/**
+ * Searches for a prefix (other than the definite article), removes it if found, and tries to find the root of the stemmed
+ * word. If the root is not found, the function returns null, with one exception: it is possible that in the checkPatterns
+ * function that is ran inside of this one, the word is modified but no root is found. In this case, the function returns
+ * the modified word.
+ *
+ * Example: للزهور -> زهر (word with prefix لل that gets its root by matching with a pattern after removing the prefix).
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null}	An object with the root/modified word and information about whether the root was found, or null if
+ * 						    the word is not modified and no root is found.
+ */
+const processWordWithPrefix = function( word, morphologyData ) {
+	// Find and remove prefix.
+	let wordAfterRemovingPrefix = removePrefix( word, morphologyData.externalStemmer.prefixes );
+	if ( wordAfterRemovingPrefix !== word ) {
+		// If prefix was removed, check if the stemmed word is a root.
+		const root = checkIfWordIsRoot( wordAfterRemovingPrefix, morphologyData );
+		if ( root ) {
+			return { word: root, rootFound: true };
+		}
+		// If no root was found, try to get the root by matching with a pattern.
+		const outputAfterCheckingPatterns = checkPatterns( wordAfterRemovingPrefix, morphologyData );
+		if ( outputAfterCheckingPatterns ) {
+			if ( outputAfterCheckingPatterns.rootFound === true ) {
+				return outputAfterCheckingPatterns;
+			}
+			wordAfterRemovingPrefix = outputAfterCheckingPatterns.word;
+		}
+		// If the root was still not found, try to find and remove suffixes and find the root again.
+		const outputAfterCheckingForSuffixes = processWordWithSuffix( wordAfterRemovingPrefix, morphologyData );
+		if ( outputAfterCheckingForSuffixes ) {
+			return outputAfterCheckingForSuffixes;
+		}
+	}
+};
+
+/**
+ * Checks if the word is a root. If root is not found, checks whether the root can be derived using a pattern. If the root is
+ * still not found, removes affixes and tries to find the root again. If the root is not found, the function returns null,
+ * with one exception: it is possible that in the checkPatterns function that is ran inside of this one, the word is modified
+ * but no root is found. In this case, the function returns the modified word.
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null}	An object with the root/modified word and information about whether the root was found, or null if
+ * 						    the word is not modified and no root is found.
+ */
+const findRoot = function( word, morphologyData ) {
+	// Check if the word is a root.
+	const root = checkIfWordIsRoot( word, morphologyData );
+	if ( root ) {
+		return { word: root, rootFound: true };
+	}
+
+	// Check if the root can be derived by matching a pattern. إعدجص
+	const outputAfterCheckingPatterns = checkPatterns( word, morphologyData );
+	let stemmedWord = word;
+	if ( outputAfterCheckingPatterns ) {
+		if ( outputAfterCheckingPatterns.rootFound === true ) {
+			return outputAfterCheckingPatterns;
+		}
+		// Word: اعدجص
+		stemmedWord = outputAfterCheckingPatterns.word;
+	}
+	// Remove affixes and check if the stemmed word is a root
+	const outputAfterProcessingSuffix = processWordWithSuffix( stemmedWord, morphologyData );
+	if ( outputAfterProcessingSuffix ) {
+		return outputAfterProcessingSuffix;
+	}
+	const outputAfterRemovingPrefix = processWordWithPrefix( stemmedWord, morphologyData );
+	if ( outputAfterRemovingPrefix ) {
+		return outputAfterRemovingPrefix;
+	}
+
+	if ( stemmedWord !== word ) {
+		return { word: stemmedWord, rootFound: false };
+	}
+};
+
+/**
+ * Search for and remove a definite article and try to get the root of the word. If the root was not found, but the word
+ * was modified inside the checkPatterns function, returns the modified word. If the definite article was removed and the
+ * stemmed word is longer than three letters, but the root was not found, returns the stemmed word. Otherwise, if the root
+ * was not found, returns null.
+ *
+ * Example: الجدولين -> جدول (word with definite article ال and suffix ين ).
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null}	An object with the root/modified word and information about whether the root was found, or null if
+ * 						    the word is not modified and no root is found.
+ */
+const processWordWithDefiniteArticle = function( word, morphologyData ) {
+	// Search for and remove the definite article.
+	const wordAfterRemovingDefiniteArticle = removePrefix( word, morphologyData.externalStemmer.definiteArticles );
+	// If a definite article was removed, try to find the root.
+	if ( wordAfterRemovingDefiniteArticle !== word ) {
+		/**
+		 * If definite article was removed, try to find root by checking whether the word is a root, matching with a pattern, and/or
+		 * searching for and removing prefixes.
+		 */
+		const outputAfterTryingToFindRoot = findRoot( wordAfterRemovingDefiniteArticle, morphologyData );
+		if ( outputAfterTryingToFindRoot  ) {
+			return outputAfterTryingToFindRoot;
+		}
+
+		// Return it even if no root was found.
+		return { word: wordAfterRemovingDefiniteArticle, rootFound: false };
+	}
+};
+
+/**
+ * Searches for prefix waw (و) and removes it if found, then tries to find the root. If the root is still not found, removes
+ * affixes and tries to find the root again. If the root is not found, the function returns null, with one exception: it
+ * is possible that in the checkPatterns function that is ran inside of this one, the word is modified but no root is found.
+ * In this case, the function returns the modified word.
+ *
+ * Example: وتمثّل -> مثل (word with prefix waw which matches a pattern after removing the prefix).
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {Object|null}	An object with the root/modified word and information about whether the root was found, or null if
+ * 						    the word is not modified and no root is found.
+ */
+const processWordWithPrefixWaw = function( word, morphologyData ) {
+	let wordAfterRemovingWaw = "";
+	if ( word.length > 3 && word.startsWith( morphologyData.externalStemmer.characters.waw ) ) {
+		wordAfterRemovingWaw = word.substring( 1 );
+		/*
+		 * If the prefix waw was removed, try to find the root by checking whether the word is a root, matching with a pattern,
+		 * and/or searching for and removing prefixes.
+		 */
+		const outputAfterTryingToFindRoot = findRoot( wordAfterRemovingWaw, morphologyData );
+
+		if ( outputAfterTryingToFindRoot ) {
+			return outputAfterTryingToFindRoot;
+		}
+	}
+};
+
+/**
+ * Stems Arabic words.
+ *
+ * @param {string}	word			The word to stem.
+ * @param {Object}	morphologyData	The Arabic morphology data.
+ *
+ * @returns {string}	The stemmed word.
+ */
+export default function stem( word, morphologyData ) {
+	// Remove diacritics that serve as phonetic guides and are not usually used in regular writing.
+	const regexRemovingDiacritics = morphologyData.externalStemmer.regexRemovingDiacritics;
+	word.replace( new RegExp( regexRemovingDiacritics ), "" );
+
+	const root = checkIfWordIsRoot( word, morphologyData );
+	if ( root ) {
+		return root;
+	}
+	// If the root still hasn't been found, check if the word matches a pattern and get its root if it does.
+	const outputAfterCheckingPatterns = checkPatterns( word, morphologyData );
+	if ( outputAfterCheckingPatterns ) {
+		// Return the root if it was found in the checkPatterns function
+		if ( outputAfterCheckingPatterns.rootFound === true ) {
+			return outputAfterCheckingPatterns.word;
+		}
+		// If the checkPatterns function modified the word but did not find the root, replace the word with the modified word.
+		word = outputAfterCheckingPatterns.word;
+	}
+
+	// If the root still hasn't been found, remove the definite article and try to find the root.
+	const outputAfterProcessingDefiniteArticle = processWordWithDefiniteArticle( word, morphologyData );
+	if ( outputAfterProcessingDefiniteArticle ) {
+		// Return the root if it was found after removing the definite article.
+		if ( outputAfterProcessingDefiniteArticle.rootFound === true ) {
+			return outputAfterProcessingDefiniteArticle.word;
+		}
+		// If the definite article was removed but the root was not found, replace the word with the stemmed word.
+
+		word = outputAfterProcessingDefiniteArticle.word;
+	}
+
+	// If the root still hasn't been found, remove the prefix waw and try to find the root.
+	const outputAfterProcessingPrefixWaw = processWordWithPrefixWaw( word, morphologyData );
+	if ( outputAfterProcessingPrefixWaw ) {
+		if ( outputAfterProcessingPrefixWaw.rootFound === true ) {
+			return outputAfterProcessingPrefixWaw.word;
+		}
+		// If the checkPatterns function modified the word but did not find the root, replace the word with the modified word.
+		word = outputAfterProcessingPrefixWaw.word;
+	}
+	// If the root still hasn't been found, remove a suffix and try to find the root.
+	const outputAfterProcessingSuffix = processWordWithSuffix( word, morphologyData );
+	if ( outputAfterProcessingSuffix ) {
+		return outputAfterProcessingSuffix.word;
+	}
+
+	// If the root still hasn't been found, remove a prefix and try to find the root.
+	const wordAfterProcessingPrefix = processWordWithPrefix( word, morphologyData );
+	if ( wordAfterProcessingPrefix ) {
+		return wordAfterProcessingPrefix.word;
+	}
+
+	return word;
+}

package/src/languageProcessing/languages/ar/helpers/isPassiveSentence.js

@@ -0,0 +1,33 @@
+import getPassiveVerbs from '../config/internal/passiveVerbsWithLongVowel';
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+/**
+ * Checks the passed sentence to see if it contains Arabic passive verb-forms.
+ *
+ * @param {string} sentence     The sentence to match against.
+ *
+ * @returns {Boolean} Whether the sentence contains Arabic passive voice.
+ */
+export default function isPassiveSentence(sentence) {
+  const arabicPrepositionalPrefix = 'و';
+  const words = getWords(sentence);
+  const passiveVerbs = [];
+
+  for (let word of words) {
+    // Check if the word starts with prefix و
+    if (word.startsWith(arabicPrepositionalPrefix)) {
+      word = word.slice(1);
+    }
+    let wordWithDamma = -1;
+    // Check if the first character has a damma or if the word is in the list of Arabic passive verbs
+    if (word.length >= 2) {
+      wordWithDamma = word[1].search('\u064F');
+    }
+    if (wordWithDamma !== -1 || getPassiveVerbs.includes(word)) {
+      passiveVerbs.push(word);
+    }
+  }
+
+  return passiveVerbs.length !== 0;
+}