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

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

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

@@ -1,183 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {
-  regexHelpers: {searchAndReplaceWithRegex, doesWordMatchRegex},
-  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
-} = languageProcessing;
-
-import {isVowelDoublingAllowed} from './stemModificationHelpers';
-
-/**
- * Checks whether the word ends in suffixes -e or -en which are preceded by -t or -d, and the -t/-d is part of the stem.
- * If it does, stem the -e/-en. Also checks if after suffix deletion the stemmed word needs modification, and applies it if
- * needed. e.g. doden -> dod -> dood
- *
- * @param {Object} 		morphologyDataNL			 	The Dutch morphology data file.
- * @param {string[]} 	regexAndReplacement				The regex to check and the string replacement that should be made.
- * @param {string} 		word							The word to be checked.
- *
- * @returns {?string}							The stem created or null.
- */
-const stemWordsWithEOrEnSuffix = function(morphologyDataNL, regexAndReplacement, word) {
-  if (doesWordMatchRegex(word, regexAndReplacement[0])) {
-    const stemmedWord = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);
-    if (
-      isVowelDoublingAllowed(
-        stemmedWord,
-        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
-        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-      )
-    ) {
-      const replacement = searchAndReplaceWithRegex(
-        stemmedWord,
-        morphologyDataNL.regularStemmer.stemModifications.doubleVowel
-      );
-      return replacement ? replacement : stemmedWord;
-    }
-    return stemmedWord;
-  }
-
-  return null;
-};
-
-/**
- * Stems words for which we know that -t/-d is the ending of the stem (so the -t/-d is not stemmed). This is done through
- * checking lists of words and matching the word with regexes.
- *
- * @param {string}	word								The word to check.
- * @param {Object} 	morphologyDataNL 					The Dutch morphology data.
- *
- * @returns {?string} 							The stemmed word, if matched in one of the checks, or null if not matched.
- */
-const checkWhetherTOrDIsPartOfStem = function(word, morphologyDataNL) {
-  const tAndDPartOfStemData = morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem;
-  /*
-   * Step 1:
-   * - If the stem ends in -tte, -tten, -dde or -dden leave the first -t/-d and stem the remaining ending.
-   * - Example: "katten" (-ten should be stemmed, leaving "kat").
-   */
-  let stemmedWord = searchAndReplaceWithRegex(word, tAndDPartOfStemData.firstTOrDPartOfStem);
-
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  /*
-   * Step 2:
-   * 2a)
-   * - Checks whether the word is in the exception list of verbal forms ending in long vowel + -fden/sden. If so, stems -den off.
-   * - Example: "hoefden" (-den should be stemmed, leaving "hoef").
-   * 2b)
-   * - Check whether the word has the suffix -en preceded by -d, where the -d is part of the stem. If it is, stem only -en.
-   * - Example: "eenden" (-en should be stemmed, leaving "eend").
-   */
-  if (tAndDPartOfStemData.verbsDenShouldBeStemmed.includes(word)) {
-    return word.slice(0, -3);
-  }
-
-  if (
-    checkIfWordEndingIsOnExceptionList(
-      word,
-      tAndDPartOfStemData.wordsStemOnlyEnEnding.endingMatch
-    ) ||
-    checkIfWordIsOnListThatCanHavePrefix(
-      word,
-      tAndDPartOfStemData.wordsStemOnlyEnEnding.verbs,
-      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-    ) ||
-    doesWordMatchRegex(word, tAndDPartOfStemData.denEnding)
-  ) {
-    stemmedWord = word.slice(0, -2);
-    //	Check if the vowel needs to be doubled after deleting suffix -en.
-    if (
-      isVowelDoublingAllowed(
-        stemmedWord,
-        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
-        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-      )
-    ) {
-      const replacement = searchAndReplaceWithRegex(
-        stemmedWord,
-        morphologyDataNL.regularStemmer.stemModifications.doubleVowel
-      );
-      return replacement ? replacement : stemmedWord;
-    }
-    return stemmedWord;
-  }
-
-  /*
-   * Step 3:
-   * - Checks whether the word matches the regex for words ending in -de with -d being part of the stem. If it is matched,
-   * only stem the -e.
-   * - Example: "beenharde" (-e should be stemmed, leaving "beenhard")
-   */
-  const dIsPartOfStemRegex = tAndDPartOfStemData.deEnding;
-  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, dIsPartOfStemRegex, word);
-
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  /*
-   * Step 4:
-   * - Checks whether the word matches the regex for words ending in -te or -ten with -t being part of the stem. If it is
-   * matched, only stem the -e/-en.
-   * - Example: "castraten" (-en should be stemmed, leaving "castraat")
-   */
-  const tIsPartOfStemRegex = tAndDPartOfStemData.teAndTenEndings;
-  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, tIsPartOfStemRegex, word);
-
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  return null;
-};
-
-/**
- * Creates the correct stem for words which end in ambiguous endings -t, -te, -ten, -de, or -den.
- *
- * @param {Object} 		morphologyDataNL 					The Dutch morphology data.
- * @param {string} 		word								The word to be checked.
- *
- * @returns {?string} 	The stemmed word or null.
- */
-export function generateCorrectStemWithTAndDEnding(morphologyDataNL, word) {
-  /*
-   * Step 1:
-   * - Check whether the word is in the exception list of words in which -t ending needs to be stemmed. If it is, stem -t.
-   * - Example: "squasht".
-   * - This is an exception to one of the rule in step 2.
-   */
-  if (
-    checkIfWordEndingIsOnExceptionList(
-      word,
-      morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed
-    )
-  ) {
-    return word.slice(0, -1);
-  }
-
-  /*
-   * Step 2:
-   * - Check if word is matched by a regex for a t that shouldn't be stemmed.
-   * - Example: "boot".
-   */
-  if (doesWordMatchRegex(word, morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding)) {
-    return word;
-  }
-
-  /*
-   * Step 3:
-   * - Check whether the word has another suffix that should be stemmed (e.g. -en) preceded by -t or -d which is part of the stem.
-   *  If yes, stem the suffix that should be stemmed and return the stem which ends in -t/-d.
-   * - Example: "tijden" (only -en should be removed, not -den).
-   */
-
-  const stemmedWord = checkWhetherTOrDIsPartOfStem(word, morphologyDataNL);
-
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  return null;
-}

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

