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

package/src/languageProcessing/languages/en/config/regularParticiplesRegex.js

@@ -1,5 +0,0 @@
-/**
- * A Regex that recognizes regular participles. NOTE: this often coincides with simple past forms.
- * @type {RegExp}
- */
-export const regularParticiplesRegex = /\w+ed($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/ig;

package/src/languageProcessing/languages/en/config/stopWords.js

@@ -1,52 +0,0 @@
-/**
- * Returns a list with stopwords for the English passive voice assessment.
- * @type {Array} The list with stopwords.
- */
-export default [
-	"to",
-	"which",
-	"who",
-	"whom",
-	"that",
-	"whose",
-	"after",
-	"although",
-	"as",
-	"because",
-	"before",
-	"even if",
-	"even though",
-	"if",
-	"in order that",
-	"inasmuch",
-	"lest",
-	"once",
-	"provided",
-	"since",
-	"so that",
-	"than",
-	"though",
-	"till",
-	"unless",
-	"until",
-	"when",
-	"whenever",
-	"where",
-	"whereas",
-	"wherever",
-	"whether",
-	"while",
-	"why",
-	"by the time",
-	"supposing",
-	"no matter",
-	"how",
-	"what",
-	"won't",
-	"do",
-	"does",
-	"–",
-	"and",
-	"but",
-	"or",
-];

package/src/languageProcessing/languages/en/config/transitionWords.js

@@ -1,48 +0,0 @@
-/** @module config/transitionWords */
-
-export const singleWords = [ "accordingly", "additionally", "afterward", "afterwards", "albeit", "also", "although", "altogether",
-	"another", "basically", "because", "before", "besides", "but", "certainly", "chiefly", "comparatively",
-	"concurrently", "consequently", "contrarily", "conversely", "correspondingly", "despite", "doubtedly", "during",
-	"e.g.", "earlier", "emphatically", "equally", "especially", "eventually", "evidently", "explicitly", "finally",
-	"firstly", "following", "formerly", "forthwith", "fourthly", "further", "furthermore", "generally", "hence",
-	"henceforth", "however", "i.e.", "identically", "indeed", "initially", "instead", "last", "lastly", "later", "lest",
-	"likewise", "markedly", "meanwhile", "moreover", "nevertheless", "nonetheless", "nor",  "notwithstanding", "obviously",
-	"occasionally", "otherwise", "overall", "particularly", "presently", "previously", "rather", "regardless", "secondly",
-	"shortly", "significantly", "similarly", "simultaneously", "since", "so", "soon", "specifically", "still", "straightaway",
-	"subsequently", "surely", "surprisingly", "than", "then", "thereafter", "therefore", "thereupon", "thirdly", "though",
-	"thus", "till", "undeniably", "undoubtedly", "unless", "unlike", "unquestionably", "until", "when", "whenever",
-	"whereas", "while", "whether", "if", "actually", "anyway", "anyways", "anyhow", "mostly", "namely", "including", "suddenly" ];
-export const multipleWords = [ "above all", "after all", "after that", "all in all", "all of a sudden", "all things considered",
-	"analogous to", "although this may be true", "analogous to", "another key point", "as a matter of fact", "as a result",
-	"as an illustration", "as can be seen", "as has been noted", "as I have noted", "as I have said", "as I have shown",
-	"as long as", "as much as", "as opposed to", "as shown above", "as soon as", "as well as", "at any rate", "at first", "at last",
-	"at least", "at length", "at the present time", "at the same time", "at this instant", "at this point", "at this time",
-	"balanced against", "being that", "by all means", "by and large", "by comparison", "by the same token", "by the time",
-	"compared to", "be that as it may", "coupled with", "different from", "due to", "equally important", "even if",
-	"even more", "even so", "even though", "first thing to remember", "for example", "for fear that", "for instance",
-	"for one thing", "for that reason", "for the most part", "for the purpose of", "for the same reason", "for this purpose",
-	"for this reason", "from time to time", "given that", "given these points", "important to realize", "in a word", "in addition",
-	"in another case", "in any case", "in any event", "in brief", "in case", "in conclusion", "in contrast",
-	"in detail", "in due time", "in effect", "in either case", "either way", "in essence", "in fact", "in general", "in light of",
-	"in like fashion", "in like manner", "in order that", "in order to", "in other words", "in particular", "in reality",
-	"in short", "in similar fashion", "in spite of", "in sum", "in summary", "in that case", "in the event that",
-	"in the final analysis", "in the first place", "in the fourth place", "in the hope that", "in the light of",
-	"in the long run", "in the meantime", "in the same fashion", "in the same way", "in the second place",
-	"in the third place", "in this case", "in this situation", "in time", "in truth", "in view of", "inasmuch as",
-	"most compelling evidence", "most important", "must be remembered", "not only", "not to mention", "note that",
-	"now that", "of course", "on account of", "on balance", "on condition that", "on one hand", "on the condition that", "on the contrary",
-	"on the negative side", "on the other hand", "on the positive side", "on the whole", "on this occasion", "all at once",
-	"once in a while", 	"only if", "owing to", "point often overlooked", "prior to", "provided that", "seeing that",
-	"so as to", "so far", "so long as", "so that", "sooner or later", "such as", "summing up", "take the case of",
-	"that is", "that is to say", "then again", "this time", "to be sure", "to begin with", "to clarify", "to conclude",
-	"to demonstrate", "to emphasize", "to enumerate", "to explain", "to illustrate", "to list", "to point out",
-	"to put it another way", "to put it differently", "to repeat", "to rephrase it", "to say nothing of", "to sum up",
-	"to summarize", "to that end", "to the end that", "to this end", "together with", "under those circumstances", "until now",
-	"up against", "up to the present time", "vis a vis", "what's more", "what is more", "while it may be true", "while this may be true",
-	"with attention to", "with the result that", "with this in mind", "with this intention", "with this purpose in mind",
-	"without a doubt", "without delay", "without doubt", "without reservation", "according to", "no sooner", "at most", "at the most",
-	"from now on" ];
-
-export const allWords = singleWords.concat( multipleWords );
-
-export default allWords;

package/src/languageProcessing/languages/en/config/twoPartTransitionWords.js

@@ -1,7 +0,0 @@
-/** @module config/twoPartTransitionWords */
-
-/**
- * Returns an array with two-part transition words to be used by the assessments.
- * @type {Array} The array filled with two-part transition words.
- */
-export default [ [ "both", "and" ], [ "not only", "but also" ], [ "neither", "nor" ], [ "either", "or" ], [ "not", "but" ] ];

package/src/languageProcessing/languages/en/config/wordComplexity.js

@@ -1,5 +0,0 @@
-// This is a config for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
-export default {
-	wordLength: 7,
-	doesUpperCaseDecreaseComplexity: true,
-};

package/src/languageProcessing/languages/en/helpers/calculateFleschReadingScore.js

@@ -1,18 +0,0 @@
-import {helpers} from '../../../index';
-const {formatNumber} = helpers;
-
-/**
- * Returns the Flesch reading score for English.
- *
- * @param {Object} statistics The Flesch reading statistics.
- *
- * @returns {number} The Flesch reading score for English.
- */
-export default function calculateScore(statistics) {
-  const score =
-    206.835 -
-    1.015 * statistics.averageWordsPerSentence -
-    84.6 * (statistics.numberOfSyllables / statistics.numberOfWords);
-
-  return formatNumber(score);
-}

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

@@ -1,43 +0,0 @@
-import buildFormRule from "../../../helpers/morphology/buildFormRule";
-import createRulesFromArrays from "../../../helpers/morphology/createRulesFromArrays";
-
-/**
- * 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;
-
-	// Whether uppercased beginning of a word decreases its complexity.
-	const doesUpperCaseDecreaseComplexity = config.doesUpperCaseDecreaseComplexity;
-
-	// The word is not complex if it's less than or the same as the length limit, i.e. 7 characters for English.
-	if ( word.length <= lengthLimit ) {
-		return false;
-	}
-
-	// The word is not complex if it starts with a capital and thus is assumed to be a named entity.
-	if ( doesUpperCaseDecreaseComplexity && word[ 0 ].toLowerCase() !== word[ 0 ] ) {
-		return false;
-	}
-
-	// The word is not complex if it's in the frequency list.
-	if ( frequencyList.includes( word ) ) {
-		return false;
-	}
-
-	// The word is not complex if its singular form is in the frequency list.
-	if ( premiumData ) {
-		const singular = buildFormRule( word, createRulesFromArrays( premiumData.nouns.regexNoun.singularize ) );
-		return ! frequencyList.includes( singular );
-	}
-
-	return true;
-}

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

@@ -1,49 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {createRegexFromArray, getClauses} = languageProcessing;
-
-import Clause from '../values/Clause';
-import auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';
-import stopwords from '../config/stopWords.js';
-import {includes} from 'lodash';
-import stripSpaces from '../../../helpers/sanitize/stripSpaces';
-import {getIndicesByWordList as getIndicesOfList} from '../../../helpers/word/indices';
-
-const options = {
-  Clause,
-  stopwords,
-  auxiliaries: auxiliaries,
-  ingExclusions: ['king', 'cling', 'ring', 'being', 'thing', 'something', 'anything'],
-  regexes: {
-    auxiliaryRegex: createRegexFromArray(auxiliaries),
-    stopCharacterRegex: /([:,]|('ll)|('ve))(?=[ \n\r\t'"+\-»«‹›<>])/gi,
-    verbEndingInIngRegex: /\w+ing(?=$|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi
-  },
-  otherStopWordIndices: []
-};
-
-/**
- * Gets active verbs (ending in ing) to determine sentence breakers in English.
- *
- * @param {string} sentence The sentence to get the active verbs from.
- *
- * @returns {Array} The array with valid matches.
- */
-const getVerbsEndingInIngIndices = function(sentence) {
-  // Matches the sentences with words ending in ing.
-  let matches = sentence.match(options.regexes.verbEndingInIngRegex) || [];
-  // Filters out words ending in -ing that aren't verbs.
-  matches = matches.filter(match => !includes(options.ingExclusions, stripSpaces(match)));
-  return getIndicesOfList(matches, sentence);
-};
-
-/**
- * Gets the clauses from a sentence by determining sentence breakers.
- *
- * @param {string} sentence The sentence to split up in clauses.
- *
- * @returns {Array} The array with all clauses that have an auxiliary.
- */
-export default function getEnglishClauses(sentence) {
-  options.otherStopWordIndices = getVerbsEndingInIngIndices(sentence);
-  return getClauses(sentence, options);
-}

package/src/languageProcessing/languages/en/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'), 'en', false);
-
-  if (morphologyData) {
-    return word => determineStem(word, morphologyData);
-  }
-
-  return baseStemmer;
-}

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

