axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.6

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 );
-}

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

@@ -1,133 +0,0 @@
-import {flatten} from 'lodash';
-import {languageProcessing} from '../../../index';
-const {
-  flattenSortLength,
-  exceptionListHelpers: {checkExceptionListWithTwoStems}
-} = languageProcessing;
-
-import stem from './stem';
-import {stemTOrDFromEndOfWord} from './stemTOrDFromEndOfWord';
-
-/**
- * Checks if the word checked is in the list of strong verbs exceptions. If it is, only return the first stem from the stem set.
- * E.g. stems: help, hielp, geholp -> the stem returned would be "help".
- *
- * @param {Object} strongVerbsLists	The exception lists of strong verbs.
- * @param {string} stemmedWord The word to check.
- * @returns {string} The unique stem.
- */
-const checkStrongVerbExceptionList = function(strongVerbsLists, stemmedWord) {
-  for (const key of Object.keys(strongVerbsLists)) {
-    for (const stemsSet of strongVerbsLists[key]) {
-      const stems = flatten(Object.values(stemsSet));
-      if (stems.includes(stemmedWord)) {
-        return stems[0];
-      }
-    }
-  }
-};
-
-/**
- * Checks if the word checked is in the list of strong verbs exceptions. Before checking, see if the word has a prefix and delete it if it does.
- * If the stem after prefix deletion is in the verb exception list, only return the first stem from the stem set and attach back the prefix.
- * E.g. words to check: verhielp, stem set: help, hielp, geholp -> the stem returned would be "verhelp".
- *
- * @param  {Object} morphologyDataNL 	The Dutch morphology data file.
- * @param  {string} stemmedWord 		The word to check.
- *
- * @returns {string} The unique stem.
- */
-const findStemOnVerbExceptionList = function(morphologyDataNL, stemmedWord) {
-  const prefixes = flattenSortLength(morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes);
-  // Check whether the inputted stem is started with one of the separable compound prefixes
-  let foundPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));
-  const doNotStemPrefix =
-    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs
-      .doNotStemPrefix;
-  const doNotStemPrefixException = doNotStemPrefix.find(exception =>
-    stemmedWord.endsWith(exception)
-  );
-  let stemmedWordWithoutPrefix = '';
-
-  // Check whether the stemmedWord is in the list of strong verbs starting with be-, ont- or ver- that do not need to be stemmed.
-  if (doNotStemPrefixException) {
-    // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.
-    foundPrefix = null;
-    // If the inputted stem is started with one of the separable compound prefixes, the prefix needs to be deleted for now.
-  } else if (foundPrefix) {
-    // Delete the prefix for now.
-    stemmedWordWithoutPrefix = stemmedWord.slice(foundPrefix.length, stemmedWord.length);
-    // At least 3 characters left after prefix deletion so that e.g. "be" is not found in the stem "berg".
-    if (stemmedWordWithoutPrefix.length > 2) {
-      stemmedWord = stemmedWordWithoutPrefix;
-    } else {
-      // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.
-      foundPrefix = null;
-    }
-  }
-
-  const strongVerbExceptions =
-    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs
-      .strongVerbStems;
-  // Find stem strong verbs lists.
-  const strongVerbsExceptionLists = [
-    strongVerbExceptions.irregularStrongVerbs,
-    strongVerbExceptions.regularStrongVerbs,
-    strongVerbExceptions.bothRegularAndIrregularStrongVerbs
-  ];
-  for (let i = 0; i < strongVerbsExceptionLists.length; i++) {
-    const checkIfWordIsException = checkStrongVerbExceptionList(
-      strongVerbsExceptionLists[i],
-      stemmedWord
-    );
-    if (checkIfWordIsException) {
-      // If the word checked had a prefix previously, attach it back.
-      if (foundPrefix) {
-        return (
-          foundPrefix + checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord)
-        );
-      }
-      // If the word checked did not have a prefix previously, only return the first stem.
-      return checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord);
-    }
-  }
-};
-
-/**
- * Return the unique stem for a given Dutch input word.
- *
- * @param {string} word The word to be checked.
- * @param {Object} morphologyDataNL The Dutch data file.
- *
- * @returns {string} The unique stem.
- */
-export default function determineStem(word, morphologyDataNL) {
-  const stemmedWord = stem(word, morphologyDataNL);
-
-  // Check whether the stemmed word is on an exception list of words with multiple stems. If it is, return the canonical stem.
-  let stemFromExceptionList = checkExceptionListWithTwoStems(
-    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems
-      .stemmingExceptionsWithTwoStems,
-    stemmedWord
-  );
-  if (stemFromExceptionList) {
-    return stemFromExceptionList;
-  }
-  stemFromExceptionList = findStemOnVerbExceptionList(morphologyDataNL, stemmedWord);
-  if (stemFromExceptionList) {
-    return stemFromExceptionList;
-  }
-
-  // If the stemmed word ends in -t or -d, check whether it should be stemmed further, and return the stem with or without the -t/d.
-  const ambiguousEndings = morphologyDataNL.ambiguousTAndDEndings.tAndDEndings;
-  for (const ending of ambiguousEndings) {
-    if (stemmedWord.endsWith(ending)) {
-      const stemmedWordWithoutTOrD = stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word);
-      if (stemmedWordWithoutTOrD) {
-        return stemmedWordWithoutTOrD;
-      }
-    }
-  }
-
-  return stemmedWord;
-}

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

@@ -1,25 +0,0 @@
-import {includes} from 'lodash';
-import {languageProcessing} from '../../../index';
-const {getWords, matchRegularParticiples} = languageProcessing;
-
-import irregularParticiples from '../../config/internal/passiveVoiceIrregulars';
-
-/**
- * Creates an array of participle for the participles found in a clause.
- *
- * @param {string} clauseText The clause text to find participles in.
- *
- * @returns {Array} The list with participle.
- */
-export default function getParticiples(clauseText) {
-  const words = getWords(clauseText);
-  const regexes = [
-    /^(ge|be|ont|ver|her|er)\S+([dt])($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi,
-    /^(aan|af|bij|binnen|los|mee|na|neer|om|onder|samen|terug|tegen|toe|uit|vast)(ge)\S+([dtn])($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi
-  ];
-
-  return words.filter(
-    word =>
-      matchRegularParticiples(word, regexes).length !== 0 || includes(irregularParticiples, word)
-  );
-}