@@ -1,146 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {
-  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix},
-  stemHelpers: {removeSuffixFromFullForm, removeSuffixesFromFullForm}
-} = languageProcessing;
-
-import detectAndStemSuffixes from './detectAndStemSuffixes';
-import {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding.js';
-import checkExceptionsWithFullForms from './checkExceptionsWithFullForms';
-import {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';
-import {modifyStem, isVowelDoublingAllowed} from './stemModificationHelpers';
-
-/**
- * Get the stem from noun diminutives and plurals exceptions.
- *
- * @param {Object}    morphologyDataNL The data for stemming exception.
- * @param {string}      word                                The word to check.
- *
- * @returns {string} The stemmed word.
- */
-const removeSuffixFromFullForms = function(morphologyDataNL, word) {
-  /*
-   * Checks whether the word is in the exception list of words ending in -er and gets either -e or -s suffix
-   * If it is, remove the corresponding suffix.
-   * e.g. lekkere -> lekker, bitters -> bitter
-   */
-  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixesFromFullForms) {
-    const stemmedWord = removeSuffixesFromFullForm(
-      exceptionClass.forms,
-      exceptionClass.suffixes,
-      word
-    );
-    if (stemmedWord) {
-      return stemmedWord;
-    }
-  }
-  /*
-   * Checks whether the word is in one of the exception lists of nouns
-   * for which a specific suffix needs to be stemmed (e.g. -s, -es, -eren, -er etc.)
-   * e.g. kuddes -> kud, modes -> mod, revenuen -> revenu
-   */
-  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixFromFullForms) {
-    const stemmedWord = removeSuffixFromFullForm(exceptionClass.forms, exceptionClass.suffix, word);
-    if (stemmedWord) {
-      return stemmedWord;
-    }
-  }
-};
-
-/**
- * Checks if the word is on a stemming exception list.
- *
- * @param {string} word The word to check.
- * @param {Object} morphologyDataNL The Dutch morphology data file.
- * @returns {string|null} The stem or null if the word was not matched by any of the exception checks.
- */
-const checkOtherStemmingExceptions = function(word, morphologyDataNL) {
-  /*
-   * Checks whether the word is in the exception list of nouns or adjectives with specific suffixes that needs to be stemmed.
-   * If it is return the stem here and run possible stem modification if it is required. e.g. modes -> mod -> mood
-   */
-  let stemFromFullForm = removeSuffixFromFullForms(morphologyDataNL, word);
-  if (stemFromFullForm) {
-    if (
-      isVowelDoublingAllowed(
-        stemFromFullForm,
-        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
-        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-      )
-    ) {
-      stemFromFullForm = modifyStem(
-        stemFromFullForm,
-        morphologyDataNL.regularStemmer.stemModifications.doubleVowel
-      );
-      return modifyStem(
-        stemFromFullForm,
-        morphologyDataNL.regularStemmer.stemModifications.finalChanges
-      );
-    }
-    return modifyStem(
-      stemFromFullForm,
-      morphologyDataNL.regularStemmer.stemModifications.finalChanges
-    );
-  }
-  return null;
-};
-
-/**
- * Stems Dutch words.
- *
- * @param {string} word  The word to stem.
- * @param {Object} morphologyDataNL The Dutch morphology data file.
- *
- * @returns {string} The stemmed word.
- */
-export default function stem(word, morphologyDataNL) {
-  // Check whether the word is in the list of words with full forms for which we define the stem. If it is, return the canonical stem.
-  let stemmedWord = checkExceptionsWithFullForms(morphologyDataNL, word);
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  // Check whether the word is a participle, and if yes, stem it and return the stem.
-  stemmedWord = detectAndStemRegularParticiple(morphologyDataNL, word);
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  // Check whether the word is on the list of words that should not be stemmed, and if yes, return the word. Example: gans -> gans
-  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;
-  if (
-    checkIfWordIsOnListThatCanHavePrefix(
-      word,
-      wordsNotToBeStemmed.verbs,
-      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-    ) ||
-    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||
-    wordsNotToBeStemmed.exactMatch.includes(word)
-  ) {
-    return word;
-  }
-
-  /*
-   * Check whether the word ends in -t/-te/-ten/-tend/-de/-den/-dend. If it does, run through a series of checks aimed at
-   * predicting whether the -t/d is part of the stem or the suffix. If the word was matched in one of the checks, stem it
-   * accordingly and return the stem. Example: boot -> boot, squasht -> squash
-   */
-  const tAndDEndings = morphologyDataNL.ambiguousTAndDEndings.otherTAndDEndings;
-  for (const ending of tAndDEndings) {
-    if (word.endsWith(ending)) {
-      stemmedWord = generateCorrectStemWithTAndDEnding(morphologyDataNL, word);
-      if (stemmedWord) {
-        return stemmedWord;
-      }
-    }
-  }
-
-  // Check if the word is on any other stemming exception list, and if yes, return the correct stem.
-  stemmedWord = checkOtherStemmingExceptions(word, morphologyDataNL);
-  if (stemmedWord) {
-    return stemmedWord;
-  }
-
-  // If the word was not stemmed in any of the previous steps, run through the stemming algorithm which detects and stems suffixes.
-  return detectAndStemSuffixes(word, morphologyDataNL);
-}

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

