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

package/build/languageProcessing/languages/de/helpers/checkIfWordIsFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkIfWordIsFunction.js","names":["all","functionWords","checkIfWordIsFunction","word","toLowerCase","includes"],"sources":["../../../../../src/languageProcessing/languages/de/helpers/checkIfWordIsFunction.js"],"sourcesContent":["import { all as functionWords } from \"../config/functionWords\";\n\n/**\n * Checks if a word is a function word.\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} Whether or not a word is a function word.\n */\nexport default function checkIfWordIsFunction( word ) {\n\t// All words are converted to lower case before processing to avoid excluding function words that start with a capital letter.\n\tword = word.toLowerCase();\n\n\treturn functionWords.includes( word );\n}\n"],"mappings":"AAAA,SAASA,GAAG,IAAIC,aAAa;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,qBAAqBA,CAAEC,IAAI,EAAG;EACrD;EACAA,IAAI,GAAGA,IAAI,CAACC,WAAW,CAAC,CAAC;EAEzB,OAAOH,aAAa,CAACI,QAAQ,CAAEF,IAAK,CAAC;AACtC","ignoreList":[]}

package/build/languageProcessing/languages/de/helpers/getClauses.js

@@ -0,0 +1,27 @@
+import { languageProcessing } from "../../../../index.js";
+const {
+  getClausesSplitOnStopWords,
+  createRegexFromArray
+} = languageProcessing;
+import GermanClause from "../values/Clause";
+import auxiliaries from "../config/internal/passiveVoiceAuxiliaries.js";
+import stopwords from "../config/stopWords.js";
+const options = {
+  Clause: GermanClause,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries.all),
+    stopwordRegex: createRegexFromArray(stopwords)
+  }
+};
+
+/**
+ * Gets the clauses from a sentence by determining sentence breakers.
+ *
+ * @param {string} sentence The sentence to split up into clauses.
+ *
+ * @returns {Array} The array with all clauses that have an auxiliary.
+ */
+export default function getClauses(sentence) {
+  return getClausesSplitOnStopWords(sentence, options);
+}
+//# sourceMappingURL=getClauses.js.map

package/build/languageProcessing/languages/de/helpers/getClauses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClauses.js","names":["languageProcessing","getClausesSplitOnStopWords","createRegexFromArray","GermanClause","auxiliaries","stopwords","options","Clause","regexes","auxiliaryRegex","all","stopwordRegex","getClauses","sentence"],"sources":["../../../../../src/languageProcessing/languages/de/helpers/getClauses.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {getClausesSplitOnStopWords, createRegexFromArray} = languageProcessing;\n\nimport GermanClause from '../values/Clause';\nimport auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';\nimport stopwords from '../config/stopWords.js';\n\nconst options = {\n  Clause: GermanClause,\n  regexes: {\n    auxiliaryRegex: createRegexFromArray(auxiliaries.all),\n    stopwordRegex: createRegexFromArray(stopwords)\n  }\n};\n\n/**\n * Gets the clauses from a sentence by determining sentence breakers.\n *\n * @param {string} sentence The sentence to split up into clauses.\n *\n * @returns {Array} The array with all clauses that have an auxiliary.\n */\nexport default function getClauses(sentence) {\n  return getClausesSplitOnStopWords(sentence, options);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC,0BAA0B;EAAEC;AAAoB,CAAC,GAAGF,kBAAkB;AAE7E,OAAOG,YAAY;AACnB,OAAOC,WAAW;AAClB,OAAOC,SAAS;AAEhB,MAAMC,OAAO,GAAG;EACdC,MAAM,EAAEJ,YAAY;EACpBK,OAAO,EAAE;IACPC,cAAc,EAAEP,oBAAoB,CAACE,WAAW,CAACM,GAAG,CAAC;IACrDC,aAAa,EAAET,oBAAoB,CAACG,SAAS;EAC/C;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASO,UAAUA,CAACC,QAAQ,EAAE;EAC3C,OAAOZ,0BAA0B,CAACY,QAAQ,EAAEP,OAAO,CAAC;AACtD","ignoreList":[]}

package/build/languageProcessing/languages/de/helpers/getStemmer.js

@@ -0,0 +1,22 @@
+import { get } from 'lodash';
+import { languageProcessing } from "../../../../index.js";
+const {
+  baseStemmer
+} = languageProcessing;
+import determineStem from "./internal/determineStem";
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer(researcher) {
+  const morphologyData = get(researcher.getData('morphology'), 'de', false);
+  if (morphologyData) {
+    return word => determineStem(word, morphologyData);
+  }
+  return baseStemmer;
+}
+//# sourceMappingURL=getStemmer.js.map

package/build/languageProcessing/languages/de/helpers/getStemmer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStemmer.js","names":["get","languageProcessing","baseStemmer","determineStem","getStemmer","researcher","morphologyData","getData","word"],"sources":["../../../../../src/languageProcessing/languages/de/helpers/getStemmer.js"],"sourcesContent":["import {get} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {baseStemmer} = languageProcessing;\n\nimport determineStem from './internal/determineStem';\n\n/**\n * Returns the stemmer for a researcher.\n *\n * @param {Researcher} researcher The researcher.\n *\n * @returns {Function} The stemmer.\n */\nexport default function getStemmer(researcher) {\n  const morphologyData = get(researcher.getData('morphology'), 'de', false);\n\n  if (morphologyData) {\n    return word => determineStem(word, morphologyData);\n  }\n\n  return baseStemmer;\n}\n"],"mappings":"AAAA,SAAQA,GAAG,QAAO,QAAQ;AAC1B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC;AAAW,CAAC,GAAGD,kBAAkB;AAExC,OAAOE,aAAa;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,UAAUA,CAACC,UAAU,EAAE;EAC7C,MAAMC,cAAc,GAAGN,GAAG,CAACK,UAAU,CAACE,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;EAEzE,IAAID,cAAc,EAAE;IAClB,OAAOE,IAAI,IAAIL,aAAa,CAACK,IAAI,EAAEF,cAAc,CAAC;EACpD;EAEA,OAAOJ,WAAW;AACpB","ignoreList":[]}

package/build/languageProcessing/languages/de/helpers/internal/SentenceTokenizer.js

@@ -0,0 +1,31 @@
+import SentenceTokenizer from "../../../../helpers/sentence/SentenceTokenizer";
+import wordBoundaries from "../../../../../config/wordBoundaries";
+
+// The beginning of a string (^) or one of the word boundaries from the wordBoundaries helper.
+const wordBoundariesForRegex = "(^|[" + wordBoundaries().map(boundary => "\\" + boundary).join("") + "])";
+const ordinalDotRegex = new RegExp(wordBoundariesForRegex + "\\d{1,3}\\.$");
+
+/**
+ * Class for tokenizing a (html) text into sentences.
+ */
+export default class GermanSentenceTokenizer extends SentenceTokenizer {
+  /**
+   * Constructor
+   * @constructor
+   */
+  constructor() {
+    super();
+  }
+
+  /**
+   * Checks whether a fullstop is an ordinal dot instead of a sentence splitter.
+   * See: https://en.wikipedia.org/wiki/Ordinal_indicator#Ordinal_dot
+   *
+   * @param {string} currentSentence A string ending with a full stop.
+   * @returns {boolean} Returns true if the full stop is an ordinal dot, false otherwise.
+   */
+  endsWithOrdinalDot(currentSentence) {
+    return ordinalDotRegex.test(currentSentence.trim());
+  }
+}
+//# sourceMappingURL=SentenceTokenizer.js.map