@@ -1,178 +0,0 @@
-import {isUndefined, flatten} from 'lodash';
-import {languageProcessing} from '../../../index';
-const {buildFormRule, createRulesFromArrays} = languageProcessing;
-
-import getAdjectiveStem from './getAdjectiveStem';
-import {
-  getInfinitive,
-  checkIrregulars as getIrregularVerbParadigm,
-  endsWithIng
-} from './getVerbStem.js';
-
-/**
- * Gets the shortest of the alphabetically ordered strings from an array.
- *
- * @param {string[]} array  The array of strings.
- *
- * @returns {string|undefined}  The shortest of the alphabetically ordered strings from the input array;
- *                              undefined if the input array is empty.
- */
-export function findShortestAndAlphabeticallyFirst(array) {
-  const strings = flatten(array);
-  let result = strings.pop();
-
-  strings.forEach(str => {
-    const lengthDifference = str.length - result.length;
-    if (lengthDifference === 0) {
-      if (str.localeCompare(result) < 0) {
-        result = str;
-      }
-    } else if (lengthDifference < 0) {
-      result = str;
-    }
-  });
-
-  return result;
-}
-
-/**
- * Checks if the input word occurs in the list of exceptions and if so returns the first form of the paradigm, which is
- * always the base.
- *
- * @param {string}		word		The word for which to determine its base.
- * @param {string[]}	irregulars	An array of irregular nouns and adjectives.
- *
- * @returns {string|null} The base form of the irregular word; null if no irregular stem was found.
- */
-export function determineIrregularStem(word, irregulars) {
-  for (const paradigm of irregulars) {
-    if (paradigm.includes(word)) {
-      return paradigm[0];
-    }
-  }
-  return null;
-}
-
-/**
- * Checks if the input word occurs in the list of exception verbs and if so returns the first form
- * of the paradigm, which is always the base. Contrary to nouns and adjectives, irregular verbs can have different prefixes
- * which are not included in the list of exceptions and have to be processed separately.
- *
- * @param {string}	word            The word for which to determine its base.
- * @param {Object}	verbMorphology  Regexes and irregulars for verb morphology, False if verb rules should not be applied.
- *
- * @returns {string|null} The base form of the irregular word; null if no irregular stem was found.
- */
-export function determineIrregularVerbStem(word, verbMorphology) {
-  const paradigmIfIrregularVerb = getIrregularVerbParadigm(
-    word,
-    verbMorphology.irregularVerbs,
-    verbMorphology.regexVerb.verbPrefixes
-  );
-  if (!isUndefined(paradigmIfIrregularVerb)) {
-    return paradigmIfIrregularVerb[0];
-  }
-  return null;
-}
-
-/**
- * Gets possible stems as a regular noun, adjective and verb.
- *
- * @param {string} word              The word for which to determine its base.
- * @param {Object} morphologyData    The morphology data for the language.
- *
- * @returns {string} The shortest and the alphabetically-first of possible noun-like, verb-like and adjective-like bases.
- */
-export function determineRegularStem(word, morphologyData) {
-  // Try to singularize as a noun.
-  const regexVerb = morphologyData.verbs.regexVerb;
-  const baseIfPluralNoun = buildFormRule(
-    word,
-    createRulesFromArrays(morphologyData.nouns.regexNoun.singularize)
-  );
-  if (!isUndefined(baseIfPluralNoun)) {
-    // Bring ing-nouns to base forms ("blessings" -> "bless").
-    if (endsWithIng(baseIfPluralNoun)) {
-      return buildFormRule(baseIfPluralNoun, createRulesFromArrays(regexVerb.ingFormToInfinitive));
-    }
-    return baseIfPluralNoun;
-  }
-
-  // Check if the word ends with "ic", "ical" or "ically". Return the "ical" form for consistency.
-  const regexAdjective = morphologyData.adjectives.regexAdjective;
-  const baseIfIcally = buildFormRule(word, createRulesFromArrays(regexAdjective.icallyToBase));
-  if (!isUndefined(baseIfIcally)) {
-    return baseIfIcally;
-  }
-
-  // No more quick guesses, we have to determine a verbal infinitive and an adjectival base.
-  const possibleRegularBases = [];
-
-  // Verbal infinitive.
-  const baseIfVerb = getInfinitive(word, regexVerb).infinitive;
-
-  possibleRegularBases.push(baseIfVerb);
-
-  // Adjectival base.
-  const stopAdjectives = morphologyData.adjectives.stopAdjectives;
-  /*
-	 The following list of words are the stem of adjectives that have two syllables or more that receive -er and -est in their comparative and superlative forms, e.g 'shallow'.
-	 Please note that if the adjective ends in -y and -e, the ending is removed, e.g. 'acute' -> 'acut'.
-	 The list is not exhaustive and can be expanded if needed. Oxford dictionary was used to check if the forms indeed exist, e.g. "acuter".
-	 */
-  const multiSyllableAdjWithSuffixes = morphologyData.adjectives.multiSyllableAdjectives.list;
-
-  const baseIfAdjective = getAdjectiveStem(
-    word,
-    regexAdjective,
-    stopAdjectives,
-    multiSyllableAdjWithSuffixes
-  ).base;
-  possibleRegularBases.push(baseIfAdjective);
-
-  return findShortestAndAlphabeticallyFirst(possibleRegularBases);
-}
-
-/**
- * Returns the stem of the input word using the morphologyData (language-specific).
- *
- * @param   {string} word           The word to get the stem for.
- * @param   {Object} morphologyData The available morphology data per language (false if unavailable).
- *
- * @returns {string} Stemmed (or base) form of the word.
- */
-export function determineStem(word, morphologyData) {
-  const nounMorphology = morphologyData.nouns;
-
-  const baseIfPossessive = buildFormRule(
-    word,
-    createRulesFromArrays(nounMorphology.regexNoun.possessiveToBase)
-  );
-
-  let stem;
-  let irregular;
-
-  // Determine if this is an irregular noun, adjective or verb.
-  if (isUndefined(baseIfPossessive)) {
-    stem = word;
-    // Word can be a noun, adjective or verb.
-    irregular =
-      determineIrregularStem(word, nounMorphology.irregularNouns) ||
-      determineIrregularStem(word, morphologyData.adjectives.irregularAdjectives) ||
-      determineIrregularVerbStem(word, morphologyData.verbs);
-  } else {
-    stem = baseIfPossessive;
-    // The word is a possessive, it can only be a noun or an ing-noun;
-    irregular = determineIrregularStem(baseIfPossessive, nounMorphology.irregularNouns);
-  }
-
-  if (irregular) {
-    // Found the stem of an irregular word! Return it.
-    return irregular;
-  }
-
-  // Treat the word as a regular noun, adjective or verb.
-  return determineRegularStem(stem, morphologyData);
-}
-
-export default determineStem;