@@ -1,109 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {
-  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
-} = languageProcessing;
-
-/**
- * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,
- * and verbs) and returns true if it is.
- *
- * @param {string}	word							The word to check.
- * @param {Object}	noVowelDoublingList	The list of stems that should not have the vowel doubled.
- * @param {Object}	compoundVerbPrefixes			The list of inseparable and separable verb prefixes.
- *
- * @returns {boolean} Whether the word was found on one of the lists
- */
-const checkIfWordIsOnNoVowelDoublingList = function(
-  word,
-  noVowelDoublingList,
-  compoundVerbPrefixes
-) {
-  if (
-    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||
-    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||
-    noVowelDoublingList.exactMatch.includes(word)
-  ) {
-    return true;
-  }
-};
-
-/**
- * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks
- * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).
- * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the
- * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.
- *
- * @param {string} word The stemmed word to check.
- *
- * @returns {boolean} Whether the vowel should be doubled or not.
- */
-const isVowelPrecededByDoubleConsonant = function(word) {
-  const fourthToLastLetter = word.charAt(word.length - 4);
-  const thirdToLastLetter = word.charAt(word.length - 3);
-  return fourthToLastLetter !== thirdToLastLetter;
-};
-
-/**
- * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should
- * not be doubled.
- *
- * @param {string} word                 The stemmed word to check.
- * @param {string} noVowelDoublingRegex The regex to match a word with.
- *
- * @returns {boolean} Whether the vowel should be doubled or not.
- */
-const doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {
-  return word.search(new RegExp(noVowelDoublingRegex)) === -1;
-};
-
-/**
- * Modifies the stem of the word according to the specified modification type.
- *
- * @param {string} word The stem that needs to be modified.
- * @param {string[]} modificationGroup The type of modification that needs to be done.
- * @returns {string} The modified stem, or the same stem if no modification was made.
- */
-export function modifyStem(word, modificationGroup) {
-  const neededReplacement = modificationGroup.find(
-    replacement => word.search(new RegExp(replacement[0])) !== -1
-  );
-  if (typeof neededReplacement !== 'undefined') {
-    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);
-  }
-  return word;
-}
-
-/**
- * Checks whether the final vowel of the stem should be doubled by going through four checks.
- *
- * @param {string}  word                               The stemmed word that the check should be executed on.
- * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.
- * @param {Object}  morphologyDataNLVerbPrefixes	   The separable and inseparable verb prefixes.
- *
- * @returns {boolean} Whether the vowel should be doubled or not.
- */
-export function isVowelDoublingAllowed(
-  word,
-  morphologyDataNLStemmingExceptions,
-  morphologyDataNLVerbPrefixes
-) {
-  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)
-  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(
-    word,
-    morphologyDataNLStemmingExceptions.getVowelDoubling,
-    morphologyDataNLVerbPrefixes
-  );
-  // Check whether the word is on the list of words which should NOT have the vowel doubled
-  const secondCheck = checkIfWordIsOnNoVowelDoublingList(
-    word,
-    morphologyDataNLStemmingExceptions.noVowelDoubling,
-    morphologyDataNLVerbPrefixes
-  );
-  const thirdCheck = isVowelPrecededByDoubleConsonant(word);
-  const fourthCheck = doesPrecedingSyllableContainDiphthong(
-    word,
-    morphologyDataNLStemmingExceptions.noVowelDoubling.rule
-  );
-
-  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);
-}

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

