axyseo 2.1.11 → 2.1.13

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

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectAndStemRegularParticiple = detectAndStemRegularParticiple;
+var _exceptionsParticiplesActive = _interopRequireDefault(require("../../config/internal/exceptionsParticiplesActive"));
+var _passiveVoiceRegex = _interopRequireDefault(require("../../config/internal/passiveVoiceRegex"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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.
+ */
+function detectAndStemRegularParticiple(morphologyDataVerbs, word) {
+  if ((0, _passiveVoiceRegex.default)(word).length > 0 || _exceptionsParticiplesActive.default.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/cjs/languageProcessing/languages/de/helpers/internal/detectAndStemRegularParticiple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectAndStemRegularParticiple.js","names":["_exceptionsParticiplesActive","_interopRequireDefault","require","_passiveVoiceRegex","e","__esModule","default","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","exceptions","exceptionsParticiplesActive","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/cjs/languageProcessing/languages/de/helpers/internal/determineStem.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = determineStem;
+var _lodash = require("lodash");
+var _index = require("../../../../../index.js");
+var _detectAndStemRegularParticiple = require("./detectAndStemRegularParticiple");
+var _stem = _interopRequireDefault(require("./stem"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  flattenSortLength
+} = _index.languageProcessing;
+/**
+ * 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 = (0, _lodash.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.
+ */
+function determineStem(word, morphologyDataGerman) {
+  const verbData = morphologyDataGerman.verbs;
+  const stemmedWord = (0, _stem.default)(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) || (0, _detectAndStemRegularParticiple.detectAndStemRegularParticiple)(verbData, word) || stemmedWord;
+}
+//# sourceMappingURL=determineStem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"determineStem.js","names":["_lodash","require","_index","_detectAndStemRegularParticiple","_stem","_interopRequireDefault","e","__esModule","default","flattenSortLength","languageProcessing","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","flatten","values","present","determineStem","word","morphologyDataGerman","verbData","verbs","stem","nouns","adjectives","detectAndStemRegularParticiple"],"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":"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","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = require("lodash");
+var _index = require("../../../../../index.js");
+var _passiveVoiceRegex = _interopRequireDefault(require("../../config/internal/passiveVoiceRegex.js"));
+var _passiveVoiceIrregulars = _interopRequireDefault(require("../../config/internal/passiveVoiceIrregulars.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  getWords
+} = _index.languageProcessing;
+const regexFunction = (0, _passiveVoiceRegex.default)();
+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.
+ */
+function _default(clauseText) {
+  const words = getWords(clauseText);
+  const foundParticiples = [];
+  (0, _lodash.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 || _passiveVoiceIrregulars.default.includes(word)) {
+      foundParticiples.push(word);
+    }
+  });
+  return foundParticiples;
+}
+//# sourceMappingURL=getParticiples.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getParticiples.js","names":["_lodash","require","_index","_passiveVoiceRegex","_interopRequireDefault","_passiveVoiceIrregulars","e","__esModule","default","getWords","languageProcessing","regexFunction","regexFunctionFactory","verbsBeginningWithErVerEntBeZerHerUber","verbsBeginningWithGe","verbsWithGeInMiddle","verbsWithErVerEntBeZerHerUberInMiddle","verbsEndingWithIert","_default","clauseText","words","foundParticiples","forEach","word","length","irregularParticiples","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,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,kBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAEA,IAAAI,uBAAA,GAAAD,sBAAA,CAAAH,OAAA;AAAmF,SAAAG,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAJnF,MAAM;EAACG;AAAQ,CAAC,GAAGC,yBAAkB;AAGrC,MAAMC,aAAa,GAAG,IAAAC,0BAAoB,EAAC,CAAC;AAG5C,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;AACe,SAAAC,SAASC,UAAU,EAAE;EAClC,MAAMC,KAAK,GAAGX,QAAQ,CAACU,UAAU,CAAC;EAElC,MAAME,gBAAgB,GAAG,EAAE;EAE3B,IAAAC,eAAO,EAACF,KAAK,EAAE,UAASG,IAAI,EAAE;IAC5B,IACET,oBAAoB,CAACS,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACvCT,mBAAmB,CAACQ,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACtCX,sCAAsC,CAACU,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACzDR,qCAAqC,CAACO,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACxDP,mBAAmB,CAACM,IAAI,CAAC,CAACC,MAAM,KAAK,CAAC,IACtCC,+BAAoB,CAACC,QAAQ,CAACH,IAAI,CAAC,EACnC;MACAF,gBAAgB,CAACM,IAAI,CAACJ,IAAI,CAAC;IAC7B;EACF,CAAC,CAAC;EACF,OAAOF,gBAAgB;AACzB","ignoreList":[]}

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

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stem;
+/**
+ * @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.
+ */
+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/cjs/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":[]}

package/build/cjs/languageProcessing/languages/de/helpers/memoizedSentenceTokenizer.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = require("lodash");
+var _SentenceTokenizer = _interopRequireDefault(require("./internal/SentenceTokenizer"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Returns the sentences from a certain text.
+ *
+ * @param {string} text 					The text to retrieve sentences from.
+ * @param {boolean} [trimSentences=true] 	Whether to trim whitespace from the beginning and end of the sentences or not.
+ *
+ * @returns {Array<string>} The list of sentences in the text.
+ */
+function getSentenceTokenizer(text, trimSentences = true) {
+  const sentenceTokenizer = new _SentenceTokenizer.default();
+  const {
+    tokenizer,
+    tokens
+  } = sentenceTokenizer.createTokenizer();
+  sentenceTokenizer.tokenize(tokenizer, text);
+  return tokens.length === 0 ? [] : sentenceTokenizer.getSentencesFromTokens(tokens, trimSentences);
+}
+
+/*
+ * The second argument to the memoize function is a so-called resolver function.
+ * It creates a cache key consisting of a combination of all arguments to a function.
+ * This is needed because by default, only the first argument to a function is used as the map cache key by the memoize function.
+ * This means that a function is only re-run if the value of the first argument changes.
+ * We want to re-run the getSentenceTokenizer function also when only the second argument changes to prevent cache collisions.
+ * @see https://lodash.com/docs/4.17.15#memoize
+ */
+var _default = exports.default = (0, _lodash.memoize)(getSentenceTokenizer, (...args) => JSON.stringify(args));
+//# sourceMappingURL=memoizedSentenceTokenizer.js.map

package/build/cjs/languageProcessing/languages/de/helpers/memoizedSentenceTokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoizedSentenceTokenizer.js","names":["_lodash","require","_SentenceTokenizer","_interopRequireDefault","e","__esModule","default","getSentenceTokenizer","text","trimSentences","sentenceTokenizer","SentenceTokenizer","tokenizer","tokens","createTokenizer","tokenize","length","getSentencesFromTokens","_default","exports","memoize","args","JSON","stringify"],"sources":["../../../../../../src/languageProcessing/languages/de/helpers/memoizedSentenceTokenizer.js"],"sourcesContent":["import { memoize } from \"lodash\";\nimport SentenceTokenizer from \"./internal/SentenceTokenizer\";\n\n/**\n * Returns the sentences from a certain text.\n *\n * @param {string} text \t\t\t\t\tThe text to retrieve sentences from.\n * @param {boolean} [trimSentences=true] \tWhether to trim whitespace from the beginning and end of the sentences or not.\n *\n * @returns {Array<string>} The list of sentences in the text.\n */\nfunction getSentenceTokenizer( text, trimSentences = true ) {\n\tconst sentenceTokenizer = new SentenceTokenizer();\n\tconst { tokenizer, tokens } = sentenceTokenizer.createTokenizer();\n\tsentenceTokenizer.tokenize( tokenizer, text );\n\n\treturn ( tokens.length === 0 ? [] : sentenceTokenizer.getSentencesFromTokens( tokens, trimSentences ) );\n}\n\n/*\n * The second argument to the memoize function is a so-called resolver function.\n * It creates a cache key consisting of a combination of all arguments to a function.\n * This is needed because by default, only the first argument to a function is used as the map cache key by the memoize function.\n * This means that a function is only re-run if the value of the first argument changes.\n * We want to re-run the getSentenceTokenizer function also when only the second argument changes to prevent cache collisions.\n * @see https://lodash.com/docs/4.17.15#memoize\n */\nexport default memoize( getSentenceTokenizer, ( ...args ) => JSON.stringify( args ) );\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA6D,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASG,oBAAoBA,CAAEC,IAAI,EAAEC,aAAa,GAAG,IAAI,EAAG;EAC3D,MAAMC,iBAAiB,GAAG,IAAIC,0BAAiB,CAAC,CAAC;EACjD,MAAM;IAAEC,SAAS;IAAEC;EAAO,CAAC,GAAGH,iBAAiB,CAACI,eAAe,CAAC,CAAC;EACjEJ,iBAAiB,CAACK,QAAQ,CAAEH,SAAS,EAAEJ,IAAK,CAAC;EAE7C,OAASK,MAAM,CAACG,MAAM,KAAK,CAAC,GAAG,EAAE,GAAGN,iBAAiB,CAACO,sBAAsB,CAAEJ,MAAM,EAAEJ,aAAc,CAAC;AACtG;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAPA,IAAAS,QAAA,GAAAC,OAAA,CAAAb,OAAA,GAQe,IAAAc,eAAO,EAAEb,oBAAoB,EAAE,CAAE,GAAGc,IAAI,KAAMC,IAAI,CAACC,SAAS,CAAEF,IAAK,CAAE,CAAC","ignoreList":[]}