axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.6

package/src/languageProcessing/languages/pt/config/sentenceLength.js

@@ -1,3 +0,0 @@
-export default {
-	recommendedLength: 25,
-};

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

@@ -1,50 +0,0 @@
-/**
- * Returns a list with stopwords for the Portuguese passive voice assessment.
- * @returns {Array} The list with stopwords.
- */
-export default [
-	"que ",
-	"como",
-	"e",
-	"nem",
-	"se",
-	"caso",
-	"conforme",
-	"consoante",
-	"porque",
-	"pois",
-	"segundo ",
-	"enquanto",
-	"embora",
-	"conquanto",
-	"quanto menos",
-	"quanto mais",
-	"quando",
-	"mal ",
-	"apenas",
-	"ora",
-	"seja",
-	"quer",
-	"já",
-	"logo",
-	"portanto",
-	"por isso",
-	"pois",
-	"рог conseguinte",
-	"ou seja ",
-	"isto é",
-	"quer dizer",
-	"a saber",
-	"ou melhor",
-	"mas",
-	"também",
-	"sim",
-	"porém",
-	"contudo",
-	"senão",
-	"todavia",
-	"mas ainda",
-	"no entanto",
-	"entretanto",
-];
-

package/src/languageProcessing/languages/pt/config/syllables.json

@@ -1,38 +0,0 @@
-{
-  "vowels": "aeiouáéíóúàâêôãõü",
-  "deviations": {
-    "vowels": [
-      {
-        "fragments": [ "(gu|qu)[aeoáéíóúêã]" ],
-        "countModifier": -1
-      },
-      {
-        "fragments": [ "[^(g|q|a)][aeiou][aeo]$" ],
-        "countModifier": -1
-      },
-      {
-        "fragments": [ "[aeiouáéíóúàâêôü][aeo]", "[aeiou][íúáéóãê]" ],
-        "countModifier": 1
-      },
-      {
-        "fragments": [ "aí[ae]" ],
-        "countModifier": 1
-      }
-    ],
-    "words": {
-      "full": [
-        { "word": "delegacia", "syllables": 5 },
-        { "word": "democracia", "syllables": 5 },
-        { "word": "parceria", "syllables": 4 },
-        { "word": "secretaria", "syllables": 5 }
-      ],
-      "fragments": []
-    }
-  }
-}
-
-
-
-
-
-

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

