axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.40

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

@@ -1,104 +0,0 @@
-/** @module config/transitionWords */
-
-export const singleWords = [ "abbastanza", "acciocché", "acciocchè", "adesso", "affinché", "affinchè", "allora", "almeno", "alquanto", "altrettanto",
-	"altrimenti", "analogamente", "anche", "ancora", "antecedentemente", "anzi", "anzitutto",
-	"apertamente", "appena", "assai", "attualmente", "benché", "benchè", "beninteso", "bensì", "brevemente", "bruscamente",
-	"casomai", "celermente", "certamente", "certo", "chiaramente", "ciononostante", "cioé", "cioè", "comparabilmente", "come",
-	"complessivamente", "completamente", "comunque", "concisamente", "concludendo", "conformemente", "congiuntamente",
-	"conseguentemente", "considerando", "considerato", "considerevolmente", "contemporaneamente", "continuamente",
-	"contrariamente", "controbilanciato", "così", "cosicché", "cosicchè", "dapprima", "dato", "davvero", "definitivamente",
-	"dettagliatamente", "differentemente", "diversamente", "dopo", "dopodiché", "dopodichè", "durante", "dunque", "eccetto",
-	"eccome", "effettivamente", "egualmente", "elencando", "enfaticamente", "eppure", "esaurientemente", "esplicitamente",
-	"espressamente", "estesamente", "evidentemente", "finalmente", "finché", "finchè", "fino", "finora", "fintanto", "fintanto che",
-	"fintantoché", "fintantochè", "fondamentalmente", "frattanto", "frequentemente", "generalmente", "già", "gradualmente", "illustrando",
-	"immantinente", "immediatamente", "importantissimo", "incontestabilmente", "incredibilmente", "indipendentemente",
-	"indiscutibilmente", "indubbiamente", "infatti", "infine", "innanzitutto", "innegabilmente", "inoltre", "insomma",
-	"intanto", "interamente", "istantaneamente", "invece", "logicamente", "lentamente", "ma", "malgrado", "marcatamente",
-	"memorabile", "mentre", "motivatamente", "naturalmente", "né", "nè", "neanche", "neppure", "nonché", "nonchè", "nondimeno",
-	"nonostante", "notevolmente", "occasionalmente", "oltretutto", "onde", "onestamente", "ossia", "ostinatamente",
-	"ovvero", "ovviamente", "parimenti", "particolarmente", "peraltro", "perché", "perchè", "perciò", "perlomeno", "però",
-	"pertanto", "pesantemente", "piuttosto", "poi", "poiché", "poichè", "praticamente", "precedentemente", "preferibilmente", "precisamente",
-	"prematuramente", "presto", "prima", "primariamente", "primo", "principalmente", "prontamente", "proporzionalmente",
-	"pure", "purché", "purchè", "quando", "quanto", "quantomeno", "quindi", "raramente", "realmente", "relativamente",
-	"riassumendo", "riformulando", "ripetutamente", "saltuariamente", "schiettamente", "sebbene", "secondariamente",
-	"secondo", "sempre", "sennò", "seguente", "sensibilmente", "seppure", "seriamente", "siccome", "sicuramente",
-	"significativamente", "similmente", "simultaneamente", "singolarmente", "sinteticamente", "solitamente", "solo",
-	"soltanto", "soprattutto", "sopravvalutato", "sorprendentemente", "sostanzialmente", "sottolineando", "sottovalutato",
-	"specialmente", "specificamente", "specificatamente", "subitamente", "subito", "successivamente", "successivo",
-	"talmente", "terzo", "totalmente", "tranne", "tuttavia", "ugualmente", "ulteriormente", "ultimamente", "veramente",
-	"verosimilmente", "visto" ];
-
-export const multipleWords = [ "a breve", "a causa", "a causa di", "a condizione che", "a conseguenza", "a conti fatti",
-	"a differenza di", "a differenza del", "a differenza della", "a differenza dei", "a differenza degli",
-	"a differenza delle", "a dire il vero", "a dire la verità", "a dirla tutta", "a dispetto di", "a lungo",
-	"a lungo termine", "a maggior ragione", "a meno che non", "a parte", "a patto che", "a prescindere", "a prima vista",
-	"a proposito", "a qualunque costo", "a quanto", "a quel proposito", "a quel tempo", "a quell'epoca", "a questo fine",
-	"a questo proposito", "a questo punto", "a questo riguardo", "a questo scopo", "a riguardo", "a seguire", "a seguito",
-	"a sottolineare", "a tal fine", "a tal proposito", "a tempo debito", "a tutti gli effetti", "a tutti i costi",
-	"a una prima occhiata", "ad eccezione di", "ad esempio", "ad essere maliziosi", "ad essere sinceri", "ad ogni buon conto",
-	"ad ogni costo", "ad ogni modo", "ad una prima occhiata", "adesso che", "al che", "al contrario", "al contrario di",
-	"al fine di", "al fine di fare", "al giorno d'oggi", "al momento", "al momento giusto", "al momento opportuno",
-	"al più presto", "al posto di", "al suo posto", "al termine", "all'epoca", "all'infuori di", "all'inizio", "all'opposto",
-	"all'ultimo", "alla fine", "alla fine della fiera", "alla luce", "alla luce di", "alla lunga", "alla moda",
-	"alla stessa maniera", "allo scopo di", "allo stesso modo", "allo stesso tempo", "anch'esso", "anch'io", "anche se",
-	"ancora più", "ancora di più", "assumendo che", "bisogna chiarire che", "bisogna considerare che", "causato da",
-	"ciò nondimeno", "ciò nonostante", "col tempo", "con il tempo", "come a dire", "come abbiamo dimostrato",
-	"come è stato notato", "come è stato detto", "come è stato dimostrato", "come hanno detto", "come ho detto",
-	"come ho dimostrato", "come ho notato", "come potete notare", "come potete vedere", "come puoi notare", "come puoi vedere",
-	"come si è dimostrato", "come si può vedere", "come si può notare", "come sopra indicato", "comunque sia", "con attenzione",
-	"con enfasi", "con il risultato che", "con l'obiettivo di", "con ostinazione", "con questa intenzione", "con questa idea",
-	"con queste idee", "con questo in testa", "con questo scopo", "così che", "così da", "d'altra parte", "d'altro canto",
-	"d'altro lato", "d'altronde", "d'ora in avanti", "d'ora in poi", "da allora", "da quando", "da quanto", "da quel momento",
-	"da quella volta", "da questo momento in poi", "da questo momento", "da qui", "da ultimo", "da un certo punto di vista",
-	"da un lato", "da una parte", "dall'altro lato", "dall'epoca", "dal che", "dato che", "dato per assunto che", "davanti a",
-	"del tutto", "dell'epoca", "detto questo", "di certo", "di colpo", "di conseguenza", "di fatto", "di fronte", "di fronte a",
-	"di lì a poco", "di punto in bianco", "di quando in quando", "di quanto non sia", "di quel tempo", "di qui a", "di rado",
-	"di seguito", "di si", "di sicuro", "di solito", "di tanto in tanto", "di tutt'altra pasta", "di quando in quando",
-	"differente da", "diversamente da", "diverso da", "dopotutto", "dovuto a", "e anche", "e inoltre", "entro breve",
-	"fermo restando che", "faccia a faccia", "fin da", "fin dall'inizio", "fin quando", "finché non", "finchè non", "fin dal primo momento",
-	"fin dall'inizio", "fino a", "fino a questo momento", "fino ad oggi", "fino ai giorni nostri", "fino adesso",
-	"fino a un certo punto", "fino adesso", "fra quanto", "il prima possibile", "in aggiunta", "in altre parole",
-	"in altri termini", "in ambo i casi", "in breve", "in caso di", "in conclusione", "in conformità", "in confronto",
-	"in confronto a", "in conseguenza", "in considerazione", "in considerazione di", "in definitiva", "in dettaglio",
-	"importante rendersi conto", "in effetti", "in entrambi i casi", "in fin dei conti", "in generale", "in genere",
-	"in linea di massima", "in poche parole", "il più possibile", "in maggior parte", "in maniera analoga", "in maniera convincente",
-	"in maniera esauriente", "in maniera esaustiva", "in maniera esplicita", "in maniera evidente", "in maniera incontestabile",
-	"in maniera indiscutibile", "in maniera innegabile", "in maniera significativa", "in maniera simile", "in modo allusivo",
-	"in modo analogo", "in modo che", "in modo convincente", "in modo da", "in modo identico", "in modo notevole",
-	"in modo significativo", "in modo significativo", "in modo simile", "in ogni caso", "in ogni modo", "in ogni momento",
-	"in parte considerevole", "in parti uguali", "in particolare", "in particolare per", "in particolare", "in più", "in pratica",
-	"in precedenza", "in prima battuta", "in prima istanza", "in primo luogo", "in rapporto", "in qualche modo", "in qualsiasi modo",
-	"in qualsiasi momento", "in qualunque modo", "in qualunque momento", "in quarta battuta", "in quarta istanza", "in quarto luogo",
-	"in quel caso", "in quelle circostanze", "in questa occasione", "in questa situazione", "in questo caso",
-	"in questo caso particolare", "in questo istante", "in questo momento", "in rare occasioni", "in realtà", "in seconda battuta",
-	"in seconda istanza", "in secondo luogo", "in seguito", "in sintesi", "in sostanza", "in tempo", "in terza battuta",
-	"in terza istanza", "in terzo luogo", "in totale", "in tutto", "in ugual maniera", "in ugual misura", "in ugual modo",
-	"in ultima analisi", "in ultima istanza", "in un altro caso", "in una parola", "in verità", "insieme a", "insieme con",
-	"invece che", "invece di", "la prima cosa da considerare", "la prima cosa da tenere a mente", "lo stesso",
-	"mentre potrebbe essere vero", "motivo per cui", "motivo per il quale", "ne consegue che", "ne deriva che", "nei dettagli",
-	"nel caso", "nel caso che", "nel caso in cui", "nel complesso", "nel corso del", "nel corso di", "nel frattempo",
-	"nel lungo periodo", "nel mentre", "nell'eventualità che", "nella misura in cui", "nella speranza che", "nella stessa maniera",
-	"nella stessa misura", "nello specifico", "nello stesso modo", "nello stesso momento", "nello stesso stile", "non appena",
-	"non per essere maliziosi", "non più da", "nonostante ciò", "nonostante tutto", "ogni qualvolta", "ogni tanto", "ogni volta",
-	"oltre a", "oltre a ciò", "ora che", "passo dopo passo", "per causa di", "per certo", "per chiarezza", "per chiarire",
-	"per come", "per concludere", "per conto di", "per contro", "per cui", "per davvero", "per di più", "per dirla in altro modo",
-	"per dirla meglio", "per dirla tutta", "per es.", "per esempio", "per essere sinceri", "per far vedere", "per farla breve",
-	"per finire", "per l'avvenire", "per l'ultima volta", "per la maggior parte", "per la stessa ragione", "per la verità",
-	"per lo più", "per mettere in luce", "per metterla in altro modo", "per non dire di", "per non parlare di", "per ora",
-	"per ovvi motivi", "per paura di", "per paura dei", "per paura delle", "per paura degli", "per prima cosa", "per quanto",
-	"per questa ragione", "per questo motivo", "per riassumere", "per sottolineare", "per timore", "per trarre le conclusioni",
-	"per ultima", "per ultime", "per ultimi", "per ultimo", "per via di", "perché si", "perchè si", "perfino se", "piano piano",
-	"più di ogni altra cosa", "più di tutto", "più facilmente", "più importante", "più tardi", "poco a poco", "poco dopo",
-	"prendiamo il caso di", "presto o tardi", "prima che", "prima di", "prima di ogni cosa", "prima di tutto",
-	"prima o dopo", "prima o poi", "questo è probabilmente vero", "questo potrebbe essere vero", "restando inteso che",
-	"riassumendo", "quanto prima", "questa volta", "se confrontato con", "se e solo se", "se no", "seduta stante", "sempreché", "semprechè",
-	"sempre che", "senz'altro", "senza alcun riguardo", "senza dubbio", "senz'ombra di dubbio", "senza ombra di dubbio",
-	"senza riguardo per", "senza tregua", "senza ulteriore ritardo", "sia quel che sia", "solo se", "sotto questa luce",
-	"sperando che", "sta volta", "su tutto", "subito dopo", "sul serio", "tanto per cominciare", "tanto quanto", "tra breve",
-	"tra l'altro", "tra poco", "tra quanto", "tutte le volte", "tutti insieme", "tutto a un tratto", "tutto ad un tratto",
-	"tutto d'un tratto", "tutto considerato", "tutto sommato", "un passo alla volta", "un tempo", "una volta",
-	"una volta ogni tanto", "unito a", "va chiarito che", "va considerato che", "vada come vada", "vale a dire", "visto che" ];
-
-export const allWords = singleWords.concat( multipleWords );
-
-export default allWords;

