axyseo 2.0.0-alpha.0.0.35 → 2.0.0-alpha.0.0.37

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

@@ -1 +0,0 @@
-{"version":3,"file":"checkIfWordIsComplex.js","names":["suffixes","suffixesRegex","RegExp","checkIfWordIsComplex","config","word","premiumData","lengthLimit","wordLength","frequencyList","list","toLowerCase","length","includes","test","replace"],"sources":["../../../../../src/languageProcessing/languages/de/helpers/checkIfWordIsComplex.js"],"sourcesContent":["const suffixes = \"(en|e|s)$\";\nconst suffixesRegex = new RegExp( suffixes );\n\n/**\n * Checks if a word is complex.\n * This is a helper for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.\n *\n * @param {object}\tconfig The configuration needed for assessing the word's complexity, e.g., the frequency list.\n * @param {string}\tword The word to check.\n * @param {object}\tpremiumData The object that contains data for the assessment including the frequency list.\n *\n * @returns {boolean} Whether or not a word is complex.\n */\nexport default function checkIfWordIsComplex( config, word, premiumData ) {\n\tconst lengthLimit = config.wordLength;\n\tconst frequencyList = premiumData.frequencyList.list;\n\t// All words are converted to lower case before processing to avoid excluding complex words that start with a capital letter.\n\tword = word.toLowerCase();\n\n\t// The German word is not complex if its length is 10 characters or fewer.\n\tif ( word.length <= lengthLimit ) {\n\t\treturn false;\n\t}\n\n\t// The word is not complex if it's in the frequency list.\n\tif ( frequencyList.includes( word ) ) {\n\t\treturn false;\n\t}\n\n\t/*\n\t* If a word is longer than 10 characters and has a plural ending in -e, -s, or -en, we remove the ending\n\t* and check if the singular form can be found in the frequency list.\n\t* The word is not complex if the singular form is in the list.\n\t*/\n\tif ( suffixesRegex.test( word ) ) {\n\t\tword = word.replace( suffixesRegex, \"\" );\n\t\treturn ! frequencyList.includes( word );\n\t}\n\treturn true;\n}\n"],"mappings":";;;;;;AAAA,MAAMA,QAAQ,GAAG,WAAW;AAC5B,MAAMC,aAAa,GAAG,IAAIC,MAAM,CAAEF,QAAS,CAAC;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASG,oBAAoBA,CAAEC,MAAM,EAAEC,IAAI,EAAEC,WAAW,EAAG;EACzE,MAAMC,WAAW,GAAGH,MAAM,CAACI,UAAU;EACrC,MAAMC,aAAa,GAAGH,WAAW,CAACG,aAAa,CAACC,IAAI;EACpD;EACAL,IAAI,GAAGA,IAAI,CAACM,WAAW,CAAC,CAAC;;EAEzB;EACA,IAAKN,IAAI,CAACO,MAAM,IAAIL,WAAW,EAAG;IACjC,OAAO,KAAK;EACb;;EAEA;EACA,IAAKE,aAAa,CAACI,QAAQ,CAAER,IAAK,CAAC,EAAG;IACrC,OAAO,KAAK;EACb;;EAEA;AACD;AACA;AACA;AACA;EACC,IAAKJ,aAAa,CAACa,IAAI,CAAET,IAAK,CAAC,EAAG;IACjCA,IAAI,GAAGA,IAAI,CAACU,OAAO,CAAEd,aAAa,EAAE,EAAG,CAAC;IACxC,OAAO,CAAEQ,aAAa,CAACI,QAAQ,CAAER,IAAK,CAAC;EACxC;EACA,OAAO,IAAI;AACZ","ignoreList":[]}

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

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = checkIfWordIsFunction;
-var _functionWords = require("../config/functionWords");
-/**
- * Checks if a word is a function word.
- *
- * @param {string} word The word to check.
- *
- * @returns {boolean} Whether or not a word is a function word.
- */
-function checkIfWordIsFunction(word) {
-  // All words are converted to lower case before processing to avoid excluding function words that start with a capital letter.
-  word = word.toLowerCase();
-  return _functionWords.all.includes(word);
-}
-//# sourceMappingURL=checkIfWordIsFunction.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"checkIfWordIsFunction.js","names":["_functionWords","require","checkIfWordIsFunction","word","toLowerCase","functionWords","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,IAAAA,cAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,qBAAqBA,CAAEC,IAAI,EAAG;EACrD;EACAA,IAAI,GAAGA,IAAI,CAACC,WAAW,CAAC,CAAC;EAEzB,OAAOC,kBAAa,CAACC,QAAQ,CAAEH,IAAK,CAAC;AACtC","ignoreList":[]}

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

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getClauses;
-var _index = require("../../../../index.js");
-var _Clause = _interopRequireDefault(require("../values/Clause"));
-var _passiveVoiceAuxiliaries = _interopRequireDefault(require("../config/internal/passiveVoiceAuxiliaries.js"));
-var _stopWords = _interopRequireDefault(require("../config/stopWords.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  getClausesSplitOnStopWords,
-  createRegexFromArray
-} = _index.languageProcessing;
-const options = {
-  Clause: _Clause.default,
-  regexes: {
-    auxiliaryRegex: createRegexFromArray(_passiveVoiceAuxiliaries.default.all),
-    stopwordRegex: createRegexFromArray(_stopWords.default)
-  }
-};
-
-/**
- * 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.
- */
-function getClauses(sentence) {
-  return getClausesSplitOnStopWords(sentence, options);
-}
-//# sourceMappingURL=getClauses.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getClauses.js","names":["_index","require","_Clause","_interopRequireDefault","_passiveVoiceAuxiliaries","_stopWords","e","__esModule","default","getClausesSplitOnStopWords","createRegexFromArray","languageProcessing","options","Clause","GermanClause","regexes","auxiliaryRegex","auxiliaries","all","stopwordRegex","stopwords","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,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,wBAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,UAAA,GAAAF,sBAAA,CAAAF,OAAA;AAA+C,SAAAE,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAJ/C,MAAM;EAACG,0BAA0B;EAAEC;AAAoB,CAAC,GAAGC,yBAAkB;AAM7E,MAAMC,OAAO,GAAG;EACdC,MAAM,EAAEC,eAAY;EACpBC,OAAO,EAAE;IACPC,cAAc,EAAEN,oBAAoB,CAACO,gCAAW,CAACC,GAAG,CAAC;IACrDC,aAAa,EAAET,oBAAoB,CAACU,kBAAS;EAC/C;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,UAAUA,CAACC,QAAQ,EAAE;EAC3C,OAAOb,0BAA0B,CAACa,QAAQ,EAAEV,OAAO,CAAC;AACtD","ignoreList":[]}

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

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getStemmer;
-var _lodash = require("lodash");
-var _index = require("../../../../index.js");
-var _determineStem = _interopRequireDefault(require("./internal/determineStem"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  baseStemmer
-} = _index.languageProcessing;
-/**
- * Returns the stemmer for a researcher.
- *
- * @param {Researcher} researcher The researcher.
- *
- * @returns {Function} The stemmer.
- */
-function getStemmer(researcher) {
-  const morphologyData = (0, _lodash.get)(researcher.getData('morphology'), 'de', false);
-  if (morphologyData) {
-    return word => (0, _determineStem.default)(word, morphologyData);
-  }
-  return baseStemmer;
-}
-//# sourceMappingURL=getStemmer.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getStemmer.js","names":["_lodash","require","_index","_determineStem","_interopRequireDefault","e","__esModule","default","baseStemmer","languageProcessing","getStemmer","researcher","morphologyData","get","getData","word","determineStem"],"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,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,cAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAqD,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAFrD,MAAM;EAACG;AAAW,CAAC,GAAGC,yBAAkB;AAIxC;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,UAAUA,CAACC,UAAU,EAAE;EAC7C,MAAMC,cAAc,GAAG,IAAAC,WAAG,EAACF,UAAU,CAACG,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;EAEzE,IAAIF,cAAc,EAAE;IAClB,OAAOG,IAAI,IAAI,IAAAC,sBAAa,EAACD,IAAI,EAAEH,cAAc,CAAC;EACpD;EAEA,OAAOJ,WAAW;AACpB","ignoreList":[]}

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

@@ -1,38 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _SentenceTokenizer = _interopRequireDefault(require("../../../../helpers/sentence/SentenceTokenizer"));
-var _wordBoundaries = _interopRequireDefault(require("../../../../../config/wordBoundaries"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// The beginning of a string (^) or one of the word boundaries from the wordBoundaries helper.
-const wordBoundariesForRegex = "(^|[" + (0, _wordBoundaries.default)().map(boundary => "\\" + boundary).join("") + "])";
-const ordinalDotRegex = new RegExp(wordBoundariesForRegex + "\\d{1,3}\\.$");
-
-/**
- * Class for tokenizing a (html) text into sentences.
- */
-class GermanSentenceTokenizer extends _SentenceTokenizer.default {
-  /**
-   * 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());
-  }
-}
-exports.default = GermanSentenceTokenizer;
-//# sourceMappingURL=SentenceTokenizer.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SentenceTokenizer.js","names":["_SentenceTokenizer","_interopRequireDefault","require","_wordBoundaries","e","__esModule","default","wordBoundariesForRegex","wordBoundaries","map","boundary","join","ordinalDotRegex","RegExp","GermanSentenceTokenizer","SentenceTokenizer","constructor","endsWithOrdinalDot","currentSentence","test","trim","exports"],"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,IAAAA,kBAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,eAAA,GAAAF,sBAAA,CAAAC,OAAA;AAAkE,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAElE;AACA,MAAMG,sBAAsB,GAAG,MAAM,GAAG,IAAAC,uBAAc,EAAC,CAAC,CAACC,GAAG,CAAIC,QAAQ,IAAM,IAAI,GAAGA,QAAS,CAAC,CAACC,IAAI,CAAE,EAAG,CAAC,GAAG,IAAI;AACjH,MAAMC,eAAe,GAAG,IAAIC,MAAM,CAAEN,sBAAsB,GAAG,cAAe,CAAC;;AAE7E;AACA;AACA;AACe,MAAMO,uBAAuB,SAASC,0BAAiB,CAAC;EACtE;AACD;AACA;AACA;EACCC,WAAWA,CAAA,EAAG;IACb,KAAK,CAAC,CAAC;EACR;;EAEA;AACD;AACA;AACA;AACA;AACA;AACA;EACCC,kBAAkBA,CAAEC,eAAe,EAAG;IACrC,OAAON,eAAe,CAACO,IAAI,CAAED,eAAe,CAACE,IAAI,CAAC,CAAE,CAAC;EACtD;AACD;AAACC,OAAA,CAAAf,OAAA,GAAAQ,uBAAA","ignoreList":[]}

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

@@ -1,118 +0,0 @@
-"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/languageProcessing/languages/de/helpers/internal/detectAndStemRegularParticiple.js.map

@@ -1 +0,0 @@
-{"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":";;;;;;AAAA,IAAAA,4BAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAF,sBAAA,CAAAC,OAAA;AAAiE,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,uCAAuC,GAAG,SAAAA,CAAUC,mBAAmB,EAAEC,IAAI,EAAG;EACrF,MAAMC,sBAAsB,GAAG,IAAIC,MAAM,CAAE,GAAG,GAAGH,mBAAmB,CAACI,yBAAyB,CAAE,CAAC,CAAE,CAACC,KAAM,CAAC;EAC3G,MAAMC,uBAAuB,GAAG,IAAIH,MAAM,CAAE,GAAG,GAAGH,mBAAmB,CAACI,yBAAyB,CAAE,CAAC,CAAE,CAACC,KAAM,CAAC;;EAE5G;AACD;AACA;AACA;EACC,IAAKC,uBAAuB,CAACC,IAAI,CAAEN,IAAK,CAAC,EAAG;IAC3C;IACA,OAASA,IAAI,CAACO,KAAK,CAAE,CAAC,EAAEP,IAAI,CAACQ,MAAM,GAAG,CAAE,CAAC;EAC1C;;EAEA;EACA,IAAKP,sBAAsB,CAACK,IAAI,CAAEN,IAAK,CAAC,EAAG;IAC1C;IACA,OAASA,IAAI,CAACO,KAAK,CAAE,CAAC,EAAEP,IAAI,CAACQ,MAAM,GAAG,CAAE,CAAC;EAC1C;EAEA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAAUT,IAAI,EAAEU,QAAQ,EAAEC,SAAS,EAAEC,SAAS,EAAEC,OAAO,EAAG;EACvG,KAAM,MAAMC,aAAa,IAAIJ,QAAQ,EAAG;IACvC,MAAMK,eAAe,GAAG,IAAIb,MAAM,CAAE,GAAG,GAAGY,aAAa,GAAGH,SAAU,CAAC;IAErE,IAAKI,eAAe,CAACT,IAAI,CAAEN,IAAK,CAAC,EAAG;MACnC,MAAMgB,iBAAiB,GAAGhB,IAAI,CAACO,KAAK,CAAEO,aAAa,CAACN,MAAM,GAAGR,IAAI,CAACQ,MAAO,CAAC;MAC1E,MAAMS,4BAA4B,GAAGD,iBAAiB,CAACT,KAAK,CAAEK,SAAS,EAAEI,iBAAiB,CAACR,MAAM,GAAGK,OAAQ,CAAC;MAE7G,OAASC,aAAa,GAAGG,4BAA4B;IACtD;EACD;EAEA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,oCAAoC,GAAG,SAAAA,CAAUnB,mBAAmB,EAAEC,IAAI,EAAG;EAClF,MAAMmB,8BAA8B,GAAGpB,mBAAmB,CAACW,QAAQ,CAACU,sBAAsB;;EAE1F;AACD;AACA;AACA;EACC,KAAM,MAAMC,eAAe,IAAItB,mBAAmB,CAACI,yBAAyB,EAAG;IAC9E,MAAMC,KAAK,GAAGiB,eAAe,CAACjB,KAAK;IACnC,MAAMQ,SAAS,GAAGS,eAAe,CAACT,SAAS;IAC3C,MAAMC,OAAO,GAAGQ,eAAe,CAACR,OAAO;IACvC,MAAMS,SAAS,GAAGD,eAAe,CAACC,SAAS;IAE3C,MAAMZ,QAAQ,GAAGY,SAAS,GACvBvB,mBAAmB,CAACW,QAAQ,CAACY,SAAS,GACtCvB,mBAAmB,CAACW,QAAQ,CAACa,WAAW;IAE3C,IAAIC,IAAI,GAAGf,qCAAqC,CAAET,IAAI,EAAEU,QAAQ,EAAEN,KAAK,EAAEQ,SAAS,EAAEC,OAAQ,CAAC;IAE7F,IAAKW,IAAI,EAAG;MACX,OAAOA,IAAI;IACZ;IAEAA,IAAI,GAAGf,qCAAqC,CAAET,IAAI,EAAEmB,8BAA8B,EAAEf,KAAK,EAAEQ,SAAS,EAAEC,OAAQ,CAAC;IAE/G,IAAKW,IAAI,EAAG;MACX,OAAOA,IAAI;IACZ;EACD;EAEA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,8BAA8BA,CAAE1B,mBAAmB,EAAEC,IAAI,EAAG;EAC3E,IAAK,IAAA0B,0BAAU,EAAE1B,IAAK,CAAC,CAACQ,MAAM,GAAG,CAAC,IAAImB,oCAA2B,CAACC,QAAQ,CAAE5B,IAAK,CAAC,EAAG;IACpF,OAAO,EAAE;EACV;EAEA,IAAIwB,IAAI,GAAG1B,uCAAuC,CAAEC,mBAAmB,EAAEC,IAAK,CAAC;EAE/E,IAAKwB,IAAI,EAAG;IACX,OAAOA,IAAI;EACZ;EAEAA,IAAI,GAAGN,oCAAoC,CAAEnB,mBAAmB,EAAEC,IAAK,CAAC;EAExE,IAAKwB,IAAI,EAAG;IACX,OAAOA,IAAI;EACZ;EAEA,OAAO,IAAI;AACZ","ignoreList":[]}

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

@@ -1,113 +0,0 @@
-"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/languageProcessing/languages/de/helpers/internal/determineStem.js.map

@@ -1 +0,0 @@
-{"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":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,+BAAA,GAAAF,OAAA;AAEA,IAAAG,KAAA,GAAAC,sBAAA,CAAAJ,OAAA;AAA0B,SAAAI,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAJ1B,MAAM;EAACG;AAAiB,CAAC,GAAGC,yBAAkB;AAM9C;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,GAAG5B,iBAAiB,CAACuB,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,GAAG,IAAAO,eAAO,EAACf,MAAM,CAACgB,MAAM,CAACR,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,CAACS,OAAO;MACpE;MAEA,OAAOH,6BAA6B,CAACN,KAAK,CAACS,OAAO;IACpD;EACF;EAEA,OAAO,IAAI;AACb,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,aAAaA,CAACC,IAAI,EAAEC,oBAAoB,EAAE;EAChE,MAAMC,QAAQ,GAAGD,oBAAoB,CAACE,KAAK;EAC3C,MAAMrC,WAAW,GAAG,IAAAsC,aAAI,EAACF,QAAQ,EAAEF,IAAI,CAAC;;EAExC;AACF;AACA;AACA;EACE,OACEpC,2BAA2B,CAACqC,oBAAoB,CAACI,KAAK,EAAEvC,WAAW,CAAC,IACpEU,gCAAgC,CAACyB,oBAAoB,CAACK,UAAU,EAAExC,WAAW,CAAC,IAC9EkB,2BAA2B,CAACkB,QAAQ,EAAEpC,WAAW,CAAC,IAClD,IAAAyC,8DAA8B,EAACL,QAAQ,EAAEF,IAAI,CAAC,IAC9ClC,WAAW;AAEf","ignoreList":[]}

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

@@ -1,39 +0,0 @@
-"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/languageProcessing/languages/de/helpers/internal/getParticiples.js.map

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