axyseo 2.0.0-alpha.0.0.37 → 2.0.0-alpha.0.0.39

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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":[]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"stemTOrDFromEndOfWord.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","detectAndStemRegularParticiple","generateCorrectStemWithTAndDEnding","checkExceptionsWithFullForms","checkIfTorDIsUnambiguous","morphologyDataNL","stemmedWord","word","wordsNotToBeStemmed","stemExceptions","wordsNotToBeStemmedExceptions","adjectivesEndingInRd","removeSuffixesFromFullForms","forms","wordsEndingInTOrDExceptionList","ambiguousTAndDEndings","tOrDArePartOfStem","doNotStemTOrD","verbs","pastParticipleStemmer","compoundVerbsPrefixes","endingMatch","exactMatch","includes","endsWith","stemTOrDFromEndOfWord","slice"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemTOrDFromEndOfWord.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, other checks still need\n * to be done in order to be sure whether we need to stem the word further or not.\n * If one of these checks returns true, we do not need to stem the word further.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n * @returns {boolean}\tWhether one of the conditions returns true or not.\n */\nconst checkIfTorDIsUnambiguous = function(morphologyDataNL, stemmedWord, word) {\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  const adjectivesEndingInRd = morphologyDataNL.stemExceptions.removeSuffixesFromFullForms[1].forms;\n  const wordsEndingInTOrDExceptionList =\n    morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;\n\n  // Run the checks below. If one of the conditions returns true, return the stem.\n  if (\n    detectAndStemRegularParticiple(morphologyDataNL, word) ||\n    generateCorrectStemWithTAndDEnding(morphologyDataNL, word) ||\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word) ||\n    adjectivesEndingInRd.includes(stemmedWord) ||\n    checkExceptionsWithFullForms(morphologyDataNL, word) ||\n    stemmedWord.endsWith('heid') ||\n    checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)\n  ) {\n    return true;\n  }\n};\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, and if it\n * is not a participle (which has its separate check), then it is still ambiguous whether -t/-d is part of the stem or a suffix.\n * Therefore, a second stem should be created with the -t/-d removed in case it was a suffix. For example, in the verb 'poolt',\n * -t is a suffix, but we could not predict in any of the previous checks that -t should be stemmed. To account for such cases,\n * we stem the -t here.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n *\n * @returns {?string}\t\t\t\t    The stemmed word or null if the -t/-d should not be stemmed.\n */\nexport function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {\n  if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {\n    return null;\n  }\n  // If none of the conditions above is true, stem the t/d from the word.\n  return stemmedWord.slice(0, -1);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGH,kBAAkB;AAEtB,SAAQI,8BAA8B;AACtC,SAAQC,kCAAkC;AAC1C,OAAOC,4BAA4B;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,GAAG,SAAAA,CAASC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EAC7E,MAAMC,mBAAmB,GAAGH,gBAAgB,CAACI,cAAc,CAACC,6BAA6B;EACzF,MAAMC,oBAAoB,GAAGN,gBAAgB,CAACI,cAAc,CAACG,2BAA2B,CAAC,CAAC,CAAC,CAACC,KAAK;EACjG,MAAMC,8BAA8B,GAClCT,gBAAgB,CAACU,qBAAqB,CAACC,iBAAiB,CAACC,aAAa;;EAExE;EACA,IACEhB,8BAA8B,CAACI,gBAAgB,EAAEE,IAAI,CAAC,IACtDL,kCAAkC,CAACG,gBAAgB,EAAEE,IAAI,CAAC,IAC1DP,oCAAoC,CAClCO,IAAI,EACJC,mBAAmB,CAACU,KAAK,EACzBb,gBAAgB,CAACc,qBAAqB,CAACC,qBACzC,CAAC,IACDrB,kCAAkC,CAACQ,IAAI,EAAEC,mBAAmB,CAACa,WAAW,CAAC,IACzEb,mBAAmB,CAACc,UAAU,CAACC,QAAQ,CAAChB,IAAI,CAAC,IAC7CI,oBAAoB,CAACY,QAAQ,CAACjB,WAAW,CAAC,IAC1CH,4BAA4B,CAACE,gBAAgB,EAAEE,IAAI,CAAC,IACpDD,WAAW,CAACkB,QAAQ,CAAC,MAAM,CAAC,IAC5BzB,kCAAkC,CAACO,WAAW,EAAEQ,8BAA8B,CAAC,EAC/E;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASW,qBAAqBA,CAACpB,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EACzE,IAAIH,wBAAwB,CAACC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,CAAC,EAAE;IACjE,OAAO,IAAI;EACb;EACA;EACA,OAAOD,WAAW,CAACoB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACjC","ignoreList":[]}