@@ -1,34 +0,0 @@
-export const singleWords = [
-	"ademais", "afinal", "aliás", "analogamente", "anteriormente", "assim", "atualmente", "certamente", "conforme",
-	"conquanto", "contudo", "decerto", "embora", "enfim", "enquanto", "então", "entretanto", "eventualmente",
-	"igualmente", "inegavelmente", "inesperadamente", "mas", "ocasionalmente", "outrossim", "pois", "porquanto",
-	"porque", "portanto", "posteriormente", "precipuamente", "primeiramente", "primordialmente", "principalmente",
-	"salvo", "semelhantemente", "similarmente", "sobretudo", "surpreendentemente", "todavia", "logo", "inclusive",
-];
-
-export const multipleWords = [
-	"a fim de", "a fim de que", "a menos que", "a princípio", "a saber", "acima de tudo", "ainda assim", "ainda mais",
-	"ainda que", "além disso", "antes de mais nada", "antes de tudo", "antes que", "ao mesmo tempo", "ao passo que",
-	"ao propósito", "apesar de", "apesar disso", "às vezes", "assim como", "assim que", "assim sendo", "assim também",
-	"bem como", "com a finalidade de", "com efeito", "com o fim de", "com o intuito de", "com o propósito de",
-	"com toda a certeza", "como resultado", "como se", "da mesma forma", "de acordo com", "de conformidade com",
-	"de fato", "de maneira idêntica", "de tal forma que", "de tal sorte que", "depois que", "desde que", "dessa forma",
-	"dessa maneira", "desse modo", "do mesmo modo", "é provável", "em conclusão", "em contrapartida", "em contraste com",
-	"em outras palavras", "em primeiro lugar", "em princípio", "em resumo", "em seguida", "em segundo lugar", "em síntese",
-	"em suma", "em terceiro lugar", "em virtude de", "finalmente", "isto é", "já que", "juntamente com", "logo após",
-	"logo depois", "logo que", "mesmo que", "não apenas", "nesse hiato", "nesse ínterim", "nesse meio tempo", "nesse sentido",
-	"no entanto", "no momento em que", "ou por outra", "ou seja", "para que", "pelo contrário", "por analogia", "por causa de",
-	"por certo", "por conseguinte", "por consequência", "por conseqüência", "porém", "por exemplo", "por fim", "por isso", "por mais que",
-	"por menos que", "por outro lado", "por vezes", "posto que", "se acaso", "se bem que", "seja como for", "sem dúvida",
-	"sempre que", "só para exemplificar", "só para ilustrar", "só que", "sob o mesmo ponto de vista", "talvez provavelmente",
-	"tanto quanto", "todas as vezes que", "todas as vezes em que", "uma vez que", "visto que", "de repente",
-	"nada obstante", "não obstante", "de qualquer forma", "diga-se de passagem", "de qualquer jeito",
-	"de vez em quando", "aos poucos", "claro que", "no geral", "em geral", "geralmente", "subitamente", "a despeito de",
-	"em razão de", "em razão disso", "razão pela qual", "por essa razão", "por motivo de", "devido a", "em todo o caso", "de qualquer maneira",
-	"de todo modo", "de todo a modo", "de qualquer modo", "de forma que", "de modo que", "de tempos em tempos", "daí em diante", " daí por diante",
-	"de hoje em diante", "a partir de agora", "de agora em diante",
-];
-
-export const allWords = singleWords.concat( multipleWords );
-
-export default allWords;

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

@@ -1,9 +0,0 @@
-/**
- * Returns an array with two-part transition words to be used by the assessments.
- * @returns {Array} The array filled with two-part transition words.
- */
-export default [
-	[ "não apenas", "como também" ], [ "não só", "bem como" ], [ "não só", "como também" ],
-	[ "não só", "mas também" ], [ "ora", "ora" ], [ "ou", "ou" ], [ "quer", "quer" ],
-];
-

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

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

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

