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

package/src/languageProcessing/languages/nl/helpers/internal/checkExceptionsWithFullForms.js

@@ -0,0 +1,128 @@
+import {flatten} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {flattenSortLength} = languageProcessing;
+
+/**
+ * Checks whether the word is on the verbs sub-list of the full forms list. Before checking the list, checks whether the word
+ * begins with one of the compound verb prefixes, and the prefix is removed if one is found. If a match is found after checking
+ * the full forms list, the canonical stem is returned, with the prefix attached back if there was one in the input word.
+ * e.g. aanbevelen -> aanbeveel
+ *
+ * @param {string}			word							The word to check.
+ * @param {string[]}		verbFullFormsList				The list of verb forms we search for match in.
+ * @param {Object}			compoundVerbPrefixes			The list of separable and inseparable compound verb prefixes.
+ *
+ * @returns {string|null}	The canonical stem or null if no match found.
+ */
+const checkVerbFullFormsList = function(word, verbFullFormsList, compoundVerbPrefixes) {
+  const prefixes = flattenSortLength(compoundVerbPrefixes);
+
+  // Check whether the inputted word starts with one of the compound prefixes
+  const foundPrefix = prefixes.find(prefix => word.startsWith(prefix));
+
+  if (typeof foundPrefix === 'string') {
+    word = word.slice(foundPrefix.length);
+  }
+
+  for (let i = 0; i < verbFullFormsList.length; i++) {
+    const stemAndForms = flatten(verbFullFormsList[i]);
+    for (let j = 0; j < stemAndForms.length; j++) {
+      if (stemAndForms.includes(word)) {
+        if (typeof foundPrefix === 'string') {
+          return foundPrefix + stemAndForms[0];
+        }
+        return stemAndForms[0];
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * Checks whether the word is on the sub-list of the full forms list for which we search for an ending match between one of
+ * the forms and the word (i.e., whether the word ends with a form from the list). If a match is found, the canonical
+ * stem is returned. e.g. fitnesscentra -> fitnesscentrum
+ *
+ * @param {string}			word							The word to check.
+ * @param {string[]}		endingMatchFullFormsList		The list we search for an ending match in.
+ * @returns {string|null}	The canonical stem or null if no match found.
+ */
+const checkEndingMatchFullFormsList = function(word, endingMatchFullFormsList) {
+  for (let i = 0; i < endingMatchFullFormsList.length; i++) {
+    const stemAndForms = flatten(endingMatchFullFormsList[i]);
+    for (let j = 0; j < stemAndForms.length; j++) {
+      if (word.endsWith(stemAndForms[j])) {
+        /*
+         * Check if the word checked is actually a compound word. e.g. familielid
+         * The character/s preceding the words in the exception should be at least 2 characters in order to be a valid compound element.
+         */
+        const precedingLexicalMaterial = word.slice(0, -stemAndForms[j].length);
+
+        if (precedingLexicalMaterial.length === 1) {
+          return null;
+        }
+
+        if (precedingLexicalMaterial.length > 1) {
+          return precedingLexicalMaterial + stemAndForms[0];
+        }
+        return stemAndForms[0];
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * Checks whether the word is on the sub-list of the full forms list for which we search for the exact match between one of
+ * the forms and the word. If a match is found, the canonical stem is returned. e.g. curricula -> curriculum
+ *
+ * @param {string}			word						The word to check.
+ * @param {string[]}		exactMatchFullFormsList		The list we search for an exact match in.
+ * @returns {string|null}	The canonical stem or null if no match found.
+ */
+const checkExactMatchFullFormsList = function(word, exactMatchFullFormsList) {
+  for (let i = 0; i < exactMatchFullFormsList.length; i++) {
+    const stemAndForms = flatten(exactMatchFullFormsList[i]);
+    for (let j = 0; j < stemAndForms.length; j++) {
+      if (stemAndForms.includes(word)) {
+        return stemAndForms[0];
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ *
+ * Checks whether a word is on the exception list for which we have full forms. If it is, returns the indicated stem of the word.
+ *
+ * @param {Array} morphologyDataNL The Dutch morphology data file.
+ * @param {string} word The word to check.
+ *
+ * @returns {string/null} The created word forms.
+ */
+export default function checkExceptionsWithFullForms(morphologyDataNL, word) {
+  const exceptionListWithFullForms =
+    morphologyDataNL.stemExceptions.stemmingExceptionStemsWithFullForms;
+
+  let stem = checkVerbFullFormsList(
+    word,
+    exceptionListWithFullForms.verbs,
+    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
+  );
+  if (stem) {
+    return stem;
+  }
+
+  stem = checkEndingMatchFullFormsList(word, exceptionListWithFullForms.endingMatch);
+  if (stem) {
+    return stem;
+  }
+
+  stem = checkExactMatchFullFormsList(word, exceptionListWithFullForms.exactMatch);
+  if (stem) {
+    return stem;
+  }
+
+  return null;
+}

package/src/languageProcessing/languages/nl/helpers/internal/detectAndStemRegularParticiple.js

@@ -0,0 +1,324 @@
+import {languageProcessing} from '../../../index';
+const {
+  regexHelpers: {doesWordMatchRegex}
+} = languageProcessing;
+
+import nonParticiples from '../../config/internal/nonParticiples.js';
+import {modifyStem} from './stemModificationHelpers';
+
+/**
+ * Checks whether the word is on an exception list of participles that do not have a ge- prefix. If it is found on the list,
+ * remove only the last letter (the suffix).
+ *
+ * @param {array} dataExceptionListToCheck The list of the exception words.
+ * @param {string} word 	The (unstemmed) word to check.
+ *
+ * @returns {null|string} The stemmed word or null if the word was not found on the exception list.
+ */
+const checkAndStemIfExceptionWithoutGePrefix = function(dataExceptionListToCheck, word) {
+  if (dataExceptionListToCheck.includes(word)) {
+    return word.slice(0, -1);
+  }
+  return null;
+};
+
+/**
+ * Checks whether a word that was detected as a participle should not have the suffix (-t or -d) removed because it is part
+ * of the stem. For example, in the participle 'geantwoord', the -d belongs to the stem so it should not be removed.
+ * The checks are conducted on the word without the prefix, so 'antwoord' in the case of 'geantwoord'.
+ *
+ * For words ending in -t, there are three checks:
+ * 1) An exception list (exceptions to a rule) containing words where -t SHOULD be stemmed,
+ * 2) The rule, defined using a regex with word endings where -t is part of the stem,
+ * 3) A list of verbs with stem ending in -t, to cover cases that were not possible to find using a regex.
+ *
+ * For words ending in -d, we check a list of verbs with stem ending in -d.
+ *
+ * @param {string}	wordWithoutPrefix	The word without prefix(es).
+ * @param {Object}	morphologyDataNL	The Dutch morphology data.
+ *
+ * @returns {boolean}					Whether the suffix should be stemmed.
+ */
+const shouldSuffixBeStemmed = function(wordWithoutPrefix, morphologyDataNL) {
+  if (wordWithoutPrefix.endsWith('t')) {
+    // Return true (suffix should be stemmed) if word was found on the exception list of verbs which should have the final -t stemmed.
+    const exceptionsTShouldBeStemmed = morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed;
+    if (exceptionsTShouldBeStemmed.includes(wordWithoutPrefix)) {
+      return true;
+    }
+    // Return false (suffix should not be stemmed) if word matches the regex for stems ending in -t.
+    if (
+      doesWordMatchRegex(
+        wordWithoutPrefix,
+        morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding
+      )
+    ) {
+      return false;
+    }
+    /*
+     * Return false (suffix should not be stemmed) if the word was found on the list of verbs with stem ending in -t (e.g. haast)
+     * Otherwise, return true (if no checks are matched, the default condition is for -t to be stemmed).
+     */
+    const exceptionsTShouldNotBeStemmed =
+      morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions.verbs;
+    return !exceptionsTShouldNotBeStemmed.includes(wordWithoutPrefix);
+  }
+  const exceptionsDShouldNotBeStemmed = morphologyDataNL.pastParticipleStemmer.doNotStemD;
+  return !exceptionsDShouldNotBeStemmed.includes(wordWithoutPrefix);
+};
+
+/**
+ * Detects whether a word is a participle of a regular verb without prefixes other than ge-. If it is, checks whether
+ * the word is an exception that should not have the prefix or the suffix stemmed. Then stems the word accordingly
+ * (remove prefix, suffix, or both).
+ *
+ * @param {Object}  morphologyDataNL	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle was matched.
+ */
+const detectAndStemParticiplesWithoutPrefixes = function(morphologyDataNL, word) {
+  const geStemTParticipleRegex = new RegExp(
+    '^' + morphologyDataNL.pastParticipleStemmer.participleStemmingClasses[0].regex
+  );
+
+  // Check if it's a ge + stem + t/d participle.
+  if (geStemTParticipleRegex.test(word)) {
+    // Check if the ge- is actually part of the stem. If yes, stem only the suffix.
+    const exception = checkAndStemIfExceptionWithoutGePrefix(
+      morphologyDataNL.pastParticipleStemmer.doNotStemGe,
+      word
+    );
+    if (exception) {
+      return exception;
+    }
+
+    // Remove the prefix.
+    let wordWithoutPrefix = word.slice(2);
+
+    // Check if stem starts with ë. If yes, replace ë with e.
+    if (wordWithoutPrefix.startsWith('ë')) {
+      wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);
+    }
+    // Check whether the suffix should be stemmed. If yes, remove it and return the stem.
+    if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {
+      return wordWithoutPrefix.slice(0, -1);
+    }
+
+    return wordWithoutPrefix;
+  }
+
+  return null;
+};
+
+/**
+ * Determines whether a given participle pattern combined with prefixes from a given class (separable or inseparable)
+ * applies to a given word and if so, returns the stem.
+ *
+ * @param {Object}      morphologyDataNL 	The Dutch morphology data.
+ * @param {string}      word        		The word (not stemmed) to check.
+ * @param {boolean}     separable  			Whether the prefix is separable or not.
+ * @param {string[]}    prefixes    		The prefixes of a certain prefix class.
+ * @param {string}      regexPart   		The regex part for a given class (completed to a full regex within the function).
+ *
+ * @returns {string|null} The stem or null if no prefixed participle was matched.
+ */
+const detectAndStemParticiplePerPrefixClass = function(
+  morphologyDataNL,
+  word,
+  separable,
+  prefixes,
+  regexPart
+) {
+  for (const currentPrefix of prefixes) {
+    const participleRegex = new RegExp('^' + currentPrefix + regexPart);
+
+    if (participleRegex.test(word)) {
+      let wordWithoutPrefix = word.slice(currentPrefix.length - word.length);
+      /*
+       * After removing a separable prefix, check whether the ge- belongs to the stem (e.g. the -ge- in opgebruikt).
+       * If it does, stem only the suffix.
+       */
+      if (separable) {
+        const exception = checkAndStemIfExceptionWithoutGePrefix(
+          morphologyDataNL.pastParticipleStemmer.doNotStemGe,
+          wordWithoutPrefix
+        );
+        if (exception) {
+          return currentPrefix + exception;
+        }
+        wordWithoutPrefix = wordWithoutPrefix.slice(2);
+      }
+      // Check whether stem starts with ë. If yes, replace ë with e.
+      if (wordWithoutPrefix.startsWith('ë')) {
+        wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);
+      }
+
+      if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {
+        return currentPrefix + wordWithoutPrefix.slice(0, -1);
+      }
+      return currentPrefix + wordWithoutPrefix;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle of a compound verb. A compound verb has a prefix in addition to, or instead of, ge-.
+ * For example, afgemaakt has the separable prefix af-, and beantwoord has the inseparable prefix be-. If a participle
+ * of a compound verb is detected, it is stemmed by removing the ge- (in case of a verb with a separable prefix) and the suffix -t or -d.
+ *
+ * @param {Object}  morphologyDataNL 	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle with prefix was matched.
+ */
+const detectAndStemParticiplesWithPrefixes = function(morphologyDataNL, word) {
+  /*
+   * It's important to preserve order here, since the ge + stem ending in -t regex is more specific than
+   * the stem + t regex, and therefore must be checked first.
+   */
+  for (const participleClass of morphologyDataNL.pastParticipleStemmer.participleStemmingClasses) {
+    const regex = participleClass.regex;
+    const separable = participleClass.separable;
+
+    const prefixes = separable
+      ? morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.separable
+      : morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable;
+
+    const stem = detectAndStemParticiplePerPrefixClass(
+      morphologyDataNL,
+      word,
+      separable,
+      prefixes,
+      regex
+    );
+
+    if (stem) {
+      return stem;
+    }
+  }
+
+  return null;
+};
+
+/**
+ *  Checks whether the word is on the list of participles that do not need to be stemmed, because the participle form
+ *  is the same as the stem.
+ *
+ * @param {string[]} dataParticiplesSameAsStem	The list of exceptions whose stem is the same as the participle.
+ * @param {string} 	 word						The word to check.
+ * @returns {boolean} Whether the word is found on the exception list.
+ */
+const checkIfParticipleIsSameAsStem = function(dataParticiplesSameAsStem, word) {
+  return dataParticiplesSameAsStem.includes(word);
+};
+
+/**
+ * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.
+ * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.
+ *
+ * @param {array}  inseparablePrefixes      The list of inseparable prefixes.
+ * @param {array}  dataExceptionListToCheck The list of the exception words.
+ * @param {array}  finalChangesRules        The array of regex-based rules to be applied to the stem.
+ * @param {string} word 	                The (unstemmed) word to check.
+ *
+ * @returns {null|string} The stemmed word or null if the word was found on the exception list.
+ */
+const checkAndStemIfInseparablePrefixWithEndEnding = function(
+  inseparablePrefixes,
+  dataExceptionListToCheck,
+  finalChangesRules,
+  word
+) {
+  const startsWithInseparablePrefix = inseparablePrefixes
+    .map(prefix => word.startsWith(prefix))
+    .some(value => value === true);
+
+  if (
+    startsWithInseparablePrefix &&
+    word.endsWith('end') &&
+    !dataExceptionListToCheck.includes(word)
+  ) {
+    return modifyStem(word.slice(0, -3), finalChangesRules);
+  }
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataNL 	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The participle stem or null if no regular participle was matched.
+ */
+export function detectAndStemRegularParticiple(morphologyDataNL, word) {
+  // Check whether the word is not a participle. If it is not, return empty string.
+  if (
+    word.endsWith('heid') ||
+    word.endsWith('teit') ||
+    word.endsWith('tijd') ||
+    nonParticiples.includes(word)
+  ) {
+    return '';
+  }
+
+  /**
+   * Check whether the word is on an exception list of verbs whose participle is the same as the stem. If the word is found
+   * on the list, return the stem.
+   */
+  if (
+    checkIfParticipleIsSameAsStem(
+      morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbsNotToBeStemmed,
+      word
+    )
+  ) {
+    return word;
+  }
+
+  // Check and stem if the word is a participle without any separable or inseparable prefix
+  let stem = detectAndStemParticiplesWithoutPrefixes(morphologyDataNL, word);
+
+  if (stem) {
+    return stem;
+  }
+
+  /**
+   * Check whether the word is on an exception list of inseparable compound verbs with a prefix that is usually separable.
+   * If it is, remove just the suffix and return the stem.
+   */
+  stem = checkAndStemIfExceptionWithoutGePrefix(
+    morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbs,
+    word
+  );
+
+  if (stem) {
+    return stem;
+  }
+
+  /**
+   * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.
+   * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.
+   */
+  stem = checkAndStemIfInseparablePrefixWithEndEnding(
+    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable,
+    morphologyDataNL.pastParticipleStemmer.pastParticiplesEndingOnEnd,
+    morphologyDataNL.regularStemmer.stemModifications.finalChanges,
+    word
+  );
+
+  if (stem) {
+    return stem;
+  }
+
+  // Check and stem if the word is a participle with a separable or inseparable prefix
+  stem = detectAndStemParticiplesWithPrefixes(morphologyDataNL, word);
+
+  if (stem) {
+    return stem;
+  }
+
+  return null;
+}

package/src/languageProcessing/languages/nl/helpers/internal/detectAndStemSuffixes.js

@@ -0,0 +1,164 @@
+/**
+ * @file Dutch stemming algorithm. Adapted from:
+ * @author:
+ * @copyright
+ * All rights reserved.
+ * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/dutch/stemmer.html
+ * Copyright of the algorithm is: Copyright (c) 2001, Dr Martin Porter and can be found at http://snowball.tartarus.org/license.php
+ *
+ * Redistribution and use in source and binary forms, with or without modification, is covered by the standard BSD license.
+ */
+
+import { isVowelDoublingAllowed, modifyStem } from "./stemModificationHelpers";
+
+/**
+ * Determines the start index of the R1 region.
+ * R1 is the region after the first non-vowel following a vowel. It should include at least 3 letters.
+ *
+ * @param {string} word The word for which to determine the R1 region.
+ * @returns {number} The start index of the R1 region.
+ */
+const determineR1 = function( word ) {
+	// Start with matching the first cluster that consists of a vowel and a non-vowel.
+	let r1Index = word.search( /[aeiouyèäüëïöáéíóú][^aeiouyèäüëïöáéíóú]/ );
+	// Then add 2 since the R1 index is the index after the first vowel & non-vowel matched with the regex.
+	if ( r1Index !== -1 ) {
+		r1Index += 2;
+	}
+
+	// Adjust R1 so that the region preceding it includes at least 3 letters.
+	if ( r1Index !== -1 && r1Index < 3 ) {
+		r1Index = 3;
+	}
+
+	return r1Index;
+};
+
+/**
+ * Searches for suffixes in a word.
+ *
+ * @param {string} word 		The word in which to look for suffixes.
+ * @param {Object} suffixStep	One of the three steps of findings suffixes.
+ * @param {number} r1Index		The index of the R1 region.
+ *
+ * @returns {Object} The index of the suffix and extra information about whether, and how, the stem will need to be modified.
+ */
+const findSuffix = function( word, suffixStep, r1Index ) {
+	const suffixStepArray = Object.entries( suffixStep );
+	for ( const suffixClass of suffixStepArray ) {
+		const suffixes = suffixClass[ 1 ].suffixes;
+
+		const matchedRegex = suffixes.find( suffixRegex => new RegExp( suffixRegex ).exec( word ) );
+
+		if ( matchedRegex ) {
+			const matched = new RegExp( matchedRegex ).exec( word );
+			const suffix = matched[ matched.length - 1 ];
+			const suffixIndex = word.lastIndexOf( suffix );
+
+			if ( r1Index !== -1 && suffixIndex >= r1Index ) {
+				return {
+					suffixIndex: suffixIndex,
+					stemModification: suffixClass[ 1 ].stemModification,
+				};
+			}
+		}
+	}
+};
+
+/**
+ * Deletes the suffix and modifies the stem according to the required modifications.
+ *
+ * @param {string} word	 The word from which to delete the suffix.
+ * @param {Object} suffixStep 	One of the three steps of deleting a suffix.
+ * @param {number} suffixIndex	 The index of the found suffix.
+ * @param {string} stemModification 	The type of stem modification that needs to be done.
+ * @param {Object} morphologyDataNL	 The Dutch morphology data file.
+ * @returns {string} The stemmed and modified word.
+ */
+const deleteSuffixAndModifyStem = function( word, suffixStep, suffixIndex, stemModification, morphologyDataNL ) {
+	if ( stemModification === "hedenToHeid" ) {
+		return modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.hedenToHeid );
+	}
+	word = word.substring( 0, suffixIndex );
+	if ( stemModification === "changeIedtoId" ) {
+		return modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.iedToId );
+	} else if ( stemModification === "changeInktoIng" && word.endsWith( "ink" ) ) {
+		return modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.inkToIng );
+	} else if (
+		stemModification === "vowelDoubling" &&
+		isVowelDoublingAllowed(
+			word,
+			morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
+			morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
+		)
+	) {
+		return modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.doubleVowel );
+	}
+	return word;
+};
+
+/**
+ * Finds and deletes the suffix found in a particular step, and modifies the stem.
+ *
+ * @param {string} word 	The word for which to find and delete a suffix.
+ * @param {Object} suffixStep	 One of the three suffix steps.
+ * @param {number} r1Index	 The index of the R1 region.
+ * @param {Object} morphologyDataNL	 The Dutch morphology data file.
+ * @returns {string} The word with the deleted suffix.
+ */
+const findAndDeleteSuffix = function( word, suffixStep, r1Index, morphologyDataNL ) {
+	const foundSuffix = findSuffix( word, suffixStep, r1Index );
+	if ( typeof foundSuffix !== "undefined" ) {
+		word = deleteSuffixAndModifyStem( word, suffixStep, foundSuffix.suffixIndex, foundSuffix.stemModification, morphologyDataNL );
+	}
+
+	return word;
+};
+
+/**
+ * Runs through three stemming steps that process different kinds of suffixes, determines if there is a valid suffix
+ * within the R1 region that can be deleted for stemming and deletes it, as well as applies suffix-specific stem
+ * modifications if needed.
+ *
+ * @param {string} word 	The word for which to find and delete suffixes.
+ * @param {Object} suffixSteps	 All of the suffix steps.
+ * @param {number} r1Index	 The index of the R1 region
+ * @param {Object} morphologyDataNL 	The Dutch morphology data file.
+ * @returns {string} The word with the delete suffix.
+ */
+const findAndDeleteSuffixes = function( word, suffixSteps, r1Index, morphologyDataNL ) {
+	const suffixStepsArray = Object.entries( suffixSteps );
+	for ( const suffixStep of suffixStepsArray ) {
+		word = findAndDeleteSuffix( word, suffixStep[ 1 ], r1Index, morphologyDataNL );
+	}
+
+	return word;
+};
+
+/**
+ * Search for suffixes in a word, remove them if found, and modify the stem if needed.
+ *
+ * @param {string} word  The word to stem.
+ * @param {Object} morphologyDataNL The Dutch morphology data file.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function detectAndStemSuffixes( word, morphologyDataNL ) {
+	/*
+	 * Put i and y in between vowels, initial y, and y after a vowel into upper case. This is because they should
+	 * be treated as consonants so we want to differentiate them from other i's and y's when matching regexes.
+	 */
+	word = modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.IAndYToUppercase );
+
+	// Find the start index of the R1 region.
+	const r1Index = determineR1( word );
+
+	// Import the suffixes from all three steps.
+	const suffixSteps = morphologyDataNL.regularStemmer.suffixes;
+
+	// Run through the three steps of possible de-suffixation.
+	word = findAndDeleteSuffixes( word, suffixSteps, r1Index, morphologyDataNL );
+
+	// Do final modifications to the stem.
+	return modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.finalChanges );
+}