axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.21

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

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

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

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