package/src/languageProcessing/languages/en/helpers/internal/getAdjectiveStem.js

@@ -1,162 +0,0 @@
-import {languageProcessing} from '../../../index';
-import {countSyllablesInWord} from '../../../../helpers/syllables/countSyllables';
-import syllables from '../../config/syllables.json';
-const {buildFormRule, createRulesFromArrays} = languageProcessing;
-
-/**
- * Further checks if the word can be a specific adjectival form.
- *
- * @param {string} word		The word to check.
- * @param {string} endsWith	The ending of the form.
- * @param {string[]} nonStemmingExceptions		The list of words ending with the form that are not this form.
- * @param {string[]} forcedStemmingExceptions	The list of words ending with the form that are not caught by the regular rules.
- *
- * @returns {boolean} Whether the word can be a specific adjectival form.
- */
-const refineAdjectiveCheck = (word, endsWith, nonStemmingExceptions, forcedStemmingExceptions) => {
-  const countSyllables = countSyllablesInWord(word, syllables);
-  /*
-   * This check is based on the regular comparative and superlative formation rules.
-   * One syllable adjectives receive -er and -est. The syllable count of the comparative/superlative form is 2.
-   * One/two syllable adjectives ending in -e receive -r and -st. The syllable count of the comparative/superlative form is 2.
-   * Two syllable adjectives ending in -y receive -ier and -iest. The syllable count of the comparative/superlative form is 3.
-   * Words ending in -er/-est that don't follow the above rules are not comparatives/superlatives, unless listed in the exception lists.
-   */
-  if (word.endsWith(endsWith)) {
-    // Words with one syllable or less can't be comparatives/superlatives.
-    if (countSyllables <= 1) {
-      return false;
-    }
-    // The suffix for adjectives ending in -y is -ier/-iest.
-    const adjectiveEndingInYSuffix = `i${endsWith}`;
-    // Checks if the word is an adjective ending in -y that can have suffixes -er/-est. For example, 'pretty'.
-    const isStemEndingInY = word.endsWith(adjectiveEndingInYSuffix);
-    // Checks if the word is an adjective longer than one syllable that can have suffixes -er/-est (e.g. 'shallow'), OR
-    // if the word is an adjective ending in -y containing more than two syllables that can have suffixes -ier/-iest (e.g. 'unlikely').
-    const isForcedStemmingException =
-      forcedStemmingExceptions.includes(word.slice(0, -adjectiveEndingInYSuffix.length)) ||
-      forcedStemmingExceptions.includes(word.slice(0, -endsWith.length));
-    // Check if the word ending in -er/-est is not a comparative/superlative (e.g. 'banner').
-    const isNonStemmingException = nonStemmingExceptions.includes(word);
-    // The maximum syllable count for a word to be a comparative/superlative is 2, unless it ends in -y, then it's 3.
-    const maxSyllables = isStemEndingInY ? 3 : 2;
-
-    if (isForcedStemmingException || (countSyllables <= maxSyllables && !isNonStemmingException)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-/**
- * Checks if the word ends with a specific form and is not in the exceptions list.
- *
- * @param {string} word		The word to check.
- * @param {string} endsWith	The ending of the form.
- * @param {string[]} nonStemmingExceptions 	The list of words ending with the form that are not this form.
- * @returns {boolean} Whether the word ends with the form and is not in the exceptions list.
- */
-const endsWithAndNoException = (word, endsWith, nonStemmingExceptions) =>
-  word.endsWith(endsWith) && !nonStemmingExceptions.includes(word);
-
-/**
- * Constructs a function that checks if the input word can be a specific adjectival form.
- *
- * @param {string}      endsWith            How the form ends.
- * @param {int}         minimumWordLength   How long the word should be to classify for this form.
- * @param {string[]}    [nonStemmingExceptions=[]]		The list of words with that ending (endsWith) which are not this form.
- * @param {string[]}	[forcedStemmingExceptions=[]]	The list of words with that ending (endsWith) which are not caught by the regular rules.
- * @param {Function}    [checkFunction=endsWithAndNoException]	An extra check to determine if the word is this form.
- *
- * @returns {Function} A function that checks if the input word can be a specific adjectival form.
- */
-const constructCanBeFunction = function(
-  endsWith,
-  minimumWordLength,
-  nonStemmingExceptions = [],
-  forcedStemmingExceptions = [],
-  checkFunction = endsWithAndNoException
-) {
-  return word => {
-    const wordLength = word.length;
-
-    if (wordLength < minimumWordLength) {
-      return false;
-    }
-    return checkFunction(word, endsWith, nonStemmingExceptions, forcedStemmingExceptions);
-  };
-};
-
-/**
- * Forms the base form from an input word.
- *
- * @param {string}   word                                  The word to build the base form for.
- * @param {Object}   regexAdjective                        The lists of regexes to apply to stem adjectives.
- * @param {Array}    regexAdjective.comparativeToBaseRegex The Array of regex-based rules to bring comparatives to base.
- * @param {Array}    regexAdjective.superlativeToBaseRegex The Array of regex-based rules to bring superlatives to base.
- * @param {Array}    regexAdjective.adverbToBaseRegex      The Array of regex-based rules to bring adverbs to base.
- * @param {Object}   stopAdjectives                        The lists of words that are not adverbs.
- * @param {string[]} stopAdjectives.erExceptions           The list of words that end with -er and are not comparatives.
- * @param {string[]} stopAdjectives.estExceptions          The list of words that end with -est and are not superlatives.
- * @param {string[]} stopAdjectives.lyExceptions           The list of words that end with -ly and are not adverbs.
- * @param {string[]} multiSyllableAdjWithSuffixes          The list of adjectives containing more than 2 syllables that can have suffixes.
- *
- * @returns {Object} The base form of the input word.
- */
-export default function(word, regexAdjective, stopAdjectives, multiSyllableAdjWithSuffixes) {
-  /*
-   * Check comparatives: Consider only words of four letters or more (otherwise, words like "per" are being treated
-   * as comparatives).
-   */
-  const canBeComparative = constructCanBeFunction(
-    'er',
-    4,
-    stopAdjectives.erExceptions,
-    multiSyllableAdjWithSuffixes,
-    refineAdjectiveCheck
-  );
-  if (canBeComparative(word)) {
-    const comparativeToBaseRegex = createRulesFromArrays(regexAdjective.comparativeToBase);
-    return {
-      base: buildFormRule(word, comparativeToBaseRegex) || word,
-      guessedForm: 'er'
-    };
-  }
-
-  /*
-   * Check superlatives: Consider only words of five letters or more (otherwise, words like "test" are being treated
-   * as superlatives).
-   */
-  const canBeSuperlative = constructCanBeFunction(
-    'est',
-    5,
-    stopAdjectives.estExceptions,
-    multiSyllableAdjWithSuffixes,
-    refineAdjectiveCheck
-  );
-  if (canBeSuperlative(word)) {
-    const superlativeToBaseRegex = createRulesFromArrays(regexAdjective.superlativeToBase);
-    return {
-      base: buildFormRule(word, superlativeToBaseRegex) || word,
-      guessedForm: 'est'
-    };
-  }
-
-  /*
-   * Check ly-adverbs: Consider only words of five letters or more (otherwise, words like "lily" are being treated
-   * as ly-adverbs).
-   */
-  const canBeLyAdverb = constructCanBeFunction('ly', 5, stopAdjectives.lyExceptions);
-  if (canBeLyAdverb(word)) {
-    const adverbToBaseRegex = createRulesFromArrays(regexAdjective.adverbToBase);
-    return {
-      base: buildFormRule(word, adverbToBaseRegex),
-      guessedForm: 'ly'
-    };
-  }
-
-  return {
-    base: word,
-    guessedForm: 'base'
-  };
-}

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

@@ -1,25 +0,0 @@
-import {forEach, includes} from 'lodash';
-import {languageProcessing} from '../../../index';
-const {matchRegularParticiples, getWords} = languageProcessing;
-
-import irregularParticiples from '../../config/internal/passiveVoiceIrregulars';
-
-/**
- * Creates participle array for the participles found in a clause.
- *
- * @param {string} clauseText The clause to find participles in
- *
- * @returns {Array} The list with participles.
- */
-export default function getParticiples(clauseText) {
-  const words = getWords(clauseText);
-  const foundParticiples = [];
-
-  forEach(words, function(word) {
-    const regex = [/\w+ed($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi];
-    if (matchRegularParticiples(word, regex).length !== 0 || includes(irregularParticiples, word)) {
-      foundParticiples.push(word);
-    }
-  });
-  return foundParticiples;
-}