axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.21

package/src/languageProcessing/languages/de/helpers/checkIfWordIsComplex.js

@@ -1,40 +0,0 @@
-const suffixes = "(en|e|s)$";
-const suffixesRegex = new RegExp( suffixes );
-
-/**
- * Checks if a word is complex.
- * This is a helper for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
- *
- * @param {object}	config The configuration needed for assessing the word's complexity, e.g., the frequency list.
- * @param {string}	word The word to check.
- * @param {object}	premiumData The object that contains data for the assessment including the frequency list.
- *
- * @returns {boolean} Whether or not a word is complex.
- */
-export default function checkIfWordIsComplex( config, word, premiumData ) {
-	const lengthLimit = config.wordLength;
-	const frequencyList = premiumData.frequencyList.list;
-	// All words are converted to lower case before processing to avoid excluding complex words that start with a capital letter.
-	word = word.toLowerCase();
-
-	// The German word is not complex if its length is 10 characters or fewer.
-	if ( word.length <= lengthLimit ) {
-		return false;
-	}
-
-	// The word is not complex if it's in the frequency list.
-	if ( frequencyList.includes( word ) ) {
-		return false;
-	}
-
-	/*
-	* If a word is longer than 10 characters and has a plural ending in -e, -s, or -en, we remove the ending
-	* and check if the singular form can be found in the frequency list.
-	* The word is not complex if the singular form is in the list.
-	*/
-	if ( suffixesRegex.test( word ) ) {
-		word = word.replace( suffixesRegex, "" );
-		return ! frequencyList.includes( word );
-	}
-	return true;
-}

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

@@ -1,15 +0,0 @@
-import { all as functionWords } from "../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.
- */
-export default 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.includes( word );
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/languageProcessing/languages/de/helpers/memoizedSentenceTokenizer.js

@@ -1,28 +0,0 @@
-import { memoize } from "lodash";
-import SentenceTokenizer from "./internal/SentenceTokenizer";
-
-/**
- * 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();
-	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
- */
-export default memoize( getSentenceTokenizer, ( ...args ) => JSON.stringify( args ) );