axyseo 2.0.0-alpha.0.0.38 → 2.0.0-alpha.0.0.39

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

@@ -1,10 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = detectAndStemSuffixes;
-var _stemModificationHelpers = require("./stemModificationHelpers");
 /**
  * @file Dutch stemming algorithm. Adapted from:
  * @author:
@@ -16,6 +9,8 @@ var _stemModificationHelpers = require("./stemModificationHelpers");
  * 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.
@@ -78,15 +73,15 @@ const findSuffix = function (word, suffixStep, r1Index) {
  */
 const deleteSuffixAndModifyStem = function (word, suffixStep, suffixIndex, stemModification, morphologyDataNL) {
   if (stemModification === "hedenToHeid") {
-    return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.hedenToHeid);
+    return modifyStem(word, morphologyDataNL.regularStemmer.stemModifications.hedenToHeid);
   }
   word = word.substring(0, suffixIndex);
   if (stemModification === "changeIedtoId") {
-    return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.iedToId);
+    return modifyStem(word, morphologyDataNL.regularStemmer.stemModifications.iedToId);
   } else if (stemModification === "changeInktoIng" && word.endsWith("ink")) {
-    return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.inkToIng);
-  } else if (stemModification === "vowelDoubling" && (0, _stemModificationHelpers.isVowelDoublingAllowed)(word, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
-    return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.doubleVowel);
+    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;
 };