package/build/languageProcessing/languages/nl/values/Clause.js

@@ -0,0 +1,57 @@
+import { includes } from 'lodash';
+import { languageProcessing } from "../../../../index.js";
+const {
+  directPrecedenceException,
+  values
+} = languageProcessing;
+const {
+  Clause
+} = values;
+import { cannotDirectlyPrecedePassiveParticiple } from "../config/functionWords";
+import nonParticiples from "../config/internal/nonParticiples";
+import getParticiples from "../helpers/internal/getParticiples";
+
+/**
+ * Creates a Clause object for the Dutch language.
+ */
+class DutchClause extends Clause {
+  /**
+   * Constructor.
+   *
+   * @param {string} clauseText   The text of the clause.
+   * @param {Array} auxiliaries   The auxiliaries.
+   *
+   * @constructor
+   */
+  constructor(clauseText, auxiliaries) {
+    super(clauseText, auxiliaries);
+    this._participles = getParticiples(this.getClauseText());
+    this.checkParticiples();
+  }
+
+  /**
+   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
+   * If no exceptions are found and there is an auxiliary present, the clause is passive.
+   *
+   * @returns {void}
+   */
+  checkParticiples() {
+    const foundParticiples = this.getParticiples().filter(participle => {
+      return !includes(nonParticiples, participle) && !this.hasNonParticipleEnding(participle) && !directPrecedenceException(this.getClauseText(), participle, cannotDirectlyPrecedePassiveParticiple);
+    });
+    this.setPassive(foundParticiples.length > 0);
+  }
+
+  /**
+   * Checks whether a found participle has a non-participle ending and is therefore not really a participle.
+   *
+   * @param {string} participle   The participle to check.
+   *
+   * @returns {boolean} Returns true if the participle has a non-participle ending, otherwise returns false.
+   */
+  hasNonParticipleEnding(participle) {
+    return /\S+(heid|teit|tijd)($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi.test(participle);
+  }
+}
+export default DutchClause;
+//# sourceMappingURL=Clause.js.map

package/build/languageProcessing/languages/nl/values/Clause.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Clause.js","names":["includes","languageProcessing","directPrecedenceException","values","Clause","cannotDirectlyPrecedePassiveParticiple","nonParticiples","getParticiples","DutchClause","constructor","clauseText","auxiliaries","_participles","getClauseText","checkParticiples","foundParticiples","filter","participle","hasNonParticipleEnding","setPassive","length","test"],"sources":["../../../../../src/languageProcessing/languages/nl/values/Clause.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {directPrecedenceException, values} = languageProcessing;\nconst {Clause} = values;\n\nimport {cannotDirectlyPrecedePassiveParticiple} from '../config/functionWords';\nimport nonParticiples from '../config/internal/nonParticiples';\nimport getParticiples from '../helpers/internal/getParticiples';\n\n/**\n * Creates a Clause object for the Dutch language.\n */\nclass DutchClause extends Clause {\n  /**\n   * Constructor.\n   *\n   * @param {string} clauseText   The text of the clause.\n   * @param {Array} auxiliaries   The auxiliaries.\n   *\n   * @constructor\n   */\n  constructor(clauseText, auxiliaries) {\n    super(clauseText, auxiliaries);\n    this._participles = getParticiples(this.getClauseText());\n    this.checkParticiples();\n  }\n\n  /**\n   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.\n   * If no exceptions are found and there is an auxiliary present, the clause is passive.\n   *\n   * @returns {void}\n   */\n  checkParticiples() {\n    const foundParticiples = this.getParticiples().filter(participle => {\n      return (\n        !includes(nonParticiples, participle) &&\n        !this.hasNonParticipleEnding(participle) &&\n        !directPrecedenceException(\n          this.getClauseText(),\n          participle,\n          cannotDirectlyPrecedePassiveParticiple\n        )\n      );\n    });\n\n    this.setPassive(foundParticiples.length > 0);\n  }\n\n  /**\n   * Checks whether a found participle has a non-participle ending and is therefore not really a participle.\n   *\n   * @param {string} participle   The participle to check.\n   *\n   * @returns {boolean} Returns true if the participle has a non-participle ending, otherwise returns false.\n   */\n  hasNonParticipleEnding(participle) {\n    return /\\S+(heid|teit|tijd)($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi.test(participle);\n  }\n}\n\nexport default DutchClause;\n"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,QAAQ;AAC/B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,yBAAyB;EAAEC;AAAM,CAAC,GAAGF,kBAAkB;AAC9D,MAAM;EAACG;AAAM,CAAC,GAAGD,MAAM;AAEvB,SAAQE,sCAAsC;AAC9C,OAAOC,cAAc;AACrB,OAAOC,cAAc;;AAErB;AACA;AACA;AACA,MAAMC,WAAW,SAASJ,MAAM,CAAC;EAC/B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEK,WAAWA,CAACC,UAAU,EAAEC,WAAW,EAAE;IACnC,KAAK,CAACD,UAAU,EAAEC,WAAW,CAAC;IAC9B,IAAI,CAACC,YAAY,GAAGL,cAAc,CAAC,IAAI,CAACM,aAAa,CAAC,CAAC,CAAC;IACxD,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEA,gBAAgBA,CAAA,EAAG;IACjB,MAAMC,gBAAgB,GAAG,IAAI,CAACR,cAAc,CAAC,CAAC,CAACS,MAAM,CAACC,UAAU,IAAI;MAClE,OACE,CAACjB,QAAQ,CAACM,cAAc,EAAEW,UAAU,CAAC,IACrC,CAAC,IAAI,CAACC,sBAAsB,CAACD,UAAU,CAAC,IACxC,CAACf,yBAAyB,CACxB,IAAI,CAACW,aAAa,CAAC,CAAC,EACpBI,UAAU,EACVZ,sCACF,CAAC;IAEL,CAAC,CAAC;IAEF,IAAI,CAACc,UAAU,CAACJ,gBAAgB,CAACK,MAAM,GAAG,CAAC,CAAC;EAC9C;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEF,sBAAsBA,CAACD,UAAU,EAAE;IACjC,OAAO,wDAAwD,CAACI,IAAI,CAACJ,UAAU,CAAC;EAClF;AACF;AAEA,eAAeT,WAAW","ignoreList":[]}

package/build/languageProcessing/languages/pl/Researcher.js

@@ -0,0 +1,48 @@
+import { languageProcessing } from "../../../index.js";
+const {
+  AbstractResearcher
+} = languageProcessing;
+
+// All config
+import firstWordExceptions from "./config/firstWordExceptions";
+import { all as functionWords } from "./config/functionWords";
+import stopWords from "./config/stopWords";
+import transitionWords from "./config/transitionWords";
+import twoPartTransitionWords from "./config/twoPartTransitionWords";
+import sentenceLength from "./config/sentenceLength";
+
+// All helpers
+import getClauses from "./helpers/getClauses";
+import getStemmer from "./helpers/getStemmer";
+
+/**
+ * The researcher contains all the researches, helpers, data, and config.
+ */
+export default class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+
+    // Delete a research(es) that is not available in Polish
+    delete this.defaultResearches.getFleschReadingScore;
+    Object.assign(this.config, {
+      language: 'pl',
+      passiveConstructionType: 'periphrastic',
+      firstWordExceptions,
+      functionWords,
+      stopWords,
+      transitionWords,
+      twoPartTransitionWords,
+      sentenceLength: sentenceLength
+    });
+    Object.assign(this.helpers, {
+      getClauses,
+      getStemmer
+    });
+  }
+}
+//# sourceMappingURL=Researcher.js.map