package/src/languageProcessing/languages/it/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é", "né" ], [ "non", "ma" ], [ "non prima", "che" ], [ "non prima", "di" ], [ "non solo", "ma anche" ],
-	[ "o", "o" ], [ "se", "allora" ], [ "se", "o" ], [ "sia", "che" ]  ];
-
-

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

@@ -1,15 +0,0 @@
-import { helpers } from "avadaseo";
-const { formatNumber } = helpers;
-
-/**
- * Returns the Flesch reading score for Italian.
- *
- * @param {Object} statistics The Flesch reading statistics.
- *
- * @returns {number} The Flesch reading score for Italian.
- */
-export default function calculateScore( statistics ) {
-	const score = 217 - ( 1.3 * statistics.averageWordsPerSentence ) - ( 0.6 * statistics.syllablesPer100Words );
-
-	return formatNumber( score );
-}

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

@@ -1,32 +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';
-
-const followingAuxiliaryExceptionWords = ['il', 'i', 'la', 'le', 'lo', 'gli', 'uno', 'una'];
-const reflexivePronouns = ['mi', 'ti', 'si', 'ci', 'vi'];
-
-const options = {
-  Clause,
-  stopwords: stopwords,
-  auxiliaries: auxiliaries,
-  regexes: {
-    auxiliaryRegex: createRegexFromArray(auxiliaries),
-    stopCharacterRegex: /([:,])(?=[ \n\r\t'"+\-»«‹›<>])/gi,
-    followingAuxiliaryExceptionRegex: createRegexFromArray(followingAuxiliaryExceptionWords),
-    directPrecedenceExceptionRegex: createRegexFromArray(reflexivePronouns)
-  }
-};
-
-/**
- * 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 the clauses that have an auxiliary.
- */
-export default function getItalianClauses(sentence) {
-  return getClauses(sentence, options);
-}

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

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

@@ -1,34 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {getWords} = languageProcessing;
-
-import participleStems from '../../config/internal/passiveVoiceParticiples';
-
-/**
- * Checks if an Italian word is a participle.
- * @param {string} word An Italian word.
- * @returns {boolean} Returns true if word is an Italian participle, and false otherwise.
- */
-function isParticiple(word) {
-  const participleSuffixes = ['a', 'o', 'e', 'i'];
-  // 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, -1);
-      // Check if the stem is in the list of participle stems: return true if it is, otherwise return false.
-      return participleStems.includes(stem);
-    }
-  });
-}
-/**
- * Creates a participle list 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/it/helpers/internal/stem.js

@@ -1,436 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-/*
-Copyright (c) 2012, Leonardo Fenu, Chris Umbel
-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 {createSingleRuleFromArray, createRulesFromArrays} = languageProcessing;
-
-/**
- * Determines whether a letter is a vowel.
- *
- * @param {string} letter           The letter that has to be checked.
- * @param {Object} morphologyData   The Italian morphology data file.
- *
- * @returns {boolean} True if the letter is a vowel.
- */
-function isVowel(letter, morphologyData) {
-  return morphologyData.externalStemmer.vowels.includes(letter);
-}
-
-/**
- * Determines the next position in a word that is a vowel.
- *
- * @param {string}  word            The word to be checked.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {number}  start           The position of the word where you start checking.
- *
- * @returns {number} The next position in a word that is a vowel, or the final position if no vowel is found.
- */
-function getNextVowelPos(word, morphologyData, start) {
-  start = start + 1;
-  const length = word.length;
-
-  for (let i = start; i < length; i++) {
-    if (isVowel(word[i], morphologyData)) {
-      return i;
-    }
-  }
-
-  return length;
-}
-
-/**
- * Determines the next position in a word that is a consonant.
- *
- * @param {string}  word            The word that has to be checked.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {number}  start           The position of the word where you start checking.
- *
- * @returns {number} The next position in a word that is a consonant, or the final position if no consonant is found.
- */
-function getNextConsonantPos(word, morphologyData, start) {
-  const length = word.length;
-
-  for (let i = start; i < length; i++) {
-    if (!isVowel(word[i], morphologyData)) {
-      return i;
-    }
-  }
-
-  return length;
-}
-
-/**
- * Checks whether a word ends in a suffix and if so it returns the suffix.
- *
- * @param {string}       word           The word that has to be checked.
- * @param {string[]}     suffixes       The suffixes that have to be checked.
- *
- * @returns {string}                    The suffix that the word ends in or an empty string if the word does not end in any of the suffixes.
- */
-function endsinArr(word, suffixes) {
-  for (let i = 0; i < suffixes.length; i++) {
-    if (word.endsWith(suffixes[i])) {
-      return suffixes[i];
-    }
-  }
-
-  return '';
-}
-
-/**
- * Turns acute accents into grave ones.
- *
- * @param {string}  word            The word that has to be checked.
- * @param {Object}  morphologyData  The Italian morphology data file.
- *
- * @returns {string} The word with acute accents (e.g. é) replaced by grave ones (e.g. è).
- */
-function replaceAcute(word, morphologyData) {
-  const acuteReplacements = createRulesFromArrays(
-    morphologyData.externalStemmer.preProcessing.acuteReplacements,
-    'gi'
-  );
-
-  for (const acuteReplacement of acuteReplacements) {
-    word = word.replace(acuteReplacement.reg, acuteReplacement.repl);
-  }
-
-  return word;
-}
-
-/**
- * Turns an i or u in between vowels into upper case.
- *
- * @param {string}  word            The word that has to be checked.
- * @param {Object}  morphologyData  The Italian morphology data file.
- *
- *  @returns {string} The word with either i or u turned into upper case.
- */
-function vowelMarking(word, morphologyData) {
-  return word.replace(
-    new RegExp(morphologyData.externalStemmer.preProcessing.vowelMarking, 'g'),
-    (match, p1, p2, p3) => p1 + p2.toUpperCase() + p3
-  );
-}
-
-/**
- * Pre-process the word for stemming by setting it to lower case and replacing some letters.
- *
- * @param {string} word            The word to pre-process.
- * @param {Object} morphologyData  The Italian morphology data file.
- *
- * @returns {string} The pre-processed word.
- */
-function preProcess(word, morphologyData) {
-  word = word.toLowerCase();
-  word = replaceAcute(word, morphologyData);
-  const quReplacement = createSingleRuleFromArray(
-    morphologyData.externalStemmer.preProcessing.quReplacement,
-    'g'
-  );
-  word = word.replace(quReplacement.reg, quReplacement.repl);
-  word = vowelMarking(word, morphologyData);
-
-  return word;
-}
-
-/**
- * Determines R1, R2 and RV in the word.
- *
- * @param {string}  word            The word for which Rs have to be determined.
- * @param {Object}  morphologyData  The Italian morphology data file.
- *
- * @returns {{r2: number, rv: number, r1: number}} R1, R2 and RV in the word.
- */
-const determineRs = function(word, morphologyData) {
-  let r1 = word.length;
-  let r2 = word.length;
-  let rv = word.length;
-
-  // R1 is the region after the first non-vowel following a vowel,
-  for (let i = 0; i < word.length - 1 && r1 === word.length; i++) {
-    if (isVowel(word[i], morphologyData) && !isVowel(word[i + 1], morphologyData)) {
-      r1 = i + 2;
-    }
-  }
-
-  // R2 is the region after the first non-vowel following a vowel in R1
-  for (let i = r1; i < word.length - 1 && r2 === word.length; i++) {
-    if (isVowel(word[i], morphologyData) && !isVowel(word[i + 1], morphologyData)) {
-      r2 = i + 2;
-    }
-  }
-
-  if (word.length > 3) {
-    if (!isVowel(word[1], morphologyData)) {
-      // If the second letter is a consonant, RV is the region after the next following vowel.
-      rv = getNextVowelPos(word, morphologyData, 1) + 1;
-    } else if (isVowel(word[0], morphologyData) && isVowel(word[1], morphologyData)) {
-      // Or if the first two letters are vowels, RV is the region after the next consonant.
-      rv = getNextConsonantPos(word, morphologyData, 2) + 1;
-    } else {
-      /*
-       * 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.
-       */
-      rv = 3;
-    }
-  }
-
-  return {r1, r2, rv};
-};
-
-/**
- * Removes pronoun suffixes.
- *
- * @param {string}  word            The word from which suffixes have to be removed.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {string}  rvText          The content of the RV.
- *
- * @returns {string} The word without pronoun suffixes.
- */
-const removePronounSuffixes = function(word, morphologyData, rvText) {
-  const foundSuffix = endsinArr(word, morphologyData.externalStemmer.pronounSuffixes.suffixes);
-
-  if (foundSuffix !== '') {
-    const foundSuffixPre1 = endsinArr(
-      rvText.slice(0, -foundSuffix.length),
-      morphologyData.externalStemmer.pronounSuffixes.preSuffixesGerund
-    );
-    const foundSuffixPre2 = endsinArr(
-      rvText.slice(0, -foundSuffix.length),
-      morphologyData.externalStemmer.pronounSuffixes.preSuffixesInfinitive
-    );
-
-    if (foundSuffixPre1 !== '') {
-      word = word.slice(0, -foundSuffix.length);
-    }
-    if (foundSuffixPre2 !== '') {
-      word =
-        word.slice(0, -foundSuffix.length) +
-        morphologyData.externalStemmer.pronounSuffixes.infinitiveCompletion;
-    }
-  }
-  return word;
-};
-
-/**
- * Removes standard suffixes.
- *
- * @param {string}  word            The word from which standard suffixes have to be removed.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {string}  r2Text          The content of the R2.
- * @param {string}  r1Text          The content of the R1.
- * @param {string}  rvText          The content of the RV.
- *
- * @returns {string} The word without standard suffixes.
- */
-const removeStandardSuffixes = function(word, morphologyData, r2Text, r1Text, rvText) {
-  const regions = {
-    r1: r1Text,
-    r2: r2Text,
-    rv: rvText
-  };
-
-  for (const suffixGroup of morphologyData.externalStemmer.standardSuffixes) {
-    const foundSuffix = endsinArr(regions[suffixGroup.region], suffixGroup.suffixes);
-
-    if (foundSuffix) {
-      return word.slice(0, -foundSuffix.length) + suffixGroup.replacement;
-    }
-  }
-
-  return word;
-};
-
-/**
- *  Removes verb suffixes.
- *
- * @param {string}  word            The word from which verb suffixes have to be removed.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {string}  rvText          The content of the RV.
- *
- * @returns {string} The word without verb suffixes.
- */
-const removeVerbSuffixes = function(word, morphologyData, rvText) {
-  const foundSuffix = endsinArr(rvText, morphologyData.externalStemmer.verbSuffixes);
-
-  if (foundSuffix) {
-    word = word.slice(0, -foundSuffix.length);
-  }
-
-  return word;
-};
-
-/**
- * Normalizes digraphs ch/gh to c/g.
- *
- * @param {string}  word    The word to normalize.
- * @param {Object}  morphologyData  The Italian morphology data file.
- * @param {string}  rvText          The content of the RV.
- *
- * @returns {string} The normalized word.
- */
-const normalizeDigraphs = function(word, morphologyData, rvText) {
-  const digraphCh = morphologyData.externalStemmer.digraphNormalization.digraphCh;
-  const digraphGh = morphologyData.externalStemmer.digraphNormalization.digraphGh;
-
-  if (rvText.endsWith(digraphCh[0])) {
-    word = word.slice(0, -digraphGh[0].length) + digraphCh[1];
-  } else if (rvText.endsWith(digraphGh[0])) {
-    word = word.slice(0, -digraphGh[0].length) + digraphGh[1];
-  }
-
-  return word;
-};
-
-/**
- * Returns a canonical stem for words with multiple stems.
- *
- * @param {string}  word                       The word to canonicalize.
- * @param {Object}  stemsThatBelongToOneWord   An object of arrays of stems belonging to one word.
- *
- * @returns {string} A canonicalized stem or the original word.
- */
-const canonicalizeStem = function(word, stemsThatBelongToOneWord) {
-  // Check the verbs list. The infinitive stem is always the canonical stem for verbs.
-  for (const paradigm of stemsThatBelongToOneWord.verbsWithMultipleStems) {
-    if (paradigm.includes(word)) {
-      return paradigm[0];
-    }
-  }
-  // Check the diminutives list.
-  for (const paradigm of stemsThatBelongToOneWord.irregularDiminutives) {
-    if (paradigm.includes(word)) {
-      return paradigm[0];
-    }
-  }
-};
-
-/**
- * Checks whether a word is in the full-form exception list and if so returns the canonical stem.
- *
- * @param {string} word	      The word to be checked.
- * @param {Object} exceptions The list of full-form exceptions to be checked in.
- *
- * @returns {null|string} The canonical stem or null if nothing was found.
- */
-const checkWordInFullFormExceptions = function(word, exceptions) {
-  for (const paradigm of exceptions) {
-    if (paradigm[1].includes(word)) {
-      return paradigm[0];
-    }
-  }
-  return null;
-};
-
-/**
- * Stems Italian words.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Italian morphology data file.
- *
- * @returns {string}               The stemmed word.
- */
-export default function stem(word, morphologyData) {
-  // Check the exception list for irregular plural nouns and adjectives.
-  const irregularPluralNounsAndAdjectives = checkWordInFullFormExceptions(
-    word,
-    morphologyData.irregularPluralNounsAndAdjectives
-  );
-  if (irregularPluralNounsAndAdjectives) {
-    return irregularPluralNounsAndAdjectives;
-  }
-
-  // Check the exception list for irregular verbs listed in full forms.
-  const irregularVerbs = checkWordInFullFormExceptions(word, morphologyData.irregularVerbs);
-  if (irregularVerbs) {
-    return irregularVerbs;
-  }
-
-  // Start word pre-processing.
-  word = preProcess(word, morphologyData);
-
-  // Don't stem words that consist of less than 3 letters.
-  if (word.length < 3) {
-    return word;
-  }
-
-  // Determines r1 ,r2, rv.
-  const {r1, r2, rv} = determineRs(word, morphologyData);
-
-  // Determiners the content of r1, r2, and rv.
-  let r1Text = word.substring(r1);
-  let r2Text = word.substring(r2);
-  let rvText = word.substring(rv);
-
-  const originalWord = word;
-
-  // Step 0: Attached pronoun removal.
-  word = removePronounSuffixes(word, morphologyData, rvText);
-
-  if (word !== originalWord) {
-    r1Text = word.substring(r1);
-    r2Text = word.substring(r2);
-    rvText = word.substring(rv);
-  }
-
-  const wordAfter0 = word;
-
-  // Step 1:  Standard suffix removal.
-  word = removeStandardSuffixes(word, morphologyData, r2Text, r1Text, rvText);
-
-  if (word !== wordAfter0) {
-    rvText = word.substring(rv);
-  }
-
-  const wordAfter1 = word;
-
-  // Step 2:  Verb suffix removal.
-  if (wordAfter0 === wordAfter1) {
-    word = removeVerbSuffixes(word, morphologyData, rvText);
-  }
-
-  rvText = word.substring(rv);
-
-  // Always do step 3.
-  let foundSuffix = '';
-
-  // Remove general suffixes.
-  if ((foundSuffix = endsinArr(rvText, morphologyData.externalStemmer.generalSuffixes)) !== '') {
-    word = word.slice(0, -foundSuffix.length);
-  }
-
-  rvText = word.substring(rv);
-
-  // Normalize digraphs ch/gh.
-  word = normalizeDigraphs(word, morphologyData, rvText);
-
-  // Lowercase the word before canonicalizing stem
-  word = word.toLowerCase();
-
-  // Returns a canonical stem for words with multiple stems (e.g., verbs: chiudere–chiuso; diminutives: ovetto-uovo).
-  const canonicalStem = canonicalizeStem(word, morphologyData.stemsThatBelongToOneWord);
-  if (canonicalStem) {
-    return canonicalStem;
-  }
-  return word.toLowerCase();
-}