@@ -1,65 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {
-  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
-} = languageProcessing;
-
-import {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';
-import {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding';
-import checkExceptionsWithFullForms from './checkExceptionsWithFullForms';
-
-/**
- * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, other checks still need
- * to be done in order to be sure whether we need to stem the word further or not.
- * If one of these checks returns true, we do not need to stem the word further.
- *
- * @param {Object}  morphologyDataNL	The Dutch morphology data.
- * @param {string}	stemmedWord			The stemmed word.
- * @param {string}	word				The unstemmed word.
- * @returns {boolean}	Whether one of the conditions returns true or not.
- */
-const checkIfTorDIsUnambiguous = function(morphologyDataNL, stemmedWord, word) {
-  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;
-  const adjectivesEndingInRd = morphologyDataNL.stemExceptions.removeSuffixesFromFullForms[1].forms;
-  const wordsEndingInTOrDExceptionList =
-    morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;
-
-  // Run the checks below. If one of the conditions returns true, return the stem.
-  if (
-    detectAndStemRegularParticiple(morphologyDataNL, word) ||
-    generateCorrectStemWithTAndDEnding(morphologyDataNL, word) ||
-    checkIfWordIsOnListThatCanHavePrefix(
-      word,
-      wordsNotToBeStemmed.verbs,
-      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
-    ) ||
-    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||
-    wordsNotToBeStemmed.exactMatch.includes(word) ||
-    adjectivesEndingInRd.includes(stemmedWord) ||
-    checkExceptionsWithFullForms(morphologyDataNL, word) ||
-    stemmedWord.endsWith('heid') ||
-    checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)
-  ) {
-    return true;
-  }
-};
-
-/**
- * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, and if it
- * is not a participle (which has its separate check), then it is still ambiguous whether -t/-d is part of the stem or a suffix.
- * Therefore, a second stem should be created with the -t/-d removed in case it was a suffix. For example, in the verb 'poolt',
- * -t is a suffix, but we could not predict in any of the previous checks that -t should be stemmed. To account for such cases,
- * we stem the -t here.
- *
- * @param {Object}  morphologyDataNL	The Dutch morphology data.
- * @param {string}	stemmedWord			The stemmed word.
- * @param {string}	word				The unstemmed word.
- *
- * @returns {?string}				    The stemmed word or null if the -t/-d should not be stemmed.
- */
-export function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {
-  if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {
-    return null;
-  }
-  // If none of the conditions above is true, stem the t/d from the word.
-  return stemmedWord.slice(0, -1);
-}