package/build/languageProcessing/languages/de/helpers/internal/SentenceTokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SentenceTokenizer.js","names":["SentenceTokenizer","wordBoundaries","wordBoundariesForRegex","map","boundary","join","ordinalDotRegex","RegExp","GermanSentenceTokenizer","constructor","endsWithOrdinalDot","currentSentence","test","trim"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/internal/SentenceTokenizer.js"],"sourcesContent":["import SentenceTokenizer from \"../../../../helpers/sentence/SentenceTokenizer\";\nimport wordBoundaries from \"../../../../../config/wordBoundaries\";\n\n// The beginning of a string (^) or one of the word boundaries from the wordBoundaries helper.\nconst wordBoundariesForRegex = \"(^|[\" + wordBoundaries().map( ( boundary ) => \"\\\\\" + boundary ).join( \"\" ) + \"])\";\nconst ordinalDotRegex = new RegExp( wordBoundariesForRegex + \"\\\\d{1,3}\\\\.$\" );\n\n/**\n * Class for tokenizing a (html) text into sentences.\n */\nexport default class GermanSentenceTokenizer extends SentenceTokenizer {\n\t/**\n\t * Constructor\n\t * @constructor\n\t */\n\tconstructor() {\n\t\tsuper();\n\t}\n\n\t/**\n\t * Checks whether a fullstop is an ordinal dot instead of a sentence splitter.\n\t * See: https://en.wikipedia.org/wiki/Ordinal_indicator#Ordinal_dot\n\t *\n\t * @param {string} currentSentence A string ending with a full stop.\n\t * @returns {boolean} Returns true if the full stop is an ordinal dot, false otherwise.\n\t */\n\tendsWithOrdinalDot( currentSentence ) {\n\t\treturn ordinalDotRegex.test( currentSentence.trim() );\n\t}\n}\n\n"],"mappings":"AAAA,OAAOA,iBAAiB;AACxB,OAAOC,cAAc;;AAErB;AACA,MAAMC,sBAAsB,GAAG,MAAM,GAAGD,cAAc,CAAC,CAAC,CAACE,GAAG,CAAIC,QAAQ,IAAM,IAAI,GAAGA,QAAS,CAAC,CAACC,IAAI,CAAE,EAAG,CAAC,GAAG,IAAI;AACjH,MAAMC,eAAe,GAAG,IAAIC,MAAM,CAAEL,sBAAsB,GAAG,cAAe,CAAC;;AAE7E;AACA;AACA;AACA,eAAe,MAAMM,uBAAuB,SAASR,iBAAiB,CAAC;EACtE;AACD;AACA;AACA;EACCS,WAAWA,CAAA,EAAG;IACb,KAAK,CAAC,CAAC;EACR;;EAEA;AACD;AACA;AACA;AACA;AACA;AACA;EACCC,kBAAkBA,CAAEC,eAAe,EAAG;IACrC,OAAOL,eAAe,CAACM,IAAI,CAAED,eAAe,CAACE,IAAI,CAAC,CAAE,CAAC;EACtD;AACD","ignoreList":[]}

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