package/build/languageProcessing/languages/pl/Researcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Researcher.js","names":["languageProcessing","AbstractResearcher","firstWordExceptions","all","functionWords","stopWords","transitionWords","twoPartTransitionWords","sentenceLength","getClauses","getStemmer","Researcher","constructor","paper","defaultResearches","getFleschReadingScore","Object","assign","config","language","passiveConstructionType","helpers"],"sources":["../../../../src/languageProcessing/languages/pl/Researcher.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport stopWords from './config/stopWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport sentenceLength from './config/sentenceLength';\n\n// All helpers\nimport getClauses from './helpers/getClauses';\nimport getStemmer from './helpers/getStemmer';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    // Delete a research(es) that is not available in Polish\n    delete this.defaultResearches.getFleschReadingScore;\n\n    Object.assign(this.config, {\n      language: 'pl',\n      passiveConstructionType: 'periphrastic',\n      firstWordExceptions,\n      functionWords,\n      stopWords,\n      transitionWords,\n      twoPartTransitionWords,\n      sentenceLength: sentenceLength\n    });\n\n    Object.assign(this.helpers, {\n      getClauses,\n      getStemmer\n    });\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAkB,CAAC,GAAGD,kBAAkB;;AAE/C;AACA,OAAOE,mBAAmB;AAC1B,SAAQC,GAAG,IAAIC,aAAa;AAC5B,OAAOC,SAAS;AAChB,OAAOC,eAAe;AACtB,OAAOC,sBAAsB;AAC7B,OAAOC,cAAc;;AAErB;AACA,OAAOC,UAAU;AACjB,OAAOC,UAAU;;AAEjB;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASV,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEW,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;;IAEZ;IACA,OAAO,IAAI,CAACC,iBAAiB,CAACC,qBAAqB;IAEnDC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,cAAc;MACvClB,mBAAmB;MACnBE,aAAa;MACbC,SAAS;MACTC,eAAe;MACfC,sBAAsB;MACtBC,cAAc,EAAEA;IAClB,CAAC,CAAC;IAEFQ,MAAM,CAACC,MAAM,CAAC,IAAI,CAACI,OAAO,EAAE;MAC1BZ,UAAU;MACVC;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

