axyseo 2.0.0-alpha.1

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

@@ -0,0 +1,635 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stem;
+/**
+ * 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.
+ */
+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;
+}
+//# sourceMappingURL=stem.js.map