@@ -0,0 +1,112 @@
+import exceptionsParticiplesActive from "../../config/internal/exceptionsParticiplesActive";
+import exceptions from "../../config/internal/passiveVoiceRegex";
+
+/**
+ * Detects whether a word is a regular participle without a prefix and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The stem or null if no participle was matched.
+ */
+const detectAndStemParticiplesWithoutPrefixes = function (morphologyDataVerbs, word) {
+  const geStemTParticipleRegex = new RegExp("^" + morphologyDataVerbs.participleStemmingClasses[1].regex);
+  const geStemEtParticipleRegex = new RegExp("^" + morphologyDataVerbs.participleStemmingClasses[0].regex);
+
+  /*
+   * Check if it's a ge + stem ending in d/t + et participle.
+   * As this is the more specific regex, it needs to be checked before the ge + stem + t regex.
+   */
+  if (geStemEtParticipleRegex.test(word)) {
+    // Remove the two-letter prefix and the two-letter suffix.
+    return word.slice(2, word.length - 2);
+  }
+
+  // Check if it's a ge + stem + t participle.
+  if (geStemTParticipleRegex.test(word)) {
+    // Remove the two-letter prefix and the one-letter suffix.
+    return word.slice(2, word.length - 1);
+  }
+  return null;
+};
+
+/**
+ * Determines whether a given participle pattern combined with prefixes from a given class applies to a given word
+ * and if so, returns the stem.
+ *
+ * @param {string}      word        The word (not stemmed) to check.
+ * @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).
+ * @param {number}      startStem   Where to start cutting off the de-prefixed word.
+ * @param {number}      endStem     Where to end cutting off the de-prefixed word (from the end index).
+ *
+ * @returns {string|null} The stem or null if no prefixed participle was matched.
+ */
+const detectAndStemParticiplePerPrefixClass = function (word, prefixes, regexPart, startStem, endStem) {
+  for (const currentPrefix of prefixes) {
+    const participleRegex = new RegExp("^" + currentPrefix + regexPart);
+    if (participleRegex.test(word)) {
+      const wordWithoutPrefix = word.slice(currentPrefix.length - word.length);
+      const wordWithoutParticipleAffixes = wordWithoutPrefix.slice(startStem, wordWithoutPrefix.length - endStem);
+      return currentPrefix + wordWithoutParticipleAffixes;
+    }
+  }
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle with a prefix and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @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 (morphologyDataVerbs, word) {
+  const prefixesSeparableOrInseparable = morphologyDataVerbs.prefixes.separableOrInseparable;
+
+  /*
+   * It's important to preserve order here, since the ge + stem ending in d/t + et regex is more specific than
+   * the ge + stem + t regex, and therefore must be checked first.
+   */
+  for (const participleClass of morphologyDataVerbs.participleStemmingClasses) {
+    const regex = participleClass.regex;
+    const startStem = participleClass.startStem;
+    const endStem = participleClass.endStem;
+    const separable = participleClass.separable;
+    const prefixes = separable ? morphologyDataVerbs.prefixes.separable : morphologyDataVerbs.prefixes.inseparable;
+    let stem = detectAndStemParticiplePerPrefixClass(word, prefixes, regex, startStem, endStem);
+    if (stem) {
+      return stem;
+    }
+    stem = detectAndStemParticiplePerPrefixClass(word, prefixesSeparableOrInseparable, regex, startStem, endStem);
+    if (stem) {
+      return stem;
+    }
+  }
+  return null;
+};
+
+/**
+ * Detects whether a word is a regular participle and if so, returns the stem.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  word                The word (not stemmed) to check.
+ *
+ * @returns {string|null} The participle stem or null if no regular participle was matched.
+ */
+export function detectAndStemRegularParticiple(morphologyDataVerbs, word) {
+  if (exceptions(word).length > 0 || exceptionsParticiplesActive.includes(word)) {
+    return "";
+  }
+  let stem = detectAndStemParticiplesWithoutPrefixes(morphologyDataVerbs, word);
+  if (stem) {
+    return stem;
+  }
+  stem = detectAndStemParticiplesWithPrefixes(morphologyDataVerbs, word);
+  if (stem) {
+    return stem;
+  }
+  return null;
+}
+//# sourceMappingURL=detectAndStemRegularParticiple.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detectAndStemRegularParticiple.js","names":["exceptionsParticiplesActive","exceptions","detectAndStemParticiplesWithoutPrefixes","morphologyDataVerbs","word","geStemTParticipleRegex","RegExp","participleStemmingClasses","regex","geStemEtParticipleRegex","test","slice","length","detectAndStemParticiplePerPrefixClass","prefixes","regexPart","startStem","endStem","currentPrefix","participleRegex","wordWithoutPrefix","wordWithoutParticipleAffixes","detectAndStemParticiplesWithPrefixes","prefixesSeparableOrInseparable","separableOrInseparable","participleClass","separable","inseparable","stem","detectAndStemRegularParticiple","includes"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/internal/detectAndStemRegularParticiple.js"],"sourcesContent":["import exceptionsParticiplesActive from \"../../config/internal/exceptionsParticiplesActive\";\nimport exceptions from \"../../config/internal/passiveVoiceRegex\";\n\n/**\n * Detects whether a word is a regular participle without a prefix and if so, returns the stem.\n *\n * @param {Object}  morphologyDataVerbs The German morphology data for verbs.\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( morphologyDataVerbs, word ) {\n\tconst geStemTParticipleRegex = new RegExp( \"^\" + morphologyDataVerbs.participleStemmingClasses[ 1 ].regex );\n\tconst geStemEtParticipleRegex = new RegExp( \"^\" + morphologyDataVerbs.participleStemmingClasses[ 0 ].regex );\n\n\t/*\n\t * Check if it's a ge + stem ending in d/t + et participle.\n\t * As this is the more specific regex, it needs to be checked before the ge + stem + t regex.\n\t */\n\tif ( geStemEtParticipleRegex.test( word ) ) {\n\t\t// Remove the two-letter prefix and the two-letter suffix.\n\t\treturn ( word.slice( 2, word.length - 2 ) );\n\t}\n\n\t// Check if it's a ge + stem + t participle.\n\tif ( geStemTParticipleRegex.test( word ) ) {\n\t\t// Remove the two-letter prefix and the one-letter suffix.\n\t\treturn ( word.slice( 2, word.length - 1 ) );\n\t}\n\n\treturn null;\n};\n\n/**\n * Determines whether a given participle pattern combined with prefixes from a given class applies to a given word\n * and if so, returns the stem.\n *\n * @param {string}      word        The word (not stemmed) to check.\n * @param {string[]}    prefixes    The prefixes of a certain prefix class.\n * @param {string}      regexPart   The regex part for a given class (completed to a full regex within the function).\n * @param {number}      startStem   Where to start cutting off the de-prefixed word.\n * @param {number}      endStem     Where to end cutting off the de-prefixed word (from the end index).\n *\n * @returns {string|null} The stem or null if no prefixed participle was matched.\n */\nconst detectAndStemParticiplePerPrefixClass = function( word, prefixes, regexPart, startStem, endStem ) {\n\tfor ( const currentPrefix of prefixes ) {\n\t\tconst participleRegex = new RegExp( \"^\" + currentPrefix + regexPart );\n\n\t\tif ( participleRegex.test( word ) ) {\n\t\t\tconst wordWithoutPrefix = word.slice( currentPrefix.length - word.length );\n\t\t\tconst wordWithoutParticipleAffixes = wordWithoutPrefix.slice( startStem, wordWithoutPrefix.length - endStem );\n\n\t\t\treturn ( currentPrefix + wordWithoutParticipleAffixes );\n\t\t}\n\t}\n\n\treturn null;\n};\n\n/**\n * Detects whether a word is a regular participle with a prefix and if so, returns the stem.\n *\n * @param {Object}  morphologyDataVerbs The German morphology data for verbs.\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( morphologyDataVerbs, word ) {\n\tconst prefixesSeparableOrInseparable = morphologyDataVerbs.prefixes.separableOrInseparable;\n\n\t/*\n\t * It's important to preserve order here, since the ge + stem ending in d/t + et regex is more specific than\n\t * the ge + stem + t regex, and therefore must be checked first.\n\t */\n\tfor ( const participleClass of morphologyDataVerbs.participleStemmingClasses ) {\n\t\tconst regex = participleClass.regex;\n\t\tconst startStem = participleClass.startStem;\n\t\tconst endStem = participleClass.endStem;\n\t\tconst separable = participleClass.separable;\n\n\t\tconst prefixes = separable\n\t\t\t? morphologyDataVerbs.prefixes.separable\n\t\t\t: morphologyDataVerbs.prefixes.inseparable;\n\n\t\tlet stem = detectAndStemParticiplePerPrefixClass( word, prefixes, regex, startStem, endStem );\n\n\t\tif ( stem ) {\n\t\t\treturn stem;\n\t\t}\n\n\t\tstem = detectAndStemParticiplePerPrefixClass( word, prefixesSeparableOrInseparable, regex, startStem, endStem );\n\n\t\tif ( stem ) {\n\t\t\treturn stem;\n\t\t}\n\t}\n\n\treturn null;\n};\n\n/**\n * Detects whether a word is a regular participle and if so, returns the stem.\n *\n * @param {Object}  morphologyDataVerbs The German morphology data for verbs.\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( morphologyDataVerbs, word ) {\n\tif ( exceptions( word ).length > 0 || exceptionsParticiplesActive.includes( word ) ) {\n\t\treturn \"\";\n\t}\n\n\tlet stem = detectAndStemParticiplesWithoutPrefixes( morphologyDataVerbs, word );\n\n\tif ( stem ) {\n\t\treturn stem;\n\t}\n\n\tstem = detectAndStemParticiplesWithPrefixes( morphologyDataVerbs, word );\n\n\tif ( stem ) {\n\t\treturn stem;\n\t}\n\n\treturn null;\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,107 @@
+import { flatten } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
+const {
+  flattenSortLength
+} = languageProcessing;
+import { detectAndStemRegularParticiple } from "./detectAndStemRegularParticiple";
+import stem from "./stem";
+
+/**
+ * Returns a stem for a word that appears on the noun exception lists.
+ *
+ * @param {Object}  morphologyDataNouns The German morphology data for nouns.
+ * @param {string}  stemmedWord         The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnNounExceptionList = function (morphologyDataNouns, stemmedWord) {
+  const exceptionStems = morphologyDataNouns.exceptionStems;
+  for (const exceptionStemSet of exceptionStems) {
+    const matchedStem = exceptionStemSet.find(exceptionStem => stemmedWord.endsWith(exceptionStem));
+    if (matchedStem) {
+      const precedingLexicalMaterial = stemmedWord.slice(0, stemmedWord.length - matchedStem.length);
+      return precedingLexicalMaterial + exceptionStemSet[0];
+    }
+  }
+  return null;
+};
+
+/**
+ * Returns a stem for a word that appears on the adjective exception lists.
+ *
+ * @param {Object}  morphologyDataAdjectives    The German morphology data for adjectives.
+ * @param {string}  stemmedWord                 The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnAdjectiveExceptionList = function (morphologyDataAdjectives, stemmedWord) {
+  const adjectiveExceptionClasses = morphologyDataAdjectives.exceptions;
+  for (const key of Object.keys(adjectiveExceptionClasses)) {
+    const exceptionStems = adjectiveExceptionClasses[key];
+    for (const exceptionStemSet of exceptionStems) {
+      if (exceptionStemSet.includes(stemmedWord)) {
+        return exceptionStemSet[0];
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * Returns a stem for a word that appears on the verb exception lists.
+ *
+ * @param {Object}  morphologyDataVerbs The German morphology data for verbs.
+ * @param {string}  stemmedWord         The stem to check.
+ *
+ * @returns {string|null} The stemmed word or null if none was found.
+ */
+const findStemOnVerbExceptionList = function (morphologyDataVerbs, stemmedWord) {
+  let wordToCheck = stemmedWord;
+  const strongAndIrregularVerbStems = morphologyDataVerbs.strongAndIrregularVerbs.stems;
+  const prefixes = flattenSortLength(morphologyDataVerbs.prefixes);
+  let matchedPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));
+  if (matchedPrefix) {
+    const wordWithoutPrefix = wordToCheck.slice(matchedPrefix.length, wordToCheck.length);
+
+    /* At least 3 characters so that e.g. "be" is not found in the stem "berg". A minimum length of 3 was chosen
+     * as a safe option, since 2-letter verb stems are highly unlikely to impossible.
+     */
+    if (wordWithoutPrefix.length > 2) {
+      wordToCheck = wordWithoutPrefix;
+    } else {
+      matchedPrefix = null;
+    }
+  }
+  for (const strongOrIrregularVerbParadigm of strongAndIrregularVerbStems) {
+    let stems = strongOrIrregularVerbParadigm.stems;
+    stems = flatten(Object.values(stems));
+    if (stems.includes(wordToCheck)) {
+      if (matchedPrefix) {
+        // The present tense stem is returned as a default stem.
+        return matchedPrefix + strongOrIrregularVerbParadigm.stems.present;
+      }
+      return strongOrIrregularVerbParadigm.stems.present;
+    }
+  }
+  return null;
+};
+
+/**
+ * Returns the stem for a given German input word.
+ *
+ * @param   {string} word                   The word to get the stem for.
+ * @param   {Object} morphologyDataGerman   The German morphology data.
+ *
+ * @returns {string} Stemmed form of the word.
+ */
+export default function determineStem(word, morphologyDataGerman) {
+  const verbData = morphologyDataGerman.verbs;
+  const stemmedWord = stem(verbData, word);
+
+  /*
+   * Goes through the stem exception functions from left to right, returns the first stem it finds.
+   * If no stem has been found, return the original, programmatically created, stem.
+   */
+  return findStemOnNounExceptionList(morphologyDataGerman.nouns, stemmedWord) || findStemOnAdjectiveExceptionList(morphologyDataGerman.adjectives, stemmedWord) || findStemOnVerbExceptionList(verbData, stemmedWord) || detectAndStemRegularParticiple(verbData, word) || stemmedWord;
+}
+//# sourceMappingURL=determineStem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"determineStem.js","names":["flatten","languageProcessing","flattenSortLength","detectAndStemRegularParticiple","stem","findStemOnNounExceptionList","morphologyDataNouns","stemmedWord","exceptionStems","exceptionStemSet","matchedStem","find","exceptionStem","endsWith","precedingLexicalMaterial","slice","length","findStemOnAdjectiveExceptionList","morphologyDataAdjectives","adjectiveExceptionClasses","exceptions","key","Object","keys","includes","findStemOnVerbExceptionList","morphologyDataVerbs","wordToCheck","strongAndIrregularVerbStems","strongAndIrregularVerbs","stems","prefixes","matchedPrefix","prefix","startsWith","wordWithoutPrefix","strongOrIrregularVerbParadigm","values","present","determineStem","word","morphologyDataGerman","verbData","verbs","nouns","adjectives"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/internal/determineStem.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {flattenSortLength} = languageProcessing;\n\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\n\nimport stem from './stem';\n\n/**\n * Returns a stem for a word that appears on the noun exception lists.\n *\n * @param {Object}  morphologyDataNouns The German morphology data for nouns.\n * @param {string}  stemmedWord         The stem to check.\n *\n * @returns {string|null} The stemmed word or null if none was found.\n */\nconst findStemOnNounExceptionList = function(morphologyDataNouns, stemmedWord) {\n  const exceptionStems = morphologyDataNouns.exceptionStems;\n\n  for (const exceptionStemSet of exceptionStems) {\n    const matchedStem = exceptionStemSet.find(exceptionStem => stemmedWord.endsWith(exceptionStem));\n\n    if (matchedStem) {\n      const precedingLexicalMaterial = stemmedWord.slice(\n        0,\n        stemmedWord.length - matchedStem.length\n      );\n\n      return precedingLexicalMaterial + exceptionStemSet[0];\n    }\n  }\n\n  return null;\n};\n\n/**\n * Returns a stem for a word that appears on the adjective exception lists.\n *\n * @param {Object}  morphologyDataAdjectives    The German morphology data for adjectives.\n * @param {string}  stemmedWord                 The stem to check.\n *\n * @returns {string|null} The stemmed word or null if none was found.\n */\nconst findStemOnAdjectiveExceptionList = function(morphologyDataAdjectives, stemmedWord) {\n  const adjectiveExceptionClasses = morphologyDataAdjectives.exceptions;\n\n  for (const key of Object.keys(adjectiveExceptionClasses)) {\n    const exceptionStems = adjectiveExceptionClasses[key];\n\n    for (const exceptionStemSet of exceptionStems) {\n      if (exceptionStemSet.includes(stemmedWord)) {\n        return exceptionStemSet[0];\n      }\n    }\n  }\n\n  return null;\n};\n\n/**\n * Returns a stem for a word that appears on the verb exception lists.\n *\n * @param {Object}  morphologyDataVerbs The German morphology data for verbs.\n * @param {string}  stemmedWord         The stem to check.\n *\n * @returns {string|null} The stemmed word or null if none was found.\n */\nconst findStemOnVerbExceptionList = function(morphologyDataVerbs, stemmedWord) {\n  let wordToCheck = stemmedWord;\n  const strongAndIrregularVerbStems = morphologyDataVerbs.strongAndIrregularVerbs.stems;\n  const prefixes = flattenSortLength(morphologyDataVerbs.prefixes);\n\n  let matchedPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));\n\n  if (matchedPrefix) {\n    const wordWithoutPrefix = wordToCheck.slice(matchedPrefix.length, wordToCheck.length);\n\n    /* At least 3 characters so that e.g. \"be\" is not found in the stem \"berg\". A minimum length of 3 was chosen\n     * as a safe option, since 2-letter verb stems are highly unlikely to impossible.\n     */\n    if (wordWithoutPrefix.length > 2) {\n      wordToCheck = wordWithoutPrefix;\n    } else {\n      matchedPrefix = null;\n    }\n  }\n\n  for (const strongOrIrregularVerbParadigm of strongAndIrregularVerbStems) {\n    let stems = strongOrIrregularVerbParadigm.stems;\n    stems = flatten(Object.values(stems));\n\n    if (stems.includes(wordToCheck)) {\n      if (matchedPrefix) {\n        // The present tense stem is returned as a default stem.\n        return matchedPrefix + strongOrIrregularVerbParadigm.stems.present;\n      }\n\n      return strongOrIrregularVerbParadigm.stems.present;\n    }\n  }\n\n  return null;\n};\n\n/**\n * Returns the stem for a given German input word.\n *\n * @param   {string} word                   The word to get the stem for.\n * @param   {Object} morphologyDataGerman   The German morphology data.\n *\n * @returns {string} Stemmed form of the word.\n */\nexport default function determineStem(word, morphologyDataGerman) {\n  const verbData = morphologyDataGerman.verbs;\n  const stemmedWord = stem(verbData, word);\n\n  /*\n   * Goes through the stem exception functions from left to right, returns the first stem it finds.\n   * If no stem has been found, return the original, programmatically created, stem.\n   */\n  return (\n    findStemOnNounExceptionList(morphologyDataGerman.nouns, stemmedWord) ||\n    findStemOnAdjectiveExceptionList(morphologyDataGerman.adjectives, stemmedWord) ||\n    findStemOnVerbExceptionList(verbData, stemmedWord) ||\n    detectAndStemRegularParticiple(verbData, word) ||\n    stemmedWord\n  );\n}\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,QAAQ;AAC9B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC;AAAiB,CAAC,GAAGD,kBAAkB;AAE9C,SAAQE,8BAA8B;AAEtC,OAAOC,IAAI;;AAEX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,2BAA2B,GAAG,SAAAA,CAASC,mBAAmB,EAAEC,WAAW,EAAE;EAC7E,MAAMC,cAAc,GAAGF,mBAAmB,CAACE,cAAc;EAEzD,KAAK,MAAMC,gBAAgB,IAAID,cAAc,EAAE;IAC7C,MAAME,WAAW,GAAGD,gBAAgB,CAACE,IAAI,CAACC,aAAa,IAAIL,WAAW,CAACM,QAAQ,CAACD,aAAa,CAAC,CAAC;IAE/F,IAAIF,WAAW,EAAE;MACf,MAAMI,wBAAwB,GAAGP,WAAW,CAACQ,KAAK,CAChD,CAAC,EACDR,WAAW,CAACS,MAAM,GAAGN,WAAW,CAACM,MACnC,CAAC;MAED,OAAOF,wBAAwB,GAAGL,gBAAgB,CAAC,CAAC,CAAC;IACvD;EACF;EAEA,OAAO,IAAI;AACb,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMQ,gCAAgC,GAAG,SAAAA,CAASC,wBAAwB,EAAEX,WAAW,EAAE;EACvF,MAAMY,yBAAyB,GAAGD,wBAAwB,CAACE,UAAU;EAErE,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACJ,yBAAyB,CAAC,EAAE;IACxD,MAAMX,cAAc,GAAGW,yBAAyB,CAACE,GAAG,CAAC;IAErD,KAAK,MAAMZ,gBAAgB,IAAID,cAAc,EAAE;MAC7C,IAAIC,gBAAgB,CAACe,QAAQ,CAACjB,WAAW,CAAC,EAAE;QAC1C,OAAOE,gBAAgB,CAAC,CAAC,CAAC;MAC5B;IACF;EACF;EAEA,OAAO,IAAI;AACb,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMgB,2BAA2B,GAAG,SAAAA,CAASC,mBAAmB,EAAEnB,WAAW,EAAE;EAC7E,IAAIoB,WAAW,GAAGpB,WAAW;EAC7B,MAAMqB,2BAA2B,GAAGF,mBAAmB,CAACG,uBAAuB,CAACC,KAAK;EACrF,MAAMC,QAAQ,GAAG7B,iBAAiB,CAACwB,mBAAmB,CAACK,QAAQ,CAAC;EAEhE,IAAIC,aAAa,GAAGD,QAAQ,CAACpB,IAAI,CAACsB,MAAM,IAAI1B,WAAW,CAAC2B,UAAU,CAACD,MAAM,CAAC,CAAC;EAE3E,IAAID,aAAa,EAAE;IACjB,MAAMG,iBAAiB,GAAGR,WAAW,CAACZ,KAAK,CAACiB,aAAa,CAAChB,MAAM,EAAEW,WAAW,CAACX,MAAM,CAAC;;IAErF;AACJ;AACA;IACI,IAAImB,iBAAiB,CAACnB,MAAM,GAAG,CAAC,EAAE;MAChCW,WAAW,GAAGQ,iBAAiB;IACjC,CAAC,MAAM;MACLH,aAAa,GAAG,IAAI;IACtB;EACF;EAEA,KAAK,MAAMI,6BAA6B,IAAIR,2BAA2B,EAAE;IACvE,IAAIE,KAAK,GAAGM,6BAA6B,CAACN,KAAK;IAC/CA,KAAK,GAAG9B,OAAO,CAACsB,MAAM,CAACe,MAAM,CAACP,KAAK,CAAC,CAAC;IAErC,IAAIA,KAAK,CAACN,QAAQ,CAACG,WAAW,CAAC,EAAE;MAC/B,IAAIK,aAAa,EAAE;QACjB;QACA,OAAOA,aAAa,GAAGI,6BAA6B,CAACN,KAAK,CAACQ,OAAO;MACpE;MAEA,OAAOF,6BAA6B,CAACN,KAAK,CAACQ,OAAO;IACpD;EACF;EAEA,OAAO,IAAI;AACb,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,aAAaA,CAACC,IAAI,EAAEC,oBAAoB,EAAE;EAChE,MAAMC,QAAQ,GAAGD,oBAAoB,CAACE,KAAK;EAC3C,MAAMpC,WAAW,GAAGH,IAAI,CAACsC,QAAQ,EAAEF,IAAI,CAAC;;EAExC;AACF;AACA;AACA;EACE,OACEnC,2BAA2B,CAACoC,oBAAoB,CAACG,KAAK,EAAErC,WAAW,CAAC,IACpEU,gCAAgC,CAACwB,oBAAoB,CAACI,UAAU,EAAEtC,WAAW,CAAC,IAC9EkB,2BAA2B,CAACiB,QAAQ,EAAEnC,WAAW,CAAC,IAClDJ,8BAA8B,CAACuC,QAAQ,EAAEF,IAAI,CAAC,IAC9CjC,WAAW;AAEf","ignoreList":[]}

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