@@ -135,12 +130,12 @@ const findAndDeleteSuffixes = function (word, suffixSteps, r1Index, morphologyDa
  *
  * @returns {string} The stemmed word.
  */
-function detectAndStemSuffixes(word, morphologyDataNL) {
+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 = (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.IAndYToUppercase);
+  word = modifyStem(word, morphologyDataNL.regularStemmer.stemModifications.IAndYToUppercase);
 
   // Find the start index of the R1 region.
   const r1Index = determineR1(word);
@@ -152,6 +147,6 @@ function detectAndStemSuffixes(word, morphologyDataNL) {
   word = findAndDeleteSuffixes(word, suffixSteps, r1Index, morphologyDataNL);
 
   // Do final modifications to the stem.
-  return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
+  return modifyStem(word, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
 }
 //# sourceMappingURL=detectAndStemSuffixes.js.map

package/build/languageProcessing/languages/nl/helpers/internal/detectAndStemSuffixes.js.map

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

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

@@ -1,20 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = determineStem;
-var _lodash = require("lodash");
-var _index = require("../../../../../index.js");
-var _stem = _interopRequireDefault(require("./stem"));
-var _stemTOrDFromEndOfWord = require("./stemTOrDFromEndOfWord");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { flatten } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
 const {
   flattenSortLength,
   exceptionListHelpers: {
     checkExceptionListWithTwoStems
   }
-} = _index.languageProcessing;
+} = 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".
@@ -26,7 +20,7 @@ const {
 const checkStrongVerbExceptionList = function (strongVerbsLists, stemmedWord) {
   for (const key of Object.keys(strongVerbsLists)) {
     for (const stemsSet of strongVerbsLists[key]) {
-      const stems = (0, _lodash.flatten)(Object.values(stemsSet));
+      const stems = flatten(Object.values(stemsSet));
       if (stems.includes(stemmedWord)) {
         return stems[0];
       }
@@ -92,8 +86,8 @@ const findStemOnVerbExceptionList = function (morphologyDataNL, stemmedWord) {
  *
  * @returns {string} The unique stem.
  */
-function determineStem(word, morphologyDataNL) {
-  const stemmedWord = (0, _stem.default)(word, morphologyDataNL);
+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);
@@ -109,7 +103,7 @@ function determineStem(word, morphologyDataNL) {
   const ambiguousEndings = morphologyDataNL.ambiguousTAndDEndings.tAndDEndings;
   for (const ending of ambiguousEndings) {
     if (stemmedWord.endsWith(ending)) {
-      const stemmedWordWithoutTOrD = (0, _stemTOrDFromEndOfWord.stemTOrDFromEndOfWord)(morphologyDataNL, stemmedWord, word);
+      const stemmedWordWithoutTOrD = stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word);
       if (stemmedWordWithoutTOrD) {
         return stemmedWordWithoutTOrD;
       }

package/build/languageProcessing/languages/nl/helpers/internal/determineStem.js.map

@@ -1 +1 @@
-{"version":3,"file":"determineStem.js","names":["_lodash","require","_index","_stem","_interopRequireDefault","_stemTOrDFromEndOfWord","e","__esModule","default","flattenSortLength","exceptionListHelpers","checkExceptionListWithTwoStems","languageProcessing","checkStrongVerbExceptionList","strongVerbsLists","stemmedWord","key","Object","keys","stemsSet","stems","flatten","values","includes","findStemOnVerbExceptionList","morphologyDataNL","prefixes","pastParticipleStemmer","compoundVerbsPrefixes","foundPrefix","find","prefix","startsWith","doNotStemPrefix","stemExceptions","stemmingExceptionsWithMultipleStems","strongAndIrregularVerbs","doNotStemPrefixException","exception","endsWith","stemmedWordWithoutPrefix","slice","length","strongVerbExceptions","strongVerbStems","strongVerbsExceptionLists","irregularStrongVerbs","regularStrongVerbs","bothRegularAndIrregularStrongVerbs","i","checkIfWordIsException","determineStem","word","stem","stemFromExceptionList","stemmingExceptionsWithTwoStems","ambiguousEndings","ambiguousTAndDEndings","tAndDEndings","ending","stemmedWordWithoutTOrD","stemTOrDFromEndOfWord"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/determineStem.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {\n  flattenSortLength,\n  exceptionListHelpers: {checkExceptionListWithTwoStems}\n} = languageProcessing;\n\nimport stem from './stem';\nimport {stemTOrDFromEndOfWord} from './stemTOrDFromEndOfWord';\n\n/**\n * 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.\n * E.g. stems: help, hielp, geholp -> the stem returned would be \"help\".\n *\n * @param {Object} strongVerbsLists\tThe exception lists of strong verbs.\n * @param {string} stemmedWord The word to check.\n * @returns {string} The unique stem.\n */\nconst checkStrongVerbExceptionList = function(strongVerbsLists, stemmedWord) {\n  for (const key of Object.keys(strongVerbsLists)) {\n    for (const stemsSet of strongVerbsLists[key]) {\n      const stems = flatten(Object.values(stemsSet));\n      if (stems.includes(stemmedWord)) {\n        return stems[0];\n      }\n    }\n  }\n};\n\n/**\n * 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.\n * 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.\n * E.g. words to check: verhielp, stem set: help, hielp, geholp -> the stem returned would be \"verhelp\".\n *\n * @param  {Object} morphologyDataNL \tThe Dutch morphology data file.\n * @param  {string} stemmedWord \t\tThe word to check.\n *\n * @returns {string} The unique stem.\n */\nconst findStemOnVerbExceptionList = function(morphologyDataNL, stemmedWord) {\n  const prefixes = flattenSortLength(morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes);\n  // Check whether the inputted stem is started with one of the separable compound prefixes\n  let foundPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));\n  const doNotStemPrefix =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .doNotStemPrefix;\n  const doNotStemPrefixException = doNotStemPrefix.find(exception =>\n    stemmedWord.endsWith(exception)\n  );\n  let stemmedWordWithoutPrefix = '';\n\n  // Check whether the stemmedWord is in the list of strong verbs starting with be-, ont- or ver- that do not need to be stemmed.\n  if (doNotStemPrefixException) {\n    // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n    foundPrefix = null;\n    // If the inputted stem is started with one of the separable compound prefixes, the prefix needs to be deleted for now.\n  } else if (foundPrefix) {\n    // Delete the prefix for now.\n    stemmedWordWithoutPrefix = stemmedWord.slice(foundPrefix.length, stemmedWord.length);\n    // At least 3 characters left after prefix deletion so that e.g. \"be\" is not found in the stem \"berg\".\n    if (stemmedWordWithoutPrefix.length > 2) {\n      stemmedWord = stemmedWordWithoutPrefix;\n    } else {\n      // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n      foundPrefix = null;\n    }\n  }\n\n  const strongVerbExceptions =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .strongVerbStems;\n  // Find stem strong verbs lists.\n  const strongVerbsExceptionLists = [\n    strongVerbExceptions.irregularStrongVerbs,\n    strongVerbExceptions.regularStrongVerbs,\n    strongVerbExceptions.bothRegularAndIrregularStrongVerbs\n  ];\n  for (let i = 0; i < strongVerbsExceptionLists.length; i++) {\n    const checkIfWordIsException = checkStrongVerbExceptionList(\n      strongVerbsExceptionLists[i],\n      stemmedWord\n    );\n    if (checkIfWordIsException) {\n      // If the word checked had a prefix previously, attach it back.\n      if (foundPrefix) {\n        return (\n          foundPrefix + checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord)\n        );\n      }\n      // If the word checked did not have a prefix previously, only return the first stem.\n      return checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord);\n    }\n  }\n};\n\n/**\n * Return the unique stem for a given Dutch input word.\n *\n * @param {string} word The word to be checked.\n * @param {Object} morphologyDataNL The Dutch data file.\n *\n * @returns {string} The unique stem.\n */\nexport default function determineStem(word, morphologyDataNL) {\n  const stemmedWord = stem(word, morphologyDataNL);\n\n  // Check whether the stemmed word is on an exception list of words with multiple stems. If it is, return the canonical stem.\n  let stemFromExceptionList = checkExceptionListWithTwoStems(\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems\n      .stemmingExceptionsWithTwoStems,\n    stemmedWord\n  );\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n  stemFromExceptionList = findStemOnVerbExceptionList(morphologyDataNL, stemmedWord);\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n\n  // 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.\n  const ambiguousEndings = morphologyDataNL.ambiguousTAndDEndings.tAndDEndings;\n  for (const ending of ambiguousEndings) {\n    if (stemmedWord.endsWith(ending)) {\n      const stemmedWordWithoutTOrD = stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word);\n      if (stemmedWordWithoutTOrD) {\n        return stemmedWordWithoutTOrD;\n      }\n    }\n  }\n\n  return stemmedWord;\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"determineStem.js","names":["flatten","languageProcessing","flattenSortLength","exceptionListHelpers","checkExceptionListWithTwoStems","stem","stemTOrDFromEndOfWord","checkStrongVerbExceptionList","strongVerbsLists","stemmedWord","key","Object","keys","stemsSet","stems","values","includes","findStemOnVerbExceptionList","morphologyDataNL","prefixes","pastParticipleStemmer","compoundVerbsPrefixes","foundPrefix","find","prefix","startsWith","doNotStemPrefix","stemExceptions","stemmingExceptionsWithMultipleStems","strongAndIrregularVerbs","doNotStemPrefixException","exception","endsWith","stemmedWordWithoutPrefix","slice","length","strongVerbExceptions","strongVerbStems","strongVerbsExceptionLists","irregularStrongVerbs","regularStrongVerbs","bothRegularAndIrregularStrongVerbs","i","checkIfWordIsException","determineStem","word","stemFromExceptionList","stemmingExceptionsWithTwoStems","ambiguousEndings","ambiguousTAndDEndings","tAndDEndings","ending","stemmedWordWithoutTOrD"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/determineStem.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {\n  flattenSortLength,\n  exceptionListHelpers: {checkExceptionListWithTwoStems}\n} = languageProcessing;\n\nimport stem from './stem';\nimport {stemTOrDFromEndOfWord} from './stemTOrDFromEndOfWord';\n\n/**\n * 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.\n * E.g. stems: help, hielp, geholp -> the stem returned would be \"help\".\n *\n * @param {Object} strongVerbsLists\tThe exception lists of strong verbs.\n * @param {string} stemmedWord The word to check.\n * @returns {string} The unique stem.\n */\nconst checkStrongVerbExceptionList = function(strongVerbsLists, stemmedWord) {\n  for (const key of Object.keys(strongVerbsLists)) {\n    for (const stemsSet of strongVerbsLists[key]) {\n      const stems = flatten(Object.values(stemsSet));\n      if (stems.includes(stemmedWord)) {\n        return stems[0];\n      }\n    }\n  }\n};\n\n/**\n * 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.\n * 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.\n * E.g. words to check: verhielp, stem set: help, hielp, geholp -> the stem returned would be \"verhelp\".\n *\n * @param  {Object} morphologyDataNL \tThe Dutch morphology data file.\n * @param  {string} stemmedWord \t\tThe word to check.\n *\n * @returns {string} The unique stem.\n */\nconst findStemOnVerbExceptionList = function(morphologyDataNL, stemmedWord) {\n  const prefixes = flattenSortLength(morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes);\n  // Check whether the inputted stem is started with one of the separable compound prefixes\n  let foundPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));\n  const doNotStemPrefix =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .doNotStemPrefix;\n  const doNotStemPrefixException = doNotStemPrefix.find(exception =>\n    stemmedWord.endsWith(exception)\n  );\n  let stemmedWordWithoutPrefix = '';\n\n  // Check whether the stemmedWord is in the list of strong verbs starting with be-, ont- or ver- that do not need to be stemmed.\n  if (doNotStemPrefixException) {\n    // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n    foundPrefix = null;\n    // If the inputted stem is started with one of the separable compound prefixes, the prefix needs to be deleted for now.\n  } else if (foundPrefix) {\n    // Delete the prefix for now.\n    stemmedWordWithoutPrefix = stemmedWord.slice(foundPrefix.length, stemmedWord.length);\n    // At least 3 characters left after prefix deletion so that e.g. \"be\" is not found in the stem \"berg\".\n    if (stemmedWordWithoutPrefix.length > 2) {\n      stemmedWord = stemmedWordWithoutPrefix;\n    } else {\n      // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n      foundPrefix = null;\n    }\n  }\n\n  const strongVerbExceptions =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .strongVerbStems;\n  // Find stem strong verbs lists.\n  const strongVerbsExceptionLists = [\n    strongVerbExceptions.irregularStrongVerbs,\n    strongVerbExceptions.regularStrongVerbs,\n    strongVerbExceptions.bothRegularAndIrregularStrongVerbs\n  ];\n  for (let i = 0; i < strongVerbsExceptionLists.length; i++) {\n    const checkIfWordIsException = checkStrongVerbExceptionList(\n      strongVerbsExceptionLists[i],\n      stemmedWord\n    );\n    if (checkIfWordIsException) {\n      // If the word checked had a prefix previously, attach it back.\n      if (foundPrefix) {\n        return (\n          foundPrefix + checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord)\n        );\n      }\n      // If the word checked did not have a prefix previously, only return the first stem.\n      return checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord);\n    }\n  }\n};\n\n/**\n * Return the unique stem for a given Dutch input word.\n *\n * @param {string} word The word to be checked.\n * @param {Object} morphologyDataNL The Dutch data file.\n *\n * @returns {string} The unique stem.\n */\nexport default function determineStem(word, morphologyDataNL) {\n  const stemmedWord = stem(word, morphologyDataNL);\n\n  // Check whether the stemmed word is on an exception list of words with multiple stems. If it is, return the canonical stem.\n  let stemFromExceptionList = checkExceptionListWithTwoStems(\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems\n      .stemmingExceptionsWithTwoStems,\n    stemmedWord\n  );\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n  stemFromExceptionList = findStemOnVerbExceptionList(morphologyDataNL, stemmedWord);\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n\n  // 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.\n  const ambiguousEndings = morphologyDataNL.ambiguousTAndDEndings.tAndDEndings;\n  for (const ending of ambiguousEndings) {\n    if (stemmedWord.endsWith(ending)) {\n      const stemmedWordWithoutTOrD = stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word);\n      if (stemmedWordWithoutTOrD) {\n        return stemmedWordWithoutTOrD;\n      }\n    }\n  }\n\n  return stemmedWord;\n}\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,QAAQ;AAC9B,SAAQC,kBAAkB;AAC1B,MAAM;EACJC,iBAAiB;EACjBC,oBAAoB,EAAE;IAACC;EAA8B;AACvD,CAAC,GAAGH,kBAAkB;AAEtB,OAAOI,IAAI;AACX,SAAQC,qBAAqB;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,4BAA4B,GAAG,SAAAA,CAASC,gBAAgB,EAAEC,WAAW,EAAE;EAC3E,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACJ,gBAAgB,CAAC,EAAE;IAC/C,KAAK,MAAMK,QAAQ,IAAIL,gBAAgB,CAACE,GAAG,CAAC,EAAE;MAC5C,MAAMI,KAAK,GAAGd,OAAO,CAACW,MAAM,CAACI,MAAM,CAACF,QAAQ,CAAC,CAAC;MAC9C,IAAIC,KAAK,CAACE,QAAQ,CAACP,WAAW,CAAC,EAAE;QAC/B,OAAOK,KAAK,CAAC,CAAC,CAAC;MACjB;IACF;EACF;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,2BAA2B,GAAG,SAAAA,CAASC,gBAAgB,EAAET,WAAW,EAAE;EAC1E,MAAMU,QAAQ,GAAGjB,iBAAiB,CAACgB,gBAAgB,CAACE,qBAAqB,CAACC,qBAAqB,CAAC;EAChG;EACA,IAAIC,WAAW,GAAGH,QAAQ,CAACI,IAAI,CAACC,MAAM,IAAIf,WAAW,CAACgB,UAAU,CAACD,MAAM,CAAC,CAAC;EACzE,MAAME,eAAe,GACnBR,gBAAgB,CAACS,cAAc,CAACC,mCAAmC,CAACC,uBAAuB,CACxFH,eAAe;EACpB,MAAMI,wBAAwB,GAAGJ,eAAe,CAACH,IAAI,CAACQ,SAAS,IAC7DtB,WAAW,CAACuB,QAAQ,CAACD,SAAS,CAChC,CAAC;EACD,IAAIE,wBAAwB,GAAG,EAAE;;EAEjC;EACA,IAAIH,wBAAwB,EAAE;IAC5B;IACAR,WAAW,GAAG,IAAI;IAClB;EACF,CAAC,MAAM,IAAIA,WAAW,EAAE;IACtB;IACAW,wBAAwB,GAAGxB,WAAW,CAACyB,KAAK,CAACZ,WAAW,CAACa,MAAM,EAAE1B,WAAW,CAAC0B,MAAM,CAAC;IACpF;IACA,IAAIF,wBAAwB,CAACE,MAAM,GAAG,CAAC,EAAE;MACvC1B,WAAW,GAAGwB,wBAAwB;IACxC,CAAC,MAAM;MACL;MACAX,WAAW,GAAG,IAAI;IACpB;EACF;EAEA,MAAMc,oBAAoB,GACxBlB,gBAAgB,CAACS,cAAc,CAACC,mCAAmC,CAACC,uBAAuB,CACxFQ,eAAe;EACpB;EACA,MAAMC,yBAAyB,GAAG,CAChCF,oBAAoB,CAACG,oBAAoB,EACzCH,oBAAoB,CAACI,kBAAkB,EACvCJ,oBAAoB,CAACK,kCAAkC,CACxD;EACD,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,yBAAyB,CAACH,MAAM,EAAEO,CAAC,EAAE,EAAE;IACzD,MAAMC,sBAAsB,GAAGpC,4BAA4B,CACzD+B,yBAAyB,CAACI,CAAC,CAAC,EAC5BjC,WACF,CAAC;IACD,IAAIkC,sBAAsB,EAAE;MAC1B;MACA,IAAIrB,WAAW,EAAE;QACf,OACEA,WAAW,GAAGf,4BAA4B,CAAC+B,yBAAyB,CAACI,CAAC,CAAC,EAAEjC,WAAW,CAAC;MAEzF;MACA;MACA,OAAOF,4BAA4B,CAAC+B,yBAAyB,CAACI,CAAC,CAAC,EAAEjC,WAAW,CAAC;IAChF;EACF;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASmC,aAAaA,CAACC,IAAI,EAAE3B,gBAAgB,EAAE;EAC5D,MAAMT,WAAW,GAAGJ,IAAI,CAACwC,IAAI,EAAE3B,gBAAgB,CAAC;;EAEhD;EACA,IAAI4B,qBAAqB,GAAG1C,8BAA8B,CACxDc,gBAAgB,CAACS,cAAc,CAACC,mCAAmC,CAChEmB,8BAA8B,EACjCtC,WACF,CAAC;EACD,IAAIqC,qBAAqB,EAAE;IACzB,OAAOA,qBAAqB;EAC9B;EACAA,qBAAqB,GAAG7B,2BAA2B,CAACC,gBAAgB,EAAET,WAAW,CAAC;EAClF,IAAIqC,qBAAqB,EAAE;IACzB,OAAOA,qBAAqB;EAC9B;;EAEA;EACA,MAAME,gBAAgB,GAAG9B,gBAAgB,CAAC+B,qBAAqB,CAACC,YAAY;EAC5E,KAAK,MAAMC,MAAM,IAAIH,gBAAgB,EAAE;IACrC,IAAIvC,WAAW,CAACuB,QAAQ,CAACmB,MAAM,CAAC,EAAE;MAChC,MAAMC,sBAAsB,GAAG9C,qBAAqB,CAACY,gBAAgB,EAAET,WAAW,EAAEoC,IAAI,CAAC;MACzF,IAAIO,sBAAsB,EAAE;QAC1B,OAAOA,sBAAsB;MAC/B;IACF;EACF;EAEA,OAAO3C,WAAW;AACpB","ignoreList":[]}

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

@@ -1,17 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getParticiples;
-var _lodash = require("lodash");
-var _index = require("../../../../../index.js");
-var _passiveVoiceIrregulars = _interopRequireDefault(require("../../config/internal/passiveVoiceIrregulars"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { includes } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
 const {
   getWords,
   matchRegularParticiples
-} = _index.languageProcessing;
+} = languageProcessing;
+import irregularParticiples from "../../config/internal/passiveVoiceIrregulars";
+
 /**
  * Creates an array of participle for the participles found in a clause.
  *
@@ -19,9 +13,9 @@ const {
  *
  * @returns {Array} The list with participle.
  */
-function getParticiples(clauseText) {
+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 || (0, _lodash.includes)(_passiveVoiceIrregulars.default, word));
+  return words.filter(word => matchRegularParticiples(word, regexes).length !== 0 || includes(irregularParticiples, word));
 }
 //# sourceMappingURL=getParticiples.js.map

package/build/languageProcessing/languages/nl/helpers/internal/getParticiples.js.map

@@ -1 +1 @@
-{"version":3,"file":"getParticiples.js","names":["_lodash","require","_index","_passiveVoiceIrregulars","_interopRequireDefault","e","__esModule","default","getWords","matchRegularParticiples","languageProcessing","getParticiples","clauseText","words","regexes","filter","word","length","includes","irregularParticiples"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/getParticiples.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {getWords, matchRegularParticiples} = languageProcessing;\n\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars';\n\n/**\n * Creates an array of participle for the participles found in a clause.\n *\n * @param {string} clauseText The clause text to find participles in.\n *\n * @returns {Array} The list with participle.\n */\nexport default function getParticiples(clauseText) {\n  const words = getWords(clauseText);\n  const regexes = [\n    /^(ge|be|ont|ver|her|er)\\S+([dt])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi,\n    /^(aan|af|bij|binnen|los|mee|na|neer|om|onder|samen|terug|tegen|toe|uit|vast)(ge)\\S+([dtn])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi\n  ];\n\n  return words.filter(\n    word =>\n      matchRegularParticiples(word, regexes).length !== 0 || includes(irregularParticiples, word)\n  );\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,uBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAgF,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAFhF,MAAM;EAACG,QAAQ;EAAEC;AAAuB,CAAC,GAAGC,yBAAkB;AAI9D;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GAAGL,QAAQ,CAACI,UAAU,CAAC;EAClC,MAAME,OAAO,GAAG,CACd,qEAAqE,EACrE,+HAA+H,CAChI;EAED,OAAOD,KAAK,CAACE,MAAM,CACjBC,IAAI,IACFP,uBAAuB,CAACO,IAAI,EAAEF,OAAO,CAAC,CAACG,MAAM,KAAK,CAAC,IAAI,IAAAC,gBAAQ,EAACC,+BAAoB,EAAEH,IAAI,CAC9F,CAAC;AACH","ignoreList":[]}
+{"version":3,"file":"getParticiples.js","names":["includes","languageProcessing","getWords","matchRegularParticiples","irregularParticiples","getParticiples","clauseText","words","regexes","filter","word","length"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/getParticiples.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {getWords, matchRegularParticiples} = languageProcessing;\n\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars';\n\n/**\n * Creates an array of participle for the participles found in a clause.\n *\n * @param {string} clauseText The clause text to find participles in.\n *\n * @returns {Array} The list with participle.\n */\nexport default function getParticiples(clauseText) {\n  const words = getWords(clauseText);\n  const regexes = [\n    /^(ge|be|ont|ver|her|er)\\S+([dt])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi,\n    /^(aan|af|bij|binnen|los|mee|na|neer|om|onder|samen|terug|tegen|toe|uit|vast)(ge)\\S+([dtn])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi\n  ];\n\n  return words.filter(\n    word =>\n      matchRegularParticiples(word, regexes).length !== 0 || includes(irregularParticiples, word)\n  );\n}\n"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,QAAQ;AAC/B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,QAAQ;EAAEC;AAAuB,CAAC,GAAGF,kBAAkB;AAE9D,OAAOG,oBAAoB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GAAGL,QAAQ,CAACI,UAAU,CAAC;EAClC,MAAME,OAAO,GAAG,CACd,qEAAqE,EACrE,+HAA+H,CAChI;EAED,OAAOD,KAAK,CAACE,MAAM,CACjBC,IAAI,IACFP,uBAAuB,CAACO,IAAI,EAAEF,OAAO,CAAC,CAACG,MAAM,KAAK,CAAC,IAAIX,QAAQ,CAACI,oBAAoB,EAAEM,IAAI,CAC9F,CAAC;AACH","ignoreList":[]}

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

@@ -1,11 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.generateCorrectStemWithTAndDEnding = generateCorrectStemWithTAndDEnding;
-var _index = require("../../../../../index.js");
-var _stemModificationHelpers = require("./stemModificationHelpers");
+import { languageProcessing } from "../../../../../index.js";
 const {
   regexHelpers: {
     searchAndReplaceWithRegex,
@@ -15,7 +8,9 @@ const {
     checkIfWordEndingIsOnExceptionList,
     checkIfWordIsOnListThatCanHavePrefix
   }
-} = _index.languageProcessing;
+} = 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
@@ -30,7 +25,7 @@ const {
 const stemWordsWithEOrEnSuffix = function (morphologyDataNL, regexAndReplacement, word) {
   if (doesWordMatchRegex(word, regexAndReplacement[0])) {
     const stemmedWord = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);
-    if ((0, _stemModificationHelpers.isVowelDoublingAllowed)(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
+    if (isVowelDoublingAllowed(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
       const replacement = searchAndReplaceWithRegex(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.doubleVowel);
       return replacement ? replacement : stemmedWord;
     }
@@ -75,7 +70,7 @@ const checkWhetherTOrDIsPartOfStem = function (word, morphologyDataNL) {
   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 ((0, _stemModificationHelpers.isVowelDoublingAllowed)(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
+    if (isVowelDoublingAllowed(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
       const replacement = searchAndReplaceWithRegex(stemmedWord, morphologyDataNL.regularStemmer.stemModifications.doubleVowel);
       return replacement ? replacement : stemmedWord;
     }
@@ -116,7 +111,7 @@ const checkWhetherTOrDIsPartOfStem = function (word, morphologyDataNL) {
  *
  * @returns {?string} 	The stemmed word or null.
  */
-function generateCorrectStemWithTAndDEnding(morphologyDataNL, word) {
+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.

package/build/languageProcessing/languages/nl/helpers/internal/getStemWordsWithTAndDEnding.js.map

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

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

@@ -1,16 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = stem;
-var _index = require("../../../../../index.js");
-var _detectAndStemSuffixes = _interopRequireDefault(require("./detectAndStemSuffixes"));
-var _getStemWordsWithTAndDEnding = require("./getStemWordsWithTAndDEnding.js");
-var _checkExceptionsWithFullForms = _interopRequireDefault(require("./checkExceptionsWithFullForms"));
-var _detectAndStemRegularParticiple = require("./detectAndStemRegularParticiple");
-var _stemModificationHelpers = require("./stemModificationHelpers");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { languageProcessing } from "../../../../../index.js";
 const {
   exceptionListHelpers: {
     checkIfWordEndingIsOnExceptionList,
@@ -20,7 +8,13 @@ const {
     removeSuffixFromFullForm,
     removeSuffixesFromFullForm
   }
-} = _index.languageProcessing;
+} = 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.
  *
@@ -68,11 +62,11 @@ const checkOtherStemmingExceptions = function (word, morphologyDataNL) {
    */
   let stemFromFullForm = removeSuffixFromFullForms(morphologyDataNL, word);
   if (stemFromFullForm) {
-    if ((0, _stemModificationHelpers.isVowelDoublingAllowed)(stemFromFullForm, morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes)) {
-      stemFromFullForm = (0, _stemModificationHelpers.modifyStem)(stemFromFullForm, morphologyDataNL.regularStemmer.stemModifications.doubleVowel);
-      return (0, _stemModificationHelpers.modifyStem)(stemFromFullForm, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
+    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 (0, _stemModificationHelpers.modifyStem)(stemFromFullForm, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
+    return modifyStem(stemFromFullForm, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
   }
   return null;
 };
@@ -85,15 +79,15 @@ const checkOtherStemmingExceptions = function (word, morphologyDataNL) {
  *
  * @returns {string} The stemmed word.
  */
-function stem(word, morphologyDataNL) {
+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 = (0, _checkExceptionsWithFullForms.default)(morphologyDataNL, word);
+  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 = (0, _detectAndStemRegularParticiple.detectAndStemRegularParticiple)(morphologyDataNL, word);
+  stemmedWord = detectAndStemRegularParticiple(morphologyDataNL, word);
   if (stemmedWord) {
     return stemmedWord;
   }
@@ -112,7 +106,7 @@ function stem(word, morphologyDataNL) {
   const tAndDEndings = morphologyDataNL.ambiguousTAndDEndings.otherTAndDEndings;
   for (const ending of tAndDEndings) {
     if (word.endsWith(ending)) {
-      stemmedWord = (0, _getStemWordsWithTAndDEnding.generateCorrectStemWithTAndDEnding)(morphologyDataNL, word);
+      stemmedWord = generateCorrectStemWithTAndDEnding(morphologyDataNL, word);
       if (stemmedWord) {
         return stemmedWord;
       }
@@ -126,6 +120,6 @@ function stem(word, morphologyDataNL) {
   }
 
   // If the word was not stemmed in any of the previous steps, run through the stemming algorithm which detects and stems suffixes.
-  return (0, _detectAndStemSuffixes.default)(word, morphologyDataNL);
+  return detectAndStemSuffixes(word, morphologyDataNL);
 }
 //# sourceMappingURL=stem.js.map

package/build/languageProcessing/languages/nl/helpers/internal/stem.js.map

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

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

@@ -1,17 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isVowelDoublingAllowed = isVowelDoublingAllowed;
-exports.modifyStem = modifyStem;
-var _index = require("../../../../../index.js");
+import { languageProcessing } from "../../../../../index.js";
 const {
   exceptionListHelpers: {
     checkIfWordEndingIsOnExceptionList,
     checkIfWordIsOnListThatCanHavePrefix
   }
-} = _index.languageProcessing;
+} = languageProcessing;
 
 /**
  * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,
@@ -65,7 +58,7 @@ const doesPrecedingSyllableContainDiphthong = function (word, noVowelDoublingReg
  * @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.
  */
-function modifyStem(word, modificationGroup) {
+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]);
@@ -82,7 +75,7 @@ function modifyStem(word, modificationGroup) {
  *
  * @returns {boolean} Whether the vowel should be doubled or not.
  */
-function isVowelDoublingAllowed(word, morphologyDataNLStemmingExceptions, morphologyDataNLVerbPrefixes) {
+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

package/build/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"stemModificationHelpers.js","names":["_index","require","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","languageProcessing","checkIfWordIsOnNoVowelDoublingList","word","noVowelDoublingList","compoundVerbPrefixes","endingMatch","verbs","exactMatch","includes","isVowelPrecededByDoubleConsonant","fourthToLastLetter","charAt","length","thirdToLastLetter","doesPrecedingSyllableContainDiphthong","noVowelDoublingRegex","search","RegExp","modifyStem","modificationGroup","neededReplacement","find","replacement","replace","isVowelDoublingAllowed","morphologyDataNLStemmingExceptions","morphologyDataNLVerbPrefixes","firstCheck","getVowelDoubling","secondCheck","noVowelDoubling","thirdCheck","fourthCheck","rule"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\n/**\n * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,\n * and verbs) and returns true if it is.\n *\n * @param {string}\tword\t\t\t\t\t\t\tThe word to check.\n * @param {Object}\tnoVowelDoublingList\tThe list of stems that should not have the vowel doubled.\n * @param {Object}\tcompoundVerbPrefixes\t\t\tThe list of inseparable and separable verb prefixes.\n *\n * @returns {boolean} Whether the word was found on one of the lists\n */\nconst checkIfWordIsOnNoVowelDoublingList = function(\n  word,\n  noVowelDoublingList,\n  compoundVerbPrefixes\n) {\n  if (\n    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||\n    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||\n    noVowelDoublingList.exactMatch.includes(word)\n  ) {\n    return true;\n  }\n};\n\n/**\n * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks\n * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).\n * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the\n * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.\n *\n * @param {string} word The stemmed word to check.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst isVowelPrecededByDoubleConsonant = function(word) {\n  const fourthToLastLetter = word.charAt(word.length - 4);\n  const thirdToLastLetter = word.charAt(word.length - 3);\n  return fourthToLastLetter !== thirdToLastLetter;\n};\n\n/**\n * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should\n * not be doubled.\n *\n * @param {string} word                 The stemmed word to check.\n * @param {string} noVowelDoublingRegex The regex to match a word with.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {\n  return word.search(new RegExp(noVowelDoublingRegex)) === -1;\n};\n\n/**\n * Modifies the stem of the word according to the specified modification type.\n *\n * @param {string} word The stem that needs to be modified.\n * @param {string[]} modificationGroup The type of modification that needs to be done.\n * @returns {string} The modified stem, or the same stem if no modification was made.\n */\nexport function modifyStem(word, modificationGroup) {\n  const neededReplacement = modificationGroup.find(\n    replacement => word.search(new RegExp(replacement[0])) !== -1\n  );\n  if (typeof neededReplacement !== 'undefined') {\n    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);\n  }\n  return word;\n}\n\n/**\n * Checks whether the final vowel of the stem should be doubled by going through four checks.\n *\n * @param {string}  word                               The stemmed word that the check should be executed on.\n * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.\n * @param {Object}  morphologyDataNLVerbPrefixes\t   The separable and inseparable verb prefixes.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nexport function isVowelDoublingAllowed(\n  word,\n  morphologyDataNLStemmingExceptions,\n  morphologyDataNLVerbPrefixes\n) {\n  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)\n  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(\n    word,\n    morphologyDataNLStemmingExceptions.getVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  // Check whether the word is on the list of words which should NOT have the vowel doubled\n  const secondCheck = checkIfWordIsOnNoVowelDoublingList(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  const thirdCheck = isVowelPrecededByDoubleConsonant(word);\n  const fourthCheck = doesPrecedingSyllableContainDiphthong(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling.rule\n  );\n\n  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGC,yBAAkB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,kCAAkC,GAAG,SAAAA,CACzCC,IAAI,EACJC,mBAAmB,EACnBC,oBAAoB,EACpB;EACA,IACEN,kCAAkC,CAACI,IAAI,EAAEC,mBAAmB,CAACE,WAAW,CAAC,IACzEN,oCAAoC,CAACG,IAAI,EAAEC,mBAAmB,CAACG,KAAK,EAAEF,oBAAoB,CAAC,IAC3FD,mBAAmB,CAACI,UAAU,CAACC,QAAQ,CAACN,IAAI,CAAC,EAC7C;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMO,gCAAgC,GAAG,SAAAA,CAASP,IAAI,EAAE;EACtD,MAAMQ,kBAAkB,GAAGR,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACvD,MAAMC,iBAAiB,GAAGX,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACtD,OAAOF,kBAAkB,KAAKG,iBAAiB;AACjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAASZ,IAAI,EAAEa,oBAAoB,EAAE;EACjF,OAAOb,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACF,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAAChB,IAAI,EAAEiB,iBAAiB,EAAE;EAClD,MAAMC,iBAAiB,GAAGD,iBAAiB,CAACE,IAAI,CAC9CC,WAAW,IAAIpB,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAC9D,CAAC;EACD,IAAI,OAAOF,iBAAiB,KAAK,WAAW,EAAE;IAC5ClB,IAAI,GAAGA,IAAI,CAACqB,OAAO,CAAC,IAAIN,MAAM,CAACG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAEA,iBAAiB,CAAC,CAAC,CAAC,CAAC;EAC7E;EACA,OAAOlB,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASsB,sBAAsBA,CACpCtB,IAAI,EACJuB,kCAAkC,EAClCC,4BAA4B,EAC5B;EACA;EACA,MAAMC,UAAU,GAAG5B,oCAAoC,CACrDG,IAAI,EACJuB,kCAAkC,CAACG,gBAAgB,EACnDF,4BACF,CAAC;EACD;EACA,MAAMG,WAAW,GAAG5B,kCAAkC,CACpDC,IAAI,EACJuB,kCAAkC,CAACK,eAAe,EAClDJ,4BACF,CAAC;EACD,MAAMK,UAAU,GAAGtB,gCAAgC,CAACP,IAAI,CAAC;EACzD,MAAM8B,WAAW,GAAGlB,qCAAqC,CACvDZ,IAAI,EACJuB,kCAAkC,CAACK,eAAe,CAACG,IACrD,CAAC;EAED,OAAON,UAAU,IAAK,CAACE,WAAW,IAAIE,UAAU,IAAIC,WAAY;AAClE","ignoreList":[]}
+{"version":3,"file":"stemModificationHelpers.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","checkIfWordIsOnNoVowelDoublingList","word","noVowelDoublingList","compoundVerbPrefixes","endingMatch","verbs","exactMatch","includes","isVowelPrecededByDoubleConsonant","fourthToLastLetter","charAt","length","thirdToLastLetter","doesPrecedingSyllableContainDiphthong","noVowelDoublingRegex","search","RegExp","modifyStem","modificationGroup","neededReplacement","find","replacement","replace","isVowelDoublingAllowed","morphologyDataNLStemmingExceptions","morphologyDataNLVerbPrefixes","firstCheck","getVowelDoubling","secondCheck","noVowelDoubling","thirdCheck","fourthCheck","rule"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\n/**\n * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,\n * and verbs) and returns true if it is.\n *\n * @param {string}\tword\t\t\t\t\t\t\tThe word to check.\n * @param {Object}\tnoVowelDoublingList\tThe list of stems that should not have the vowel doubled.\n * @param {Object}\tcompoundVerbPrefixes\t\t\tThe list of inseparable and separable verb prefixes.\n *\n * @returns {boolean} Whether the word was found on one of the lists\n */\nconst checkIfWordIsOnNoVowelDoublingList = function(\n  word,\n  noVowelDoublingList,\n  compoundVerbPrefixes\n) {\n  if (\n    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||\n    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||\n    noVowelDoublingList.exactMatch.includes(word)\n  ) {\n    return true;\n  }\n};\n\n/**\n * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks\n * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).\n * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the\n * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.\n *\n * @param {string} word The stemmed word to check.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst isVowelPrecededByDoubleConsonant = function(word) {\n  const fourthToLastLetter = word.charAt(word.length - 4);\n  const thirdToLastLetter = word.charAt(word.length - 3);\n  return fourthToLastLetter !== thirdToLastLetter;\n};\n\n/**\n * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should\n * not be doubled.\n *\n * @param {string} word                 The stemmed word to check.\n * @param {string} noVowelDoublingRegex The regex to match a word with.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {\n  return word.search(new RegExp(noVowelDoublingRegex)) === -1;\n};\n\n/**\n * Modifies the stem of the word according to the specified modification type.\n *\n * @param {string} word The stem that needs to be modified.\n * @param {string[]} modificationGroup The type of modification that needs to be done.\n * @returns {string} The modified stem, or the same stem if no modification was made.\n */\nexport function modifyStem(word, modificationGroup) {\n  const neededReplacement = modificationGroup.find(\n    replacement => word.search(new RegExp(replacement[0])) !== -1\n  );\n  if (typeof neededReplacement !== 'undefined') {\n    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);\n  }\n  return word;\n}\n\n/**\n * Checks whether the final vowel of the stem should be doubled by going through four checks.\n *\n * @param {string}  word                               The stemmed word that the check should be executed on.\n * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.\n * @param {Object}  morphologyDataNLVerbPrefixes\t   The separable and inseparable verb prefixes.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nexport function isVowelDoublingAllowed(\n  word,\n  morphologyDataNLStemmingExceptions,\n  morphologyDataNLVerbPrefixes\n) {\n  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)\n  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(\n    word,\n    morphologyDataNLStemmingExceptions.getVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  // Check whether the word is on the list of words which should NOT have the vowel doubled\n  const secondCheck = checkIfWordIsOnNoVowelDoublingList(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  const thirdCheck = isVowelPrecededByDoubleConsonant(word);\n  const fourthCheck = doesPrecedingSyllableContainDiphthong(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling.rule\n  );\n\n  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGH,kBAAkB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,kCAAkC,GAAG,SAAAA,CACzCC,IAAI,EACJC,mBAAmB,EACnBC,oBAAoB,EACpB;EACA,IACEL,kCAAkC,CAACG,IAAI,EAAEC,mBAAmB,CAACE,WAAW,CAAC,IACzEL,oCAAoC,CAACE,IAAI,EAAEC,mBAAmB,CAACG,KAAK,EAAEF,oBAAoB,CAAC,IAC3FD,mBAAmB,CAACI,UAAU,CAACC,QAAQ,CAACN,IAAI,CAAC,EAC7C;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMO,gCAAgC,GAAG,SAAAA,CAASP,IAAI,EAAE;EACtD,MAAMQ,kBAAkB,GAAGR,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACvD,MAAMC,iBAAiB,GAAGX,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACtD,OAAOF,kBAAkB,KAAKG,iBAAiB;AACjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAASZ,IAAI,EAAEa,oBAAoB,EAAE;EACjF,OAAOb,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACF,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,UAAUA,CAAChB,IAAI,EAAEiB,iBAAiB,EAAE;EAClD,MAAMC,iBAAiB,GAAGD,iBAAiB,CAACE,IAAI,CAC9CC,WAAW,IAAIpB,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAC9D,CAAC;EACD,IAAI,OAAOF,iBAAiB,KAAK,WAAW,EAAE;IAC5ClB,IAAI,GAAGA,IAAI,CAACqB,OAAO,CAAC,IAAIN,MAAM,CAACG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAEA,iBAAiB,CAAC,CAAC,CAAC,CAAC;EAC7E;EACA,OAAOlB,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASsB,sBAAsBA,CACpCtB,IAAI,EACJuB,kCAAkC,EAClCC,4BAA4B,EAC5B;EACA;EACA,MAAMC,UAAU,GAAG3B,oCAAoC,CACrDE,IAAI,EACJuB,kCAAkC,CAACG,gBAAgB,EACnDF,4BACF,CAAC;EACD;EACA,MAAMG,WAAW,GAAG5B,kCAAkC,CACpDC,IAAI,EACJuB,kCAAkC,CAACK,eAAe,EAClDJ,4BACF,CAAC;EACD,MAAMK,UAAU,GAAGtB,gCAAgC,CAACP,IAAI,CAAC;EACzD,MAAM8B,WAAW,GAAGlB,qCAAqC,CACvDZ,IAAI,EACJuB,kCAAkC,CAACK,eAAe,CAACG,IACrD,CAAC;EAED,OAAON,UAAU,IAAK,CAACE,WAAW,IAAIE,UAAU,IAAIC,WAAY;AAClE","ignoreList":[]}