axyseo 2.0.0-alpha.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkExceptionsWithFullForms.js","names":["_lodash","require","_index","flattenSortLength","languageProcessing","checkVerbFullFormsList","word","verbFullFormsList","compoundVerbPrefixes","prefixes","foundPrefix","find","prefix","startsWith","slice","length","i","stemAndForms","flatten","j","includes","checkEndingMatchFullFormsList","endingMatchFullFormsList","endsWith","precedingLexicalMaterial","checkExactMatchFullFormsList","exactMatchFullFormsList","checkExceptionsWithFullForms","morphologyDataNL","exceptionListWithFullForms","stemExceptions","stemmingExceptionStemsWithFullForms","stem","verbs","pastParticipleStemmer","compoundVerbsPrefixes","endingMatch","exactMatch"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/checkExceptionsWithFullForms.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '../../../index';\nconst {flattenSortLength} = languageProcessing;\n\n/**\n * Checks whether the word is on the verbs sub-list of the full forms list. Before checking the list, checks whether the word\n * begins with one of the compound verb prefixes, and the prefix is removed if one is found. If a match is found after checking\n * the full forms list, the canonical stem is returned, with the prefix attached back if there was one in the input word.\n * e.g. aanbevelen -> aanbeveel\n *\n * @param {string}\t\t\tword\t\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\tverbFullFormsList\t\t\t\tThe list of verb forms we search for match in.\n * @param {Object}\t\t\tcompoundVerbPrefixes\t\t\tThe list of separable and inseparable compound verb prefixes.\n *\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkVerbFullFormsList = function(word, verbFullFormsList, compoundVerbPrefixes) {\n  const prefixes = flattenSortLength(compoundVerbPrefixes);\n\n  // Check whether the inputted word starts with one of the compound prefixes\n  const foundPrefix = prefixes.find(prefix => word.startsWith(prefix));\n\n  if (typeof foundPrefix === 'string') {\n    word = word.slice(foundPrefix.length);\n  }\n\n  for (let i = 0; i < verbFullFormsList.length; i++) {\n    const stemAndForms = flatten(verbFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (stemAndForms.includes(word)) {\n        if (typeof foundPrefix === 'string') {\n          return foundPrefix + stemAndForms[0];\n        }\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n * Checks whether the word is on the sub-list of the full forms list for which we search for an ending match between one of\n * the forms and the word (i.e., whether the word ends with a form from the list). If a match is found, the canonical\n * stem is returned. e.g. fitnesscentra -> fitnesscentrum\n *\n * @param {string}\t\t\tword\t\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\tendingMatchFullFormsList\t\tThe list we search for an ending match in.\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkEndingMatchFullFormsList = function(word, endingMatchFullFormsList) {\n  for (let i = 0; i < endingMatchFullFormsList.length; i++) {\n    const stemAndForms = flatten(endingMatchFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (word.endsWith(stemAndForms[j])) {\n        /*\n         * Check if the word checked is actually a compound word. e.g. familielid\n         * The character/s preceding the words in the exception should be at least 2 characters in order to be a valid compound element.\n         */\n        const precedingLexicalMaterial = word.slice(0, -stemAndForms[j].length);\n\n        if (precedingLexicalMaterial.length === 1) {\n          return null;\n        }\n\n        if (precedingLexicalMaterial.length > 1) {\n          return precedingLexicalMaterial + stemAndForms[0];\n        }\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n * Checks whether the word is on the sub-list of the full forms list for which we search for the exact match between one of\n * the forms and the word. If a match is found, the canonical stem is returned. e.g. curricula -> curriculum\n *\n * @param {string}\t\t\tword\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\texactMatchFullFormsList\t\tThe list we search for an exact match in.\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkExactMatchFullFormsList = function(word, exactMatchFullFormsList) {\n  for (let i = 0; i < exactMatchFullFormsList.length; i++) {\n    const stemAndForms = flatten(exactMatchFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (stemAndForms.includes(word)) {\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n *\n * Checks whether a word is on the exception list for which we have full forms. If it is, returns the indicated stem of the word.\n *\n * @param {Array} morphologyDataNL The Dutch morphology data file.\n * @param {string} word The word to check.\n *\n * @returns {string/null} The created word forms.\n */\nexport default function checkExceptionsWithFullForms(morphologyDataNL, word) {\n  const exceptionListWithFullForms =\n    morphologyDataNL.stemExceptions.stemmingExceptionStemsWithFullForms;\n\n  let stem = checkVerbFullFormsList(\n    word,\n    exceptionListWithFullForms.verbs,\n    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n  );\n  if (stem) {\n    return stem;\n  }\n\n  stem = checkEndingMatchFullFormsList(word, exceptionListWithFullForms.endingMatch);\n  if (stem) {\n    return stem;\n  }\n\n  stem = checkExactMatchFullFormsList(word, exceptionListWithFullForms.exactMatch);\n  if (stem) {\n    return stem;\n  }\n\n  return null;\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectAndStemRegularParticiple = detectAndStemRegularParticiple;
+var _index = require("../../../index");
+var _nonParticiples = _interopRequireDefault(require("../../config/internal/nonParticiples.js"));
+var _stemModificationHelpers = require("./stemModificationHelpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  regexHelpers: {
+    doesWordMatchRegex
+  }
+} = _index.languageProcessing;
+/**
+ * Checks whether the word is on an exception list of participles that do not have a ge- prefix. If it is found on the list,
+ * remove only the last letter (the suffix).
+ *
+ * @param {array} dataExceptionListToCheck The list of the exception words.
+ * @param {string} word 	The (unstemmed) word to check.
+ *
+ * @returns {null|string} The stemmed word or null if the word was not found on the exception list.
+ */
+const checkAndStemIfExceptionWithoutGePrefix = function (dataExceptionListToCheck, word) {
+  if (dataExceptionListToCheck.includes(word)) {
+    return word.slice(0, -1);
+  }
+  return null;
+};
+
+/**
+ * Checks whether a word that was detected as a participle should not have the suffix (-t or -d) removed because it is part
+ * of the stem. For example, in the participle 'geantwoord', the -d belongs to the stem so it should not be removed.
+ * The checks are conducted on the word without the prefix, so 'antwoord' in the case of 'geantwoord'.
+ *
+ * For words ending in -t, there are three checks:
+ * 1) An exception list (exceptions to a rule) containing words where -t SHOULD be stemmed,
+ * 2) The rule, defined using a regex with word endings where -t is part of the stem,
+ * 3) A list of verbs with stem ending in -t, to cover cases that were not possible to find using a regex.
+ *
+ * For words ending in -d, we check a list of verbs with stem ending in -d.
+ *
+ * @param {string}	wordWithoutPrefix	The word without prefix(es).
+ * @param {Object}	morphologyDataNL	The Dutch morphology data.
+ *
+ * @returns {boolean}					Whether the suffix should be stemmed.
+ */
+const shouldSuffixBeStemmed = function (wordWithoutPrefix, morphologyDataNL) {
+  if (wordWithoutPrefix.endsWith('t')) {
+    // Return true (suffix should be stemmed) if word was found on the exception list of verbs which should have the final -t stemmed.
+    const exceptionsTShouldBeStemmed = morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed;
+    if (exceptionsTShouldBeStemmed.includes(wordWithoutPrefix)) {
+      return true;
+    }
+    // Return false (suffix should not be stemmed) if word matches the regex for stems ending in -t.
+    if (doesWordMatchRegex(wordWithoutPrefix, morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding)) {
+      return false;
+    }
+    /*
+     * Return false (suffix should not be stemmed) if the word was found on the list of verbs with stem ending in -t (e.g. haast)
+     * Otherwise, return true (if no checks are matched, the default condition is for -t to be stemmed).
+     */
+    const exceptionsTShouldNotBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions.verbs;
+    return !exceptionsTShouldNotBeStemmed.includes(wordWithoutPrefix);
+  }
+  const exceptionsDShouldNotBeStemmed = morphologyDataNL.pastParticipleStemmer.doNotStemD;
+  return !exceptionsDShouldNotBeStemmed.includes(wordWithoutPrefix);
+};
+
+/**
+ * Detects whether a word is a participle of a regular verb without prefixes other than ge-. If it is, checks whether
+ * the word is an exception that should not have the prefix or the suffix stemmed. Then stems the word accordingly
+ * (remove prefix, suffix, or both).
+ *
+ * @param {Object}  morphologyDataNL	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle was matched.
+ */
+const detectAndStemParticiplesWithoutPrefixes = function (morphologyDataNL, word) {
+  const geStemTParticipleRegex = new RegExp('^' + morphologyDataNL.pastParticipleStemmer.participleStemmingClasses[0].regex);
+
+  // Check if it's a ge + stem + t/d participle.
+  if (geStemTParticipleRegex.test(word)) {
+    // Check if the ge- is actually part of the stem. If yes, stem only the suffix.
+    const exception = checkAndStemIfExceptionWithoutGePrefix(morphologyDataNL.pastParticipleStemmer.doNotStemGe, word);
+    if (exception) {
+      return exception;
+    }
+
+    // Remove the prefix.
+    let wordWithoutPrefix = word.slice(2);
+
+    // Check if stem starts with ë. If yes, replace ë with e.
+    if (wordWithoutPrefix.startsWith('ë')) {
+      wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);
+    }
+    // Check whether the suffix should be stemmed. If yes, remove it and return the stem.
+    if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {
+      return wordWithoutPrefix.slice(0, -1);
+    }
+    return wordWithoutPrefix;
+  }
+  return null;
+};
+
+/**
+ * Determines whether a given participle pattern combined with prefixes from a given class (separable or inseparable)
+ * applies to a given word and if so, returns the stem.
+ *
+ * @param {Object}      morphologyDataNL 	The Dutch morphology data.
+ * @param {string}      word        		The word (not stemmed) to check.
+ * @param {boolean}     separable  			Whether the prefix is separable or not.
+ * @param {string[]}    prefixes    		The prefixes of a certain prefix class.
+ * @param {string}      regexPart   		The regex part for a given class (completed to a full regex within the function).
+ *
+ * @returns {string|null} The stem or null if no prefixed participle was matched.
+ */
+const detectAndStemParticiplePerPrefixClass = function (morphologyDataNL, word, separable, prefixes, regexPart) {
+  for (const currentPrefix of prefixes) {
+    const participleRegex = new RegExp('^' + currentPrefix + regexPart);
+    if (participleRegex.test(word)) {
+      let wordWithoutPrefix = word.slice(currentPrefix.length - word.length);
+      /*
+       * After removing a separable prefix, check whether the ge- belongs to the stem (e.g. the -ge- in opgebruikt).
+       * If it does, stem only the suffix.
+       */
+      if (separable) {
+        const exception = checkAndStemIfExceptionWithoutGePrefix(morphologyDataNL.pastParticipleStemmer.doNotStemGe, wordWithoutPrefix);
+        if (exception) {
+          return currentPrefix + exception;
+        }
+        wordWithoutPrefix = wordWithoutPrefix.slice(2);
+      }
+      // Check whether stem starts with ë. If yes, replace ë with e.
+      if (wordWithoutPrefix.startsWith('ë')) {
+        wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);
+      }
+      if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {
+        return currentPrefix + wordWithoutPrefix.slice(0, -1);
+      }
+      return currentPrefix + wordWithoutPrefix;
+    }
+  }
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle of a compound verb. A compound verb has a prefix in addition to, or instead of, ge-.
+ * For example, afgemaakt has the separable prefix af-, and beantwoord has the inseparable prefix be-. If a participle
+ * of a compound verb is detected, it is stemmed by removing the ge- (in case of a verb with a separable prefix) and the suffix -t or -d.
+ *
+ * @param {Object}  morphologyDataNL 	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle with prefix was matched.
+ */
+const detectAndStemParticiplesWithPrefixes = function (morphologyDataNL, word) {
+  /*
+   * It's important to preserve order here, since the ge + stem ending in -t regex is more specific than
+   * the stem + t regex, and therefore must be checked first.
+   */
+  for (const participleClass of morphologyDataNL.pastParticipleStemmer.participleStemmingClasses) {
+    const regex = participleClass.regex;
+    const separable = participleClass.separable;
+    const prefixes = separable ? morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.separable : morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable;
+    const stem = detectAndStemParticiplePerPrefixClass(morphologyDataNL, word, separable, prefixes, regex);
+    if (stem) {
+      return stem;
+    }
+  }
+  return null;
+};
+
+/**
+ *  Checks whether the word is on the list of participles that do not need to be stemmed, because the participle form
+ *  is the same as the stem.
+ *
+ * @param {string[]} dataParticiplesSameAsStem	The list of exceptions whose stem is the same as the participle.
+ * @param {string} 	 word						The word to check.
+ * @returns {boolean} Whether the word is found on the exception list.
+ */
+const checkIfParticipleIsSameAsStem = function (dataParticiplesSameAsStem, word) {
+  return dataParticiplesSameAsStem.includes(word);
+};
+
+/**
+ * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.
+ * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.
+ *
+ * @param {array}  inseparablePrefixes      The list of inseparable prefixes.
+ * @param {array}  dataExceptionListToCheck The list of the exception words.
+ * @param {array}  finalChangesRules        The array of regex-based rules to be applied to the stem.
+ * @param {string} word 	                The (unstemmed) word to check.
+ *
+ * @returns {null|string} The stemmed word or null if the word was found on the exception list.
+ */
+const checkAndStemIfInseparablePrefixWithEndEnding = function (inseparablePrefixes, dataExceptionListToCheck, finalChangesRules, word) {
+  const startsWithInseparablePrefix = inseparablePrefixes.map(prefix => word.startsWith(prefix)).some(value => value === true);
+  if (startsWithInseparablePrefix && word.endsWith('end') && !dataExceptionListToCheck.includes(word)) {
+    return (0, _stemModificationHelpers.modifyStem)(word.slice(0, -3), finalChangesRules);
+  }
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataNL 	The Dutch morphology data.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The participle stem or null if no regular participle was matched.
+ */
+function detectAndStemRegularParticiple(morphologyDataNL, word) {
+  // Check whether the word is not a participle. If it is not, return empty string.
+  if (word.endsWith('heid') || word.endsWith('teit') || word.endsWith('tijd') || _nonParticiples.default.includes(word)) {
+    return '';
+  }
+
+  /**
+   * Check whether the word is on an exception list of verbs whose participle is the same as the stem. If the word is found
+   * on the list, return the stem.
+   */
+  if (checkIfParticipleIsSameAsStem(morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbsNotToBeStemmed, word)) {
+    return word;
+  }
+
+  // Check and stem if the word is a participle without any separable or inseparable prefix
+  let stem = detectAndStemParticiplesWithoutPrefixes(morphologyDataNL, word);
+  if (stem) {
+    return stem;
+  }
+
+  /**
+   * Check whether the word is on an exception list of inseparable compound verbs with a prefix that is usually separable.
+   * If it is, remove just the suffix and return the stem.
+   */
+  stem = checkAndStemIfExceptionWithoutGePrefix(morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbs, word);
+  if (stem) {
+    return stem;
+  }
+
+  /**
+   * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.
+   * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.
+   */
+  stem = checkAndStemIfInseparablePrefixWithEndEnding(morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable, morphologyDataNL.pastParticipleStemmer.pastParticiplesEndingOnEnd, morphologyDataNL.regularStemmer.stemModifications.finalChanges, word);
+  if (stem) {
+    return stem;
+  }
+
+  // Check and stem if the word is a participle with a separable or inseparable prefix
+  stem = detectAndStemParticiplesWithPrefixes(morphologyDataNL, word);
+  if (stem) {
+    return stem;
+  }
+  return null;
+}
+//# sourceMappingURL=detectAndStemRegularParticiple.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detectAndStemRegularParticiple.js","names":["_index","require","_nonParticiples","_interopRequireDefault","_stemModificationHelpers","e","__esModule","default","regexHelpers","doesWordMatchRegex","languageProcessing","checkAndStemIfExceptionWithoutGePrefix","dataExceptionListToCheck","word","includes","slice","shouldSuffixBeStemmed","wordWithoutPrefix","morphologyDataNL","endsWith","exceptionsTShouldBeStemmed","ambiguousTAndDEndings","wordsTShouldBeStemmed","tOrDArePartOfStem","tEnding","exceptionsTShouldNotBeStemmed","stemExceptions","wordsNotToBeStemmedExceptions","verbs","exceptionsDShouldNotBeStemmed","pastParticipleStemmer","doNotStemD","detectAndStemParticiplesWithoutPrefixes","geStemTParticipleRegex","RegExp","participleStemmingClasses","regex","test","exception","doNotStemGe","startsWith","detectAndStemParticiplePerPrefixClass","separable","prefixes","regexPart","currentPrefix","participleRegex","length","detectAndStemParticiplesWithPrefixes","participleClass","compoundVerbsPrefixes","inseparable","stem","checkIfParticipleIsSameAsStem","dataParticiplesSameAsStem","checkAndStemIfInseparablePrefixWithEndEnding","inseparablePrefixes","finalChangesRules","startsWithInseparablePrefix","map","prefix","some","value","modifyStem","detectAndStemRegularParticiple","nonParticiples","inseparableCompoundVerbsNotToBeStemmed","inseparableCompoundVerbs","pastParticiplesEndingOnEnd","regularStemmer","stemModifications","finalChanges"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/detectAndStemRegularParticiple.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {\n  regexHelpers: {doesWordMatchRegex}\n} = languageProcessing;\n\nimport nonParticiples from '../../config/internal/nonParticiples.js';\nimport {modifyStem} from './stemModificationHelpers';\n\n/**\n * Checks whether the word is on an exception list of participles that do not have a ge- prefix. If it is found on the list,\n * remove only the last letter (the suffix).\n *\n * @param {array} dataExceptionListToCheck The list of the exception words.\n * @param {string} word \tThe (unstemmed) word to check.\n *\n * @returns {null|string} The stemmed word or null if the word was not found on the exception list.\n */\nconst checkAndStemIfExceptionWithoutGePrefix = function(dataExceptionListToCheck, word) {\n  if (dataExceptionListToCheck.includes(word)) {\n    return word.slice(0, -1);\n  }\n  return null;\n};\n\n/**\n * Checks whether a word that was detected as a participle should not have the suffix (-t or -d) removed because it is part\n * of the stem. For example, in the participle 'geantwoord', the -d belongs to the stem so it should not be removed.\n * The checks are conducted on the word without the prefix, so 'antwoord' in the case of 'geantwoord'.\n *\n * For words ending in -t, there are three checks:\n * 1) An exception list (exceptions to a rule) containing words where -t SHOULD be stemmed,\n * 2) The rule, defined using a regex with word endings where -t is part of the stem,\n * 3) A list of verbs with stem ending in -t, to cover cases that were not possible to find using a regex.\n *\n * For words ending in -d, we check a list of verbs with stem ending in -d.\n *\n * @param {string}\twordWithoutPrefix\tThe word without prefix(es).\n * @param {Object}\tmorphologyDataNL\tThe Dutch morphology data.\n *\n * @returns {boolean}\t\t\t\t\tWhether the suffix should be stemmed.\n */\nconst shouldSuffixBeStemmed = function(wordWithoutPrefix, morphologyDataNL) {\n  if (wordWithoutPrefix.endsWith('t')) {\n    // Return true (suffix should be stemmed) if word was found on the exception list of verbs which should have the final -t stemmed.\n    const exceptionsTShouldBeStemmed = morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed;\n    if (exceptionsTShouldBeStemmed.includes(wordWithoutPrefix)) {\n      return true;\n    }\n    // Return false (suffix should not be stemmed) if word matches the regex for stems ending in -t.\n    if (\n      doesWordMatchRegex(\n        wordWithoutPrefix,\n        morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding\n      )\n    ) {\n      return false;\n    }\n    /*\n     * Return false (suffix should not be stemmed) if the word was found on the list of verbs with stem ending in -t (e.g. haast)\n     * Otherwise, return true (if no checks are matched, the default condition is for -t to be stemmed).\n     */\n    const exceptionsTShouldNotBeStemmed =\n      morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions.verbs;\n    return !exceptionsTShouldNotBeStemmed.includes(wordWithoutPrefix);\n  }\n  const exceptionsDShouldNotBeStemmed = morphologyDataNL.pastParticipleStemmer.doNotStemD;\n  return !exceptionsDShouldNotBeStemmed.includes(wordWithoutPrefix);\n};\n\n/**\n * Detects whether a word is a participle of a regular verb without prefixes other than ge-. If it is, checks whether\n * the word is an exception that should not have the prefix or the suffix stemmed. Then stems the word accordingly\n * (remove prefix, suffix, or both).\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The stem or null if no participle was matched.\n */\nconst detectAndStemParticiplesWithoutPrefixes = function(morphologyDataNL, word) {\n  const geStemTParticipleRegex = new RegExp(\n    '^' + morphologyDataNL.pastParticipleStemmer.participleStemmingClasses[0].regex\n  );\n\n  // Check if it's a ge + stem + t/d participle.\n  if (geStemTParticipleRegex.test(word)) {\n    // Check if the ge- is actually part of the stem. If yes, stem only the suffix.\n    const exception = checkAndStemIfExceptionWithoutGePrefix(\n      morphologyDataNL.pastParticipleStemmer.doNotStemGe,\n      word\n    );\n    if (exception) {\n      return exception;\n    }\n\n    // Remove the prefix.\n    let wordWithoutPrefix = word.slice(2);\n\n    // Check if stem starts with ë. If yes, replace ë with e.\n    if (wordWithoutPrefix.startsWith('ë')) {\n      wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);\n    }\n    // Check whether the suffix should be stemmed. If yes, remove it and return the stem.\n    if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {\n      return wordWithoutPrefix.slice(0, -1);\n    }\n\n    return wordWithoutPrefix;\n  }\n\n  return null;\n};\n\n/**\n * Determines whether a given participle pattern combined with prefixes from a given class (separable or inseparable)\n * applies to a given word and if so, returns the stem.\n *\n * @param {Object}      morphologyDataNL \tThe Dutch morphology data.\n * @param {string}      word        \t\tThe word (not stemmed) to check.\n * @param {boolean}     separable  \t\t\tWhether the prefix is separable or not.\n * @param {string[]}    prefixes    \t\tThe prefixes of a certain prefix class.\n * @param {string}      regexPart   \t\tThe regex part for a given class (completed to a full regex within the function).\n *\n * @returns {string|null} The stem or null if no prefixed participle was matched.\n */\nconst detectAndStemParticiplePerPrefixClass = function(\n  morphologyDataNL,\n  word,\n  separable,\n  prefixes,\n  regexPart\n) {\n  for (const currentPrefix of prefixes) {\n    const participleRegex = new RegExp('^' + currentPrefix + regexPart);\n\n    if (participleRegex.test(word)) {\n      let wordWithoutPrefix = word.slice(currentPrefix.length - word.length);\n      /*\n       * After removing a separable prefix, check whether the ge- belongs to the stem (e.g. the -ge- in opgebruikt).\n       * If it does, stem only the suffix.\n       */\n      if (separable) {\n        const exception = checkAndStemIfExceptionWithoutGePrefix(\n          morphologyDataNL.pastParticipleStemmer.doNotStemGe,\n          wordWithoutPrefix\n        );\n        if (exception) {\n          return currentPrefix + exception;\n        }\n        wordWithoutPrefix = wordWithoutPrefix.slice(2);\n      }\n      // Check whether stem starts with ë. If yes, replace ë with e.\n      if (wordWithoutPrefix.startsWith('ë')) {\n        wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);\n      }\n\n      if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {\n        return currentPrefix + wordWithoutPrefix.slice(0, -1);\n      }\n      return currentPrefix + wordWithoutPrefix;\n    }\n  }\n\n  return null;\n};\n\n/**\n * Detects whether a word is a regular participle of a compound verb. A compound verb has a prefix in addition to, or instead of, ge-.\n * For example, afgemaakt has the separable prefix af-, and beantwoord has the inseparable prefix be-. If a participle\n * of a compound verb is detected, it is stemmed by removing the ge- (in case of a verb with a separable prefix) and the suffix -t or -d.\n *\n * @param {Object}  morphologyDataNL \tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The stem or null if no participle with prefix was matched.\n */\nconst detectAndStemParticiplesWithPrefixes = function(morphologyDataNL, word) {\n  /*\n   * It's important to preserve order here, since the ge + stem ending in -t regex is more specific than\n   * the stem + t regex, and therefore must be checked first.\n   */\n  for (const participleClass of morphologyDataNL.pastParticipleStemmer.participleStemmingClasses) {\n    const regex = participleClass.regex;\n    const separable = participleClass.separable;\n\n    const prefixes = separable\n      ? morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.separable\n      : morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable;\n\n    const stem = detectAndStemParticiplePerPrefixClass(\n      morphologyDataNL,\n      word,\n      separable,\n      prefixes,\n      regex\n    );\n\n    if (stem) {\n      return stem;\n    }\n  }\n\n  return null;\n};\n\n/**\n *  Checks whether the word is on the list of participles that do not need to be stemmed, because the participle form\n *  is the same as the stem.\n *\n * @param {string[]} dataParticiplesSameAsStem\tThe list of exceptions whose stem is the same as the participle.\n * @param {string} \t word\t\t\t\t\t\tThe word to check.\n * @returns {boolean} Whether the word is found on the exception list.\n */\nconst checkIfParticipleIsSameAsStem = function(dataParticiplesSameAsStem, word) {\n  return dataParticiplesSameAsStem.includes(word);\n};\n\n/**\n * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.\n * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.\n *\n * @param {array}  inseparablePrefixes      The list of inseparable prefixes.\n * @param {array}  dataExceptionListToCheck The list of the exception words.\n * @param {array}  finalChangesRules        The array of regex-based rules to be applied to the stem.\n * @param {string} word \t                The (unstemmed) word to check.\n *\n * @returns {null|string} The stemmed word or null if the word was found on the exception list.\n */\nconst checkAndStemIfInseparablePrefixWithEndEnding = function(\n  inseparablePrefixes,\n  dataExceptionListToCheck,\n  finalChangesRules,\n  word\n) {\n  const startsWithInseparablePrefix = inseparablePrefixes\n    .map(prefix => word.startsWith(prefix))\n    .some(value => value === true);\n\n  if (\n    startsWithInseparablePrefix &&\n    word.endsWith('end') &&\n    !dataExceptionListToCheck.includes(word)\n  ) {\n    return modifyStem(word.slice(0, -3), finalChangesRules);\n  }\n  return null;\n};\n\n/**\n * Detects whether a word is a regular participle and if so, returns the stem.\n *\n * @param {Object}  morphologyDataNL \tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The participle stem or null if no regular participle was matched.\n */\nexport function detectAndStemRegularParticiple(morphologyDataNL, word) {\n  // Check whether the word is not a participle. If it is not, return empty string.\n  if (\n    word.endsWith('heid') ||\n    word.endsWith('teit') ||\n    word.endsWith('tijd') ||\n    nonParticiples.includes(word)\n  ) {\n    return '';\n  }\n\n  /**\n   * Check whether the word is on an exception list of verbs whose participle is the same as the stem. If the word is found\n   * on the list, return the stem.\n   */\n  if (\n    checkIfParticipleIsSameAsStem(\n      morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbsNotToBeStemmed,\n      word\n    )\n  ) {\n    return word;\n  }\n\n  // Check and stem if the word is a participle without any separable or inseparable prefix\n  let stem = detectAndStemParticiplesWithoutPrefixes(morphologyDataNL, word);\n\n  if (stem) {\n    return stem;\n  }\n\n  /**\n   * Check whether the word is on an exception list of inseparable compound verbs with a prefix that is usually separable.\n   * If it is, remove just the suffix and return the stem.\n   */\n  stem = checkAndStemIfExceptionWithoutGePrefix(\n    morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbs,\n    word\n  );\n\n  if (stem) {\n    return stem;\n  }\n\n  /**\n   * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.\n   * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.\n   */\n  stem = checkAndStemIfInseparablePrefixWithEndEnding(\n    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable,\n    morphologyDataNL.pastParticipleStemmer.pastParticiplesEndingOnEnd,\n    morphologyDataNL.regularStemmer.stemModifications.finalChanges,\n    word\n  );\n\n  if (stem) {\n    return stem;\n  }\n\n  // Check and stem if the word is a participle with a separable or inseparable prefix\n  stem = detectAndStemParticiplesWithPrefixes(morphologyDataNL, word);\n\n  if (stem) {\n    return stem;\n  }\n\n  return null;\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = detectAndStemSuffixes;
+var _stemModificationHelpers = require("./stemModificationHelpers");
+/**
+ * @file Dutch stemming algorithm. Adapted from:
+ * @author:
+ * @copyright
+ * All rights reserved.
+ * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/dutch/stemmer.html
+ * Copyright of the algorithm is: Copyright (c) 2001, Dr Martin Porter and can be found at http://snowball.tartarus.org/license.php
+ *
+ * Redistribution and use in source and binary forms, with or without modification, is covered by the standard BSD license.
+ */
+
+/**
+ * Determines the start index of the R1 region.
+ * R1 is the region after the first non-vowel following a vowel. It should include at least 3 letters.
+ *
+ * @param {string} word The word for which to determine the R1 region.
+ * @returns {number} The start index of the R1 region.
+ */
+const determineR1 = function (word) {
+  // Start with matching the first cluster that consists of a vowel and a non-vowel.
+  let r1Index = word.search(/[aeiouyèäüëïöáéíóú][^aeiouyèäüëïöáéíóú]/);
+  // Then add 2 since the R1 index is the index after the first vowel & non-vowel matched with the regex.
+  if (r1Index !== -1) {
+    r1Index += 2;
+  }
+
+  // Adjust R1 so that the region preceding it includes at least 3 letters.
+  if (r1Index !== -1 && r1Index < 3) {
+    r1Index = 3;
+  }
+  return r1Index;
+};
+
+/**
+ * Searches for suffixes in a word.
+ *
+ * @param {string} word 		The word in which to look for suffixes.
+ * @param {Object} suffixStep	One of the three steps of findings suffixes.
+ * @param {number} r1Index		The index of the R1 region.
+ *
+ * @returns {Object} The index of the suffix and extra information about whether, and how, the stem will need to be modified.
+ */
+const findSuffix = function (word, suffixStep, r1Index) {
+  const suffixStepArray = Object.entries(suffixStep);
+  for (const suffixClass of suffixStepArray) {
+    const suffixes = suffixClass[1].suffixes;
+    const matchedRegex = suffixes.find(suffixRegex => new RegExp(suffixRegex).exec(word));
+    if (matchedRegex) {
+      const matched = new RegExp(matchedRegex).exec(word);
+      const suffix = matched[matched.length - 1];
+      const suffixIndex = word.lastIndexOf(suffix);
+      if (r1Index !== -1 && suffixIndex >= r1Index) {
+        return {
+          suffixIndex: suffixIndex,
+          stemModification: suffixClass[1].stemModification
+        };
+      }
+    }
+  }
+};
+
+/**
+ * Deletes the suffix and modifies the stem according to the required modifications.
+ *
+ * @param {string} word	 The word from which to delete the suffix.
+ * @param {Object} suffixStep 	One of the three steps of deleting a suffix.
+ * @param {number} suffixIndex	 The index of the found suffix.
+ * @param {string} stemModification 	The type of stem modification that needs to be done.
+ * @param {Object} morphologyDataNL	 The Dutch morphology data file.
+ * @returns {string} The stemmed and modified word.
+ */
+const deleteSuffixAndModifyStem = function (word, suffixStep, suffixIndex, stemModification, morphologyDataNL) {
+  if (stemModification === "hedenToHeid") {
+    return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.hedenToHeid);
+  }
+  word = word.substring(0, suffixIndex);
+  if (stemModification === "changeIedtoId") {
+    return (0, _stemModificationHelpers.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 word;
+};
+
+/**
+ * Finds and deletes the suffix found in a particular step, and modifies the stem.
+ *
+ * @param {string} word 	The word for which to find and delete a suffix.
+ * @param {Object} suffixStep	 One of the three suffix steps.
+ * @param {number} r1Index	 The index of the R1 region.
+ * @param {Object} morphologyDataNL	 The Dutch morphology data file.
+ * @returns {string} The word with the deleted suffix.
+ */
+const findAndDeleteSuffix = function (word, suffixStep, r1Index, morphologyDataNL) {
+  const foundSuffix = findSuffix(word, suffixStep, r1Index);
+  if (typeof foundSuffix !== "undefined") {
+    word = deleteSuffixAndModifyStem(word, suffixStep, foundSuffix.suffixIndex, foundSuffix.stemModification, morphologyDataNL);
+  }
+  return word;
+};
+
+/**
+ * Runs through three stemming steps that process different kinds of suffixes, determines if there is a valid suffix
+ * within the R1 region that can be deleted for stemming and deletes it, as well as applies suffix-specific stem
+ * modifications if needed.
+ *
+ * @param {string} word 	The word for which to find and delete suffixes.
+ * @param {Object} suffixSteps	 All of the suffix steps.
+ * @param {number} r1Index	 The index of the R1 region
+ * @param {Object} morphologyDataNL 	The Dutch morphology data file.
+ * @returns {string} The word with the delete suffix.
+ */
+const findAndDeleteSuffixes = function (word, suffixSteps, r1Index, morphologyDataNL) {
+  const suffixStepsArray = Object.entries(suffixSteps);
+  for (const suffixStep of suffixStepsArray) {
+    word = findAndDeleteSuffix(word, suffixStep[1], r1Index, morphologyDataNL);
+  }
+  return word;
+};
+
+/**
+ * Search for suffixes in a word, remove them if found, and modify the stem if needed.
+ *
+ * @param {string} word  The word to stem.
+ * @param {Object} morphologyDataNL The Dutch morphology data file.
+ *
+ * @returns {string} The stemmed word.
+ */
+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);
+
+  // Find the start index of the R1 region.
+  const r1Index = determineR1(word);
+
+  // Import the suffixes from all three steps.
+  const suffixSteps = morphologyDataNL.regularStemmer.suffixes;
+
+  // Run through the three steps of possible de-suffixation.
+  word = findAndDeleteSuffixes(word, suffixSteps, r1Index, morphologyDataNL);
+
+  // Do final modifications to the stem.
+  return (0, _stemModificationHelpers.modifyStem)(word, morphologyDataNL.regularStemmer.stemModifications.finalChanges);
+}
+//# sourceMappingURL=detectAndStemSuffixes.js.map

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

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

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

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