@@ -0,0 +1,32 @@
+import { forEach } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
+const {
+  getWords
+} = languageProcessing;
+import regexFunctionFactory from "../../config/internal/passiveVoiceRegex.js";
+const regexFunction = regexFunctionFactory();
+import irregularParticiples from "../../config/internal/passiveVoiceIrregulars.js";
+const verbsBeginningWithErVerEntBeZerHerUber = regexFunction.verbsBeginningWithErVerEntBeZerHerUber;
+const verbsBeginningWithGe = regexFunction.verbsBeginningWithGe;
+const verbsWithGeInMiddle = regexFunction.verbsWithGeInMiddle;
+const verbsWithErVerEntBeZerHerUberInMiddle = regexFunction.verbsWithErVerEntBeZerHerUberInMiddle;
+const verbsEndingWithIert = regexFunction.verbsEndingWithIert;
+
+/**
+ * Creates German participles array for the participles found in a clause.
+ *
+ * @param {string} clauseText The clause to finds participles in.
+ *
+ * @returns {Array} The array with the German participles found.
+ */
+export default function (clauseText) {
+  const words = getWords(clauseText);
+  const foundParticiples = [];
+  forEach(words, function (word) {
+    if (verbsBeginningWithGe(word).length !== 0 || verbsWithGeInMiddle(word).length !== 0 || verbsBeginningWithErVerEntBeZerHerUber(word).length !== 0 || verbsWithErVerEntBeZerHerUberInMiddle(word).length !== 0 || verbsEndingWithIert(word).length !== 0 || irregularParticiples.includes(word)) {
+      foundParticiples.push(word);
+    }
+  });
+  return foundParticiples;
+}
+//# sourceMappingURL=getParticiples.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getParticiples.js","names":["forEach","languageProcessing","getWords","regexFunctionFactory","regexFunction","irregularParticiples","verbsBeginningWithErVerEntBeZerHerUber","verbsBeginningWithGe","verbsWithGeInMiddle","verbsWithErVerEntBeZerHerUberInMiddle","verbsEndingWithIert","clauseText","words","foundParticiples","word","length","includes","push"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/internal/getParticiples.js"],"sourcesContent":["import {forEach} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {getWords} = languageProcessing;\n\nimport regexFunctionFactory from '../../config/internal/passiveVoiceRegex.js';\nconst regexFunction = regexFunctionFactory();\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars.js';\n\nconst verbsBeginningWithErVerEntBeZerHerUber = regexFunction.verbsBeginningWithErVerEntBeZerHerUber;\nconst verbsBeginningWithGe = regexFunction.verbsBeginningWithGe;\nconst verbsWithGeInMiddle = regexFunction.verbsWithGeInMiddle;\nconst verbsWithErVerEntBeZerHerUberInMiddle = regexFunction.verbsWithErVerEntBeZerHerUberInMiddle;\nconst verbsEndingWithIert = regexFunction.verbsEndingWithIert;\n\n/**\n * Creates German participles array for the participles found in a clause.\n *\n * @param {string} clauseText The clause to finds participles in.\n *\n * @returns {Array} The array with the German participles found.\n */\nexport default function(clauseText) {\n  const words = getWords(clauseText);\n\n  const foundParticiples = [];\n\n  forEach(words, function(word) {\n    if (\n      verbsBeginningWithGe(word).length !== 0 ||\n      verbsWithGeInMiddle(word).length !== 0 ||\n      verbsBeginningWithErVerEntBeZerHerUber(word).length !== 0 ||\n      verbsWithErVerEntBeZerHerUberInMiddle(word).length !== 0 ||\n      verbsEndingWithIert(word).length !== 0 ||\n      irregularParticiples.includes(word)\n    ) {\n      foundParticiples.push(word);\n    }\n  });\n  return foundParticiples;\n}\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,QAAQ;AAC9B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC;AAAQ,CAAC,GAAGD,kBAAkB;AAErC,OAAOE,oBAAoB;AAC3B,MAAMC,aAAa,GAAGD,oBAAoB,CAAC,CAAC;AAC5C,OAAOE,oBAAoB;AAE3B,MAAMC,sCAAsC,GAAGF,aAAa,CAACE,sCAAsC;AACnG,MAAMC,oBAAoB,GAAGH,aAAa,CAACG,oBAAoB;AAC/D,MAAMC,mBAAmB,GAAGJ,aAAa,CAACI,mBAAmB;AAC7D,MAAMC,qCAAqC,GAAGL,aAAa,CAACK,qCAAqC;AACjG,MAAMC,mBAAmB,GAAGN,aAAa,CAACM,mBAAmB;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAASC,UAAU,EAAE;EAClC,MAAMC,KAAK,GAAGV,QAAQ,CAACS,UAAU,CAAC;EAElC,MAAME,gBAAgB,GAAG,EAAE;EAE3Bb,OAAO,CAACY,KAAK,EAAE,UAASE,IAAI,EAAE;IAC5B,IACEP,oBAAoB,CAACO,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACvCP,mBAAmB,CAACM,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACtCT,sCAAsC,CAACQ,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACzDN,qCAAqC,CAACK,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACxDL,mBAAmB,CAACI,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACtCV,oBAAoB,CAACW,QAAQ,CAACF,IAAI,CAAC,EACnC;MACAD,gBAAgB,CAACI,IAAI,CAACH,IAAI,CAAC;IAC7B;EACF,CAAC,CAAC;EACF,OAAOD,gBAAgB;AACzB","ignoreList":[]}

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