@@ -1,29 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {createRegexFromArray, getClauses} = languageProcessing;
-
-import PortugueseClause from '../values/Clause';
-import auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';
-import stopwords from '../config/stopWords.js';
-const followingAuxiliaryExceptionWords = ['o', 'a', 'os', 'as', 'um', 'ums', 'uma', 'umas'];
-
-const options = {
-  Clause: PortugueseClause,
-  stopwords: stopwords,
-  auxiliaries: auxiliaries,
-  regexes: {
-    auxiliaryRegex: createRegexFromArray(auxiliaries),
-    stopCharacterRegex: /([:,])(?=[ \n\r\t'"+\-»«‹›<>])/gi,
-    followingAuxiliaryExceptionRegex: createRegexFromArray(followingAuxiliaryExceptionWords)
-  }
-};
-
-/**
- * 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 getPortugueseClauses(sentence) {
-  return getClauses(sentence, options);
-}

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

@@ -1,22 +0,0 @@
-import {get} from 'lodash';
-import {languageProcessing} from '../../../index';
-const {baseStemmer} = languageProcessing;
-
-import stem from './internal/stem';
-
-/**
- * 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'), 'pt', false);
-
-  if (morphologyData) {
-    return word => stem(word, morphologyData);
-  }
-
-  return baseStemmer;
-}

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

@@ -1,35 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {getWords} = languageProcessing;
-
-import participleStems from '../../config/internal/passiveVoiceParticiples';
-
-/**
- * Checks if a Portuguese word is a participle.
- * @param {string} word A Portuguese word.
- * @returns {boolean} Returns true if word is a Portuguese participle, and false otherwise.
- */
-function isParticiple(word) {
-  const participleSuffixes = ['a', 'o', 'as', 'os'];
-  // For each participle suffixes, check if the word ends in one of them.
-  return participleSuffixes.some(suffix => {
-    // Make sure only possible participles are targeted (minimum length being "> 3")
-    if (word.length > 3 && word.endsWith(suffix)) {
-      // If the word ends with one of the suffixes, retrieve the stem.
-      const stem = word.slice(0, -suffix.length);
-      // Check if the stem is in the list of participle stems: return true if it is, otherwise return false.
-      return participleStems.includes(stem);
-    }
-  });
-}
-
-/**
- * Creates an array of participles 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);
-  return words.filter(word => isParticiple(word));
-}

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

@@ -1,319 +0,0 @@
-/* eslint-disable max-statements, complexity */
-
-/*
-Copyright (c) 2015, Luís Rodrigues
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-import {languageProcessing} from '../../../index';
-const {findMatchingEndingInArray} = languageProcessing;
-
-/**
- * Checks whether the character is a vowel.
- *
- * @param {string}	    character	The character to check.
- * @param {string[]}    vowels      The Portuguese vowels.
- *
- * @returns {boolean}	Whether the character is a vowel.
- */
-const isVowel = function(character, vowels) {
-  return vowels.includes(character);
-};
-
-/**
- * Finds the first vowel in a string after the specified index and returns the index of the character following that vowel
- * (if found).
- *
- * @param {string}	    word	    The word to check.
- * @param {string[]}    vowels      The Portuguese vowels.
- * @param {number}	    start       The index at which the search for a vowel should begin.
- *
- * @returns {number} The index of the character following the found vowel. If this is not found, the length of the word.
- */
-const nextVowelPosition = function(word, vowels, start) {
-  const length = word.length;
-
-  for (let position = start; position < length; position++) {
-    if (isVowel(word[position], vowels)) {
-      return position;
-    }
-  }
-
-  return length;
-};
-
-/**
- * Finds the first consonant in a string after the specified index and returns the index of the character following that
- * consonant (if found).
- *
- * @param {string}	    word	The word to check.
- * @param {string[]}    vowels  The Portuguese vowels.
- * @param {number}	    start	The index at which the search for a consonant should begin.
- *
- * @returns {number} The index of the character following the found consonant. If this is not found, the length of the word.
- */
-const nextConsonantPosition = function(word, vowels, start) {
-  const length = word.length;
-
-  for (let position = start; position < length; position++) {
-    if (!isVowel(word[position], vowels)) {
-      return position;
-    }
-  }
-
-  return length;
-};
-
-/**
- * Replaces characters with other characters if found in a word.
- *
- * @param {string}		word				The word to check.
- * @param {string[]}	charactersToReplace	The characters to replace.
- * @param {string[]}	replacements		The replacement characters.
- *
- * @returns {string}	The word with the replacement characters, or the original word if no characters to replace were found.
- */
-const replaceCharacters = function(word, charactersToReplace, replacements) {
-  for (let i = 0; i < charactersToReplace.length; i++) {
-    word = word.replace(charactersToReplace[i], replacements[i]);
-  }
-
-  return word;
-};
-
-/**
- * Looks for the longest suffix in each group and removes it if it is found within the specified region (R1, R2 or RV).
- * Once a suffix is found and removed, stops searching further.
- *
- * For some of the suffix groups, replaces the suffix with another string after removing it (e.g. -logia is replaced with
- * -log).
- *
- * @param {string}	word	            The word to check.
- * @param {Object}  standardSuffixData  The data for stemming standard suffixes.
- * @param {string}	r1Text	            The text in the R1 region.
- * @param {string}	r2Text	            The text in the R2 region.
- * @param {string}	rvText	            The text in the RV region.
- *
- * @returns {string} The stemmed word or the original word if no suffix was removed.
- */
-const stemStandardSuffixes = function(word, standardSuffixData, r1Text, r2Text, rvText) {
-  const regions = {
-    r1: r1Text,
-    r2: r2Text,
-    rv: rvText
-  };
-
-  for (const suffixGroup of standardSuffixData.standardGroups) {
-    const foundSuffix = findMatchingEndingInArray(
-      regions[suffixGroup.region],
-      suffixGroup.suffixes
-    );
-
-    if (foundSuffix) {
-      return word.slice(0, -foundSuffix.length) + suffixGroup.replacement;
-    }
-  }
-
-  const specialEnding = findMatchingEndingInArray(
-    regions[standardSuffixData.specialClass.region],
-    standardSuffixData.specialClass.suffixes
-  );
-  if (
-    findMatchingEndingInArray(word, standardSuffixData.specialClass.wordEndingsToCheck) &&
-    specialEnding
-  ) {
-    word = word.slice(0, -specialEnding.length) + standardSuffixData.specialClass.replacement;
-  }
-
-  return word;
-};
-
-/**
- * Stems verb suffixes.
- *
- * @param {string}      word            The original word.
- * @param {string[]}    verbSuffixes    The verb suffixes to check.
- * @param {string}      rvText          The text of the RV.
- *
- * @returns {string} The word with the verb suffixes removed (if applicable).
- */
-const stemVerbSuffixes = function(word, verbSuffixes, rvText) {
-  const verbSuffix = findMatchingEndingInArray(rvText, verbSuffixes);
-
-  if (verbSuffix !== '') {
-    word = word.slice(0, -verbSuffix.length);
-  }
-
-  return word;
-};
-
-/**
- * Stems residual suffixes.
- *
- * @param {string}	word	            The word to check.
- * @param {Object}  residualSuffixData  The data used to stem residual suffixes.
- * @param {string}	rvText	            The text in the RV region.
- *
- * @returns {string} The word with a removed suffix, or the original input word if no suffix was removed.
- */
-const stemResidualSuffixes = function(word, residualSuffixData, rvText) {
-  const foundSuffixUe = findMatchingEndingInArray(rvText, residualSuffixData.groupUe.suffixes);
-  const foundSuffixIe = findMatchingEndingInArray(rvText, residualSuffixData.groupIe.suffixes);
-  const foundSuffixE = findMatchingEndingInArray(rvText, residualSuffixData.groupESuffixes);
-
-  if (
-    foundSuffixUe &&
-    findMatchingEndingInArray(word, residualSuffixData.groupUe.wordEndingsToCheck)
-  ) {
-    word = word.slice(0, -foundSuffixUe.length);
-  } else if (
-    foundSuffixIe &&
-    findMatchingEndingInArray(word, residualSuffixData.groupIe.wordEndingsToCheck)
-  ) {
-    word = word.slice(0, -foundSuffixIe.length);
-  } else if (foundSuffixE) {
-    word = word.slice(0, -foundSuffixE.length);
-  } else if (word.endsWith(residualSuffixData.cCedilla[0])) {
-    word = word.slice(0, -1) + residualSuffixData.cCedilla[1];
-  }
-
-  return word;
-};
-
-/**
- * Stems Portuguese words.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Portuguese morphology data.
- *
- * @returns {string} The stemmed word.
- */
-export default function stem(word, morphologyData) {
-  word.toLowerCase();
-  const vowels = morphologyData.externalStemmer.vowels;
-
-  // Nasal vowels should be treated as a vowel followed by a consonant.
-  const nasalVowels = morphologyData.externalStemmer.nasalVowels.originals;
-  const nasalVowelsReplacement = morphologyData.externalStemmer.nasalVowels.replacements;
-  word = replaceCharacters(word, nasalVowels, nasalVowelsReplacement);
-
-  const length = word.length;
-  if (length < 2) {
-    return word;
-  }
-
-  let r1 = length;
-  let r2 = length;
-  let rv = length;
-
-  /*
-   * R1 is the region after the first non-vowel following a vowel, or is the null region at the end of the word if
-   * there is no such non-vowel.
-   */
-  for (let i = 0; i < length - 1 && r1 === length; i++) {
-    if (isVowel(word[i], vowels) && !isVowel(word[i + 1], vowels)) {
-      r1 = i + 2;
-    }
-  }
-
-  /*
-   * R2 is the region after the first non-vowel following a vowel in R1, or is the null region at the end of the
-   * word if there is no such non-vowel.
-   */
-  for (let i = r1; i < length - 1 && r2 === length; i++) {
-    if (isVowel(word[i], vowels) && !isVowel(word[i + 1], vowels)) {
-      r2 = i + 2;
-    }
-  }
-
-  /*
-   * If the second letter is a consonant, RV is the region after the next following vowel. If the first two letters are
-   * vowels, RV is the region after the next consonant, and otherwise (consonant-vowel case) RV is the region after the
-   * third letter. But RV is the end of the word if these positions cannot be found.
-   */
-  if (length > 3) {
-    if (!isVowel(word[1], vowels)) {
-      rv = nextVowelPosition(word, vowels, 2) + 1;
-    } else if (isVowel(word[0], vowels) && isVowel(word[1], vowels)) {
-      rv = nextConsonantPosition(word, vowels, 2) + 1;
-    } else {
-      rv = 3;
-    }
-  }
-
-  const r1Text = word.slice(r1);
-  const r2Text = word.slice(r2);
-  let rvText = word.slice(rv);
-
-  // Go through the first step of removing suffixes.
-  const wordAfterStep1 = stemStandardSuffixes(
-    word,
-    morphologyData.externalStemmer.standardSuffixes,
-    r1Text,
-    r2Text,
-    rvText
-  );
-
-  // If no suffixes were removed in the first step, search for and remove verb suffixes.
-  let wordAfterStep2 = '';
-
-  if (word === wordAfterStep1) {
-    wordAfterStep2 = stemVerbSuffixes(word, morphologyData.externalStemmer.verbSuffixes, rvText);
-  }
-
-  // If suffixes were removed in one of the previous steps, replace the word with the de-suffixed word and adjust RV text.
-  if (word !== wordAfterStep1) {
-    word = wordAfterStep1;
-    rvText = word.slice(rv);
-  } else if (word !== wordAfterStep2) {
-    word = wordAfterStep2;
-    rvText = word.slice(rv);
-  }
-
-  /*
-   * If a suffix was removed in one of the two previous steps, remove -i if preceded by -c and in RV. If no suffix was
-   * removed in one of the previous steps, remove -os, -a, -i, -o, -á, í, or ó if in RV.
-   */
-  if (wordAfterStep1 !== word || wordAfterStep2 !== word) {
-    if (
-      word.endsWith(morphologyData.externalStemmer.ciToC[0]) &&
-      rvText.endsWith(morphologyData.externalStemmer.ciToC[1])
-    ) {
-      word = word.slice(0, -1);
-      rvText = word.slice(rv);
-    }
-  } else {
-    const foundGeneralSuffix = findMatchingEndingInArray(
-      rvText,
-      morphologyData.externalStemmer.generalSuffixes
-    );
-    if (foundGeneralSuffix !== '') {
-      word = word.slice(0, -foundGeneralSuffix.length);
-      rvText = word.slice(rv);
-    }
-  }
-
-  // Stem residual suffixes, regardless of whether a suffix was removed in any of the previous steps or not.
-  word = stemResidualSuffixes(word, morphologyData.externalStemmer.residualSuffixes, rvText);
-
-  // Change the nasal vowel replacements back into the nasal vowels.
-  word = replaceCharacters(word, nasalVowelsReplacement, nasalVowels);
-
-  return word;
-}

package/src/languageProcessing/languages/pt/values/Clause.js

@@ -1,43 +0,0 @@
-import {languageProcessing} from '../../../index';
-import {cannotDirectlyPrecedePassiveParticiple} from '../config/functionWords';
-import getParticiples from '../helpers/internal/getParticiples';
-const {directPrecedenceException, values} = languageProcessing;
-const {Clause} = values;
-
-/**
- * Creates a Clause object for the Portuguese language.
- */
-class PortugueseClause extends Clause {
-  /**
-   * Constructor.
-   *
-   * @param {string} clauseText   The text of the clause.
-   * @param {Array} auxiliaries   The auxiliaries.
-   *
-   * @constructor
-   */
-  constructor(clauseText, auxiliaries) {
-    super(clauseText, auxiliaries);
-    this._participles = getParticiples(this.getClauseText());
-    this.checkParticiples();
-  }
-
-  /**
-   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
-   * If no exceptions are found, the clause is passive.
-   *
-   * @returns {void}
-   */
-  checkParticiples() {
-    const clause = this.getClauseText();
-
-    const foundParticiples = this.getParticiples().filter(
-      participle =>
-        !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple)
-    );
-
-    this.setPassive(foundParticiples.length > 0);
-  }
-}
-
-export default PortugueseClause;

package/src/languageProcessing/languages/ru/Researcher.js

@@ -1,48 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {AbstractResearcher} = languageProcessing;
-
-// All config
-import firstWordExceptions from './config/firstWordExceptions';
-import {all as functionWords} from './config/functionWords';
-import transitionWords from './config/transitionWords';
-import twoPartTransitionWords from './config/twoPartTransitionWords';
-import syllables from './config/syllables.json';
-import fleschReadingEaseScores from './config/fleschReadingEaseScores';
-import sentenceLength from './config/sentenceLength';
-
-// All helpers
-import getStemmer from './helpers/getStemmer';
-import isPassiveSentence from './helpers/isPassiveSentence';
-import fleschReadingScore from './helpers/calculateFleschReadingScore';
-
-/**
- * The researcher contains all the researches, helpers, data, and config.
- */
-export default class Researcher extends AbstractResearcher {
-  /**
-   * Constructor
-   * @param {Paper} paper The Paper object that is needed within the researches.
-   * @constructor
-   */
-  constructor(paper) {
-    super(paper);
-
-    Object.assign(this.config, {
-      language: 'ru',
-      passiveConstructionType: 'morphological',
-      firstWordExceptions,
-      functionWords,
-      transitionWords,
-      twoPartTransitionWords,
-      syllables,
-      fleschReadingEaseScores,
-      sentenceLength
-    });
-
-    Object.assign(this.helpers, {
-      getStemmer,
-      isPassiveSentence,
-      fleschReadingScore
-    });
-  }
-}

package/src/languageProcessing/languages/ru/config/firstWordExceptions.js

@@ -1,14 +0,0 @@
-/**
- *  Returns an array with exceptions for the sentence beginning researcher.
- *  @returns {Array} The array filled with exceptions.
- *  */
-export default [
-	// Numbers 1-10:
-	"один", "одна", "одно", "два", "две", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять",
-	// Demonstrative pronouns: тот, этот, такой, таков, столько
-	"этот", "этого", "этому", "этим", "этом", "эта", "этой", "эту", "это", "этого", "этому", "эти", "этих", "этим",
-	"этими", "тот", "того", "тому", "тем", "том", "та", "той", "ту", "те", "тех", "тем", "теми", "тех", "такой",
-	"такого", "такому", "таким", "такая", "такую", "такое", "такие", "таких", "таким", "такими", "стольких",
-	"стольким", "столько", "столькими", "вот",
-];
-