package/build/languageProcessing/languages/pl/config/firstWordExceptions.js

@@ -0,0 +1,10 @@
+/**
+ *  Returns an array with exceptions for the sentence beginning researcher.
+ *  @returns {Array} The array filled with exceptions.
+ *  */
+export default [
+// Numbers 1-10:
+"jeden", "jedna", "jedno", "dwa", "dwie", "trzy", "cztery", "pięć", "sześć", "siedem", "osiem", "dziewięć", "dziesięć",
+// Demonstrative pronouns:
+"ta", "to", "ten", "te", "ci", "taki", "tacy", "taka", "taką", "takich", "takie", "takiego", "takiej", "takiemu", "takim", "takimi", "tamten", "tamta", "tamto", "tamci", "tamte", "tamtą", "tamtego", "tamtej", "tamtemu", "tamtych", "tamtym", "tamtymi", "tą", "tę", "tego", "tej", "temu", "tych", "tymi", "tym", "tak"];
+//# sourceMappingURL=firstWordExceptions.js.map

package/build/languageProcessing/languages/pl/config/firstWordExceptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstWordExceptions.js","names":[],"sources":["../../../../../src/languageProcessing/languages/pl/config/firstWordExceptions.js"],"sourcesContent":["/**\n *  Returns an array with exceptions for the sentence beginning researcher.\n *  @returns {Array} The array filled with exceptions.\n *  */\nexport default [\n\t// Numbers 1-10:\n\t\"jeden\", \"jedna\", \"jedno\", \"dwa\", \"dwie\", \"trzy\", \"cztery\", \"pięć\", \"sześć\", \"siedem\", \"osiem\", \"dziewięć\", \"dziesięć\",\n\t// Demonstrative pronouns:\n\t\"ta\", \"to\", \"ten\", \"te\", \"ci\", \"taki\", \"tacy\", \"taka\", \"taką\", \"takich\", \"takie\", \"takiego\", \"takiej\", \"takiemu\",\n\t\"takim\", \"takimi\", \"tamten\", \"tamta\", \"tamto\", \"tamci\", \"tamte\", \"tamtą\", \"tamtego\", \"tamtej\", \"tamtemu\", \"tamtych\",\n\t\"tamtym\", \"tamtymi\", \"tą\", \"tę\", \"tego\", \"tej\", \"temu\", \"tych\", \"tymi\", \"tym\", \"tak\",\n];\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA,eAAe;AACd;AACA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU;AACtH;AACA,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAChH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EACnH,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CACpF","ignoreList":[]}