@@ -0,0 +1,216 @@
+/**
+ * @file German stemming algorithm. Adapted from:
+ * @author: Joder Illi
+ * @copyright (c) 2010, FormBlitz AG
+ * All rights reserved.
+ * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/german/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 first vowel and 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;
+};
+
+/**
+ * Search for the longest among the following suffixes,
+ * (a) em   ern   er
+ * (b) e   en   es
+ * (c) s (preceded by a valid s-ending)
+ * Define a valid s-ending as one of b, d, f, g, h, k, l, m, n, r or t.
+ *
+ * @param {string} word The word to check for the suffix.
+ * @returns {{index1: number, optionUsed1: string}} The index of the suffix and the kind of suffix used.
+ */
+const findSuffixStep1 = function (word) {
+  const a1Index = word.search(/(em|ern|er)$/g);
+  const b1Index = word.search(/(e|en|es)$/g);
+  let c1Index = word.search(/([bdfghklmnrt]s)$/g);
+  // Exclude the s-ending before the s.
+  if (c1Index !== -1) {
+    c1Index++;
+  }
+  let optionUsed1 = "";
+  let index1 = 10000;
+  if (a1Index !== -1) {
+    optionUsed1 = "a";
+    index1 = a1Index;
+    return {
+      index1,
+      optionUsed1
+    };
+  } else if (b1Index !== -1) {
+    optionUsed1 = "b";
+    index1 = b1Index;
+    return {
+      index1,
+      optionUsed1
+    };
+  } else if (c1Index !== -1) {
+    optionUsed1 = "c";
+    index1 = c1Index;
+    return {
+      index1,
+      optionUsed1
+    };
+  }
+  return {
+    index1,
+    optionUsed1
+  };
+};
+
+/**
+ * Search for the longest among the following suffixes,
+ * (a) en   er   est
+ * (b) st (preceded by a valid st-ending, itself preceded by at least 3 letters)
+ * Define a valid st-ending as one of b, d, f, g, h, k, l, m, n or t.
+ *
+ * @param {string} word The word to check for the suffix.
+ * @returns {number} The index of the suffix.
+ */
+const findSuffixStep2 = function (word) {
+  const a2Index = word.search(/(en|er|est)$/g);
+  let b2Index = word.search(/(.{3}[bdfghklmnt]st)$/g);
+  // Exclude the st-ending and the preceding 3 letters.
+  if (b2Index !== -1) {
+    b2Index += 4;
+  }
+  let index2 = 10000;
+  if (a2Index !== -1) {
+    index2 = a2Index;
+  } else if (b2Index !== -1) {
+    index2 = b2Index;
+  }
+  return index2;
+};
+
+/**
+ * Delete the suffix found in step 1 if in R1. (The letter of the valid s-ending is not necessarily in R1.)
+ * If an ending of group (b) is deleted, and the ending is preceded by niss, delete the final s.
+ * (For example, äckern -> äck, ackers -> acker, armes -> arm, bedürfnissen -> bedürfnis).
+ *
+ * @param {string} word         The word for which to delete the suffix.
+ * @param {number} index1       The index of the suffix found in step 1.
+ * @param {string} optionUsed1  The type of the suffix found in step 1.
+ * @param {number} r1Index      The R1 index.
+ *
+ * @returns {string} The word with the deleted suffix.
+ */
+const deleteSuffix1 = function (word, index1, optionUsed1, r1Index) {
+  if (index1 !== 10000 && r1Index !== -1) {
+    if (index1 >= r1Index) {
+      word = word.substring(0, index1);
+      if (optionUsed1 === "b") {
+        if (word.search(/niss$/) !== -1) {
+          word = word.substring(0, word.length - 1);
+        }
+      }
+    }
+  }
+  return word;
+};
+
+/**
+ * Delete the suffix found in step 2 if in R1.
+ * (For example, derbsten -> derbst by step 1, and derbst -> derb by step 2,
+ * since b is a valid st-ending, and is preceded by just 3 letters).
+ *
+ * @param {string} word     The word for which to delete the suffix.
+ * @param {number} index2   The index of the suffix found in step 2.
+ * @param {number} r1Index  The R1 index.
+ *
+ * @returns {string} The word with the deleted suffix.
+ */
+const deleteSuffix2 = function (word, index2, r1Index) {
+  if (index2 !== 10000 && r1Index !== -1) {
+    if (index2 >= r1Index) {
+      word = word.substring(0, index2);
+    }
+  }
+  return word;
+};
+
+/**
+ * Stems irregular verbs.
+ *
+ * @param {Object} morphologyDataVerbs  The German morphology data for verbs.
+ * @param {string} word                 The word to stem.
+ *
+ * @returns {string} The stemmed word.
+ */
+const stemIrregularVerbs = function (morphologyDataVerbs, word) {
+  const irregularVerbs = morphologyDataVerbs.veryIrregularVerbs;
+  const matchedParadigm = irregularVerbs.find(paradigm => {
+    const forms = paradigm.forms;
+    return forms.includes(word);
+  });
+  if (matchedParadigm) {
+    return matchedParadigm.stem;
+  }
+  return null;
+};
+
+/**
+ * Stems German words.
+ *
+ * @param {Object} morphologyDataVerbs  The German morphology data for verbs.
+ * @param {string} word                 The word to stem.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function stem(morphologyDataVerbs, word) {
+  // Check if word is a very irregular verb, and if so, return its stem.
+  const veryIrregularVerbStem = stemIrregularVerbs(morphologyDataVerbs, word);
+  if (veryIrregularVerbStem) {
+    return veryIrregularVerbStem;
+  }
+
+  // Put u and y between vowels into upper case.
+  word = word.replace(/([aeiouyäöü])u([aeiouyäöü])/g, "$1U$2");
+  word = word.replace(/([aeiouyäöü])y([aeiouyäöü])/g, "$1Y$2");
+  word = word.replace(/([aeiouyäöü])i([aeiouyäöü])/g, "$1I$2");
+  word = word.replace(/([aeiouyäöü])e([aeiouyäöü])/g, "$1E$2");
+
+  // Find the start index of the R1 region.
+  const r1Index = determineR1(word);
+
+  // Find suffixes as defined in step 1.
+  const index1 = findSuffixStep1(word).index1;
+  const optionUsed1 = findSuffixStep1(word).optionUsed1;
+
+  // Delete the suffix found in step 1.
+  word = deleteSuffix1(word, index1, optionUsed1, r1Index);
+
+  // Find suffixes as defined in step 2.
+  const index2 = findSuffixStep2(word);
+
+  // Delete the suffix found in step 2.
+  word = deleteSuffix2(word, index2, r1Index);
+
+  // Turn U and Y back into lower case.
+  word = word.replace(/U/g, "u");
+  word = word.replace(/Y/g, "y");
+  word = word.replace(/I/g, "i");
+  word = word.replace(/E/g, "e");
+  return word;
+}
+//# sourceMappingURL=stem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stem.js","names":["determineR1","word","r1Index","search","findSuffixStep1","a1Index","b1Index","c1Index","optionUsed1","index1","findSuffixStep2","a2Index","b2Index","index2","deleteSuffix1","substring","length","deleteSuffix2","stemIrregularVerbs","morphologyDataVerbs","irregularVerbs","veryIrregularVerbs","matchedParadigm","find","paradigm","forms","includes","stem","veryIrregularVerbStem","replace"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/internal/stem.js"],"sourcesContent":["/**\n * @file German stemming algorithm. Adapted from:\n * @author: Joder Illi\n * @copyright (c) 2010, FormBlitz AG\n * All rights reserved.\n * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/german/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/**\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 first vowel and 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 * Search for the longest among the following suffixes,\n * (a) em   ern   er\n * (b) e   en   es\n * (c) s (preceded by a valid s-ending)\n * Define a valid s-ending as one of b, d, f, g, h, k, l, m, n, r or t.\n *\n * @param {string} word The word to check for the suffix.\n * @returns {{index1: number, optionUsed1: string}} The index of the suffix and the kind of suffix used.\n */\nconst findSuffixStep1 = function( word ) {\n\tconst a1Index = word.search( /(em|ern|er)$/g );\n\tconst b1Index = word.search( /(e|en|es)$/g );\n\tlet c1Index = word.search( /([bdfghklmnrt]s)$/g );\n\t// Exclude the s-ending before the s.\n\tif ( c1Index !== -1 ) {\n\t\tc1Index++;\n\t}\n\tlet optionUsed1 = \"\";\n\tlet index1 = 10000;\n\tif ( a1Index !== -1 ) {\n\t\toptionUsed1 = \"a\";\n\t\tindex1 = a1Index;\n\n\t\treturn { index1, optionUsed1 };\n\t} else if ( b1Index !== -1 ) {\n\t\toptionUsed1 = \"b\";\n\t\tindex1 = b1Index;\n\n\t\treturn { index1, optionUsed1 };\n\t} else if ( c1Index !== -1 ) {\n\t\toptionUsed1 = \"c\";\n\t\tindex1 = c1Index;\n\n\t\treturn { index1, optionUsed1 };\n\t}\n\n\treturn { index1, optionUsed1 };\n};\n\n/**\n * Search for the longest among the following suffixes,\n * (a) en   er   est\n * (b) st (preceded by a valid st-ending, itself preceded by at least 3 letters)\n * Define a valid st-ending as one of b, d, f, g, h, k, l, m, n or t.\n *\n * @param {string} word The word to check for the suffix.\n * @returns {number} The index of the suffix.\n */\nconst findSuffixStep2 = function( word ) {\n\tconst a2Index = word.search( /(en|er|est)$/g );\n\tlet b2Index = word.search( /(.{3}[bdfghklmnt]st)$/g );\n\t// Exclude the st-ending and the preceding 3 letters.\n\tif ( b2Index !== -1 ) {\n\t\tb2Index += 4;\n\t}\n\tlet index2 = 10000;\n\tif ( a2Index !== -1 ) {\n\t\tindex2 = a2Index;\n\t} else if ( b2Index !== -1  ) {\n\t\tindex2 = b2Index;\n\t}\n\n\treturn index2;\n};\n\n/**\n * Delete the suffix found in step 1 if in R1. (The letter of the valid s-ending is not necessarily in R1.)\n * If an ending of group (b) is deleted, and the ending is preceded by niss, delete the final s.\n * (For example, äckern -> äck, ackers -> acker, armes -> arm, bedürfnissen -> bedürfnis).\n *\n * @param {string} word         The word for which to delete the suffix.\n * @param {number} index1       The index of the suffix found in step 1.\n * @param {string} optionUsed1  The type of the suffix found in step 1.\n * @param {number} r1Index      The R1 index.\n *\n * @returns {string} The word with the deleted suffix.\n */\nconst deleteSuffix1 = function( word, index1, optionUsed1, r1Index ) {\n\tif ( index1 !== 10000 && r1Index !== -1 ) {\n\t\tif ( index1 >= r1Index ) {\n\t\t\tword = word.substring( 0, index1 );\n\t\t\tif ( optionUsed1 === \"b\" ) {\n\t\t\t\tif ( word.search( /niss$/ ) !== -1 ) {\n\t\t\t\t\tword = word.substring( 0, word.length - 1 );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn word;\n};\n\n/**\n * Delete the suffix found in step 2 if in R1.\n * (For example, derbsten -> derbst by step 1, and derbst -> derb by step 2,\n * since b is a valid st-ending, and is preceded by just 3 letters).\n *\n * @param {string} word     The word for which to delete the suffix.\n * @param {number} index2   The index of the suffix found in step 2.\n * @param {number} r1Index  The R1 index.\n *\n * @returns {string} The word with the deleted suffix.\n */\nconst deleteSuffix2 = function( word, index2, r1Index ) {\n\tif ( index2 !== 10000 && r1Index !== -1 ) {\n\t\tif ( index2 >= r1Index ) {\n\t\t\tword = word.substring( 0, index2 );\n\t\t}\n\t}\n\treturn word;\n};\n\n\n/**\n * Stems irregular verbs.\n *\n * @param {Object} morphologyDataVerbs  The German morphology data for verbs.\n * @param {string} word                 The word to stem.\n *\n * @returns {string} The stemmed word.\n */\nconst stemIrregularVerbs = function( morphologyDataVerbs, word ) {\n\tconst irregularVerbs = morphologyDataVerbs.veryIrregularVerbs;\n\n\tconst matchedParadigm = irregularVerbs.find( paradigm => {\n\t\tconst forms = paradigm.forms;\n\t\treturn forms.includes( word );\n\t} );\n\n\tif ( matchedParadigm ) {\n\t\treturn matchedParadigm.stem;\n\t}\n\n\treturn null;\n};\n\n/**\n * Stems German words.\n *\n * @param {Object} morphologyDataVerbs  The German morphology data for verbs.\n * @param {string} word                 The word to stem.\n *\n * @returns {string} The stemmed word.\n */\nexport default function stem( morphologyDataVerbs, word ) {\n\t// Check if word is a very irregular verb, and if so, return its stem.\n\tconst veryIrregularVerbStem = stemIrregularVerbs( morphologyDataVerbs, word );\n\n\tif ( veryIrregularVerbStem ) {\n\t\treturn veryIrregularVerbStem;\n\t}\n\n\t// Put u and y between vowels into upper case.\n\tword = word.replace( /([aeiouyäöü])u([aeiouyäöü])/g, \"$1U$2\" );\n\tword = word.replace( /([aeiouyäöü])y([aeiouyäöü])/g, \"$1Y$2\" );\n\tword = word.replace( /([aeiouyäöü])i([aeiouyäöü])/g, \"$1I$2\" );\n\tword = word.replace( /([aeiouyäöü])e([aeiouyäöü])/g, \"$1E$2\" );\n\n\t// Find the start index of the R1 region.\n\tconst r1Index = determineR1( word );\n\n\t// Find suffixes as defined in step 1.\n\tconst index1 = findSuffixStep1( word ).index1;\n\tconst optionUsed1 = findSuffixStep1( word ).optionUsed1;\n\n\t// Delete the suffix found in step 1.\n\tword = deleteSuffix1( word, index1, optionUsed1, r1Index );\n\n\t// Find suffixes as defined in step 2.\n\tconst index2 = findSuffixStep2( word );\n\n\t// Delete the suffix found in step 2.\n\tword = deleteSuffix2( word, index2, r1Index );\n\n\t// Turn U and Y back into lower case.\n\tword = word.replace( /U/g, \"u\" );\n\tword = word.replace( /Y/g, \"y\" );\n\tword = word.replace( /I/g, \"i\" );\n\tword = word.replace( /E/g, \"e\" );\n\n\treturn word;\n}\n"],"mappings":"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","ignoreList":[]}