axyseo 2.0.0-alpha.2 → 2.1.0

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

@@ -1,17 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-var _index = require("../../../index");
-var _countSyllables = require("../../../../helpers/syllables/countSyllables");
-var _syllables = _interopRequireDefault(require("../../config/syllables.json"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { languageProcessing } from "../../../../../index.js";
+import { countSyllablesInWord } from "../../../../helpers/syllables/countSyllables";
+import syllables from "../../config/syllables.json";
 const {
   buildFormRule,
   createRulesFromArrays
-} = _index.languageProcessing;
+} = languageProcessing;
 
 /**
  * Further checks if the word can be a specific adjectival form.
@@ -24,7 +17,7 @@ const {
  * @returns {boolean} Whether the word can be a specific adjectival form.
  */
 const refineAdjectiveCheck = (word, endsWith, nonStemmingExceptions, forcedStemmingExceptions) => {
-  const countSyllables = (0, _countSyllables.countSyllablesInWord)(word, _syllables.default);
+  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.
@@ -102,7 +95,7 @@ const constructCanBeFunction = function (endsWith, minimumWordLength, nonStemmin
  *
  * @returns {Object} The base form of the input word.
  */
-function _default(word, regexAdjective, stopAdjectives, multiSyllableAdjWithSuffixes) {
+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).

package/build/languageProcessing/languages/en/helpers/internal/getAdjectiveStem.js.map

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

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

@@ -1,17 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getParticiples;
-var _lodash = require("lodash");
-var _index = require("../../../index");
-var _passiveVoiceIrregulars = _interopRequireDefault(require("../../config/internal/passiveVoiceIrregulars"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { forEach, includes } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
 const {
   matchRegularParticiples,
   getWords
-} = _index.languageProcessing;
+} = languageProcessing;
+import irregularParticiples from "../../config/internal/passiveVoiceIrregulars";
+
 /**
  * Creates participle array for the participles found in a clause.
  *
@@ -19,12 +13,12 @@ const {
  *
  * @returns {Array} The list with participles.
  */
-function getParticiples(clauseText) {
+export default function getParticiples(clauseText) {
   const words = getWords(clauseText);
   const foundParticiples = [];
-  (0, _lodash.forEach)(words, function (word) {
+  forEach(words, function (word) {
     const regex = [/\w+ed($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi];
-    if (matchRegularParticiples(word, regex).length !== 0 || (0, _lodash.includes)(_passiveVoiceIrregulars.default, word)) {
+    if (matchRegularParticiples(word, regex).length !== 0 || includes(irregularParticiples, word)) {
       foundParticiples.push(word);
     }
   });

package/build/languageProcessing/languages/en/helpers/internal/getParticiples.js.map

@@ -1 +1 @@
-{"version":3,"file":"getParticiples.js","names":["_lodash","require","_index","_passiveVoiceIrregulars","_interopRequireDefault","e","__esModule","default","matchRegularParticiples","getWords","languageProcessing","getParticiples","clauseText","words","foundParticiples","forEach","word","regex","length","includes","irregularParticiples","push"],"sources":["../../../../../../src/languageProcessing/languages/en/helpers/internal/getParticiples.js"],"sourcesContent":["import {forEach, includes} from 'lodash';\nimport {languageProcessing} from '../../../index';\nconst {matchRegularParticiples, getWords} = languageProcessing;\n\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars';\n\n/**\n * Creates participle array for the participles found in a clause.\n *\n * @param {string} clauseText The clause to find participles in\n *\n * @returns {Array} The list with participles.\n */\nexport default function getParticiples(clauseText) {\n  const words = getWords(clauseText);\n  const foundParticiples = [];\n\n  forEach(words, function(word) {\n    const regex = [/\\w+ed($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi];\n    if (matchRegularParticiples(word, regex).length !== 0 || includes(irregularParticiples, word)) {\n      foundParticiples.push(word);\n    }\n  });\n  return foundParticiples;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,uBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAgF,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAFhF,MAAM;EAACG,uBAAuB;EAAEC;AAAQ,CAAC,GAAGC,yBAAkB;AAI9D;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GAAGJ,QAAQ,CAACG,UAAU,CAAC;EAClC,MAAME,gBAAgB,GAAG,EAAE;EAE3B,IAAAC,eAAO,EAACF,KAAK,EAAE,UAASG,IAAI,EAAE;IAC5B,MAAMC,KAAK,GAAG,CAAC,0CAA0C,CAAC;IAC1D,IAAIT,uBAAuB,CAACQ,IAAI,EAAEC,KAAK,CAAC,CAACC,MAAM,KAAK,CAAC,IAAI,IAAAC,gBAAQ,EAACC,+BAAoB,EAAEJ,IAAI,CAAC,EAAE;MAC7FF,gBAAgB,CAACO,IAAI,CAACL,IAAI,CAAC;IAC7B;EACF,CAAC,CAAC;EACF,OAAOF,gBAAgB;AACzB","ignoreList":[]}
+{"version":3,"file":"getParticiples.js","names":["forEach","includes","languageProcessing","matchRegularParticiples","getWords","irregularParticiples","getParticiples","clauseText","words","foundParticiples","word","regex","length","push"],"sources":["../../../../../../src/languageProcessing/languages/en/helpers/internal/getParticiples.js"],"sourcesContent":["import {forEach, includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {matchRegularParticiples, getWords} = languageProcessing;\n\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars';\n\n/**\n * Creates participle array for the participles found in a clause.\n *\n * @param {string} clauseText The clause to find participles in\n *\n * @returns {Array} The list with participles.\n */\nexport default function getParticiples(clauseText) {\n  const words = getWords(clauseText);\n  const foundParticiples = [];\n\n  forEach(words, function(word) {\n    const regex = [/\\w+ed($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi];\n    if (matchRegularParticiples(word, regex).length !== 0 || includes(irregularParticiples, word)) {\n      foundParticiples.push(word);\n    }\n  });\n  return foundParticiples;\n}\n"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,QAAQ,QAAO,QAAQ;AACxC,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,uBAAuB;EAAEC;AAAQ,CAAC,GAAGF,kBAAkB;AAE9D,OAAOG,oBAAoB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GAAGJ,QAAQ,CAACG,UAAU,CAAC;EAClC,MAAME,gBAAgB,GAAG,EAAE;EAE3BT,OAAO,CAACQ,KAAK,EAAE,UAASE,IAAI,EAAE;IAC5B,MAAMC,KAAK,GAAG,CAAC,0CAA0C,CAAC;IAC1D,IAAIR,uBAAuB,CAACO,IAAI,EAAEC,KAAK,CAAC,CAACC,MAAM,KAAK,CAAC,IAAIX,QAAQ,CAACI,oBAAoB,EAAEK,IAAI,CAAC,EAAE;MAC7FD,gBAAgB,CAACI,IAAI,CAACH,IAAI,CAAC;IAC7B;EACF,CAAC,CAAC;EACF,OAAOD,gBAAgB;AACzB","ignoreList":[]}

package/build/languageProcessing/languages/en/helpers/internal/getVerbStem.js

@@ -1,17 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.normalizePrefixed = exports.getInfinitive = exports.endsWithIng = exports.checkIrregulars = void 0;
-var _lodash = require("lodash");
-var _index = require("../../../index");
 // "use strict";
-
+import { isUndefined } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
 const {
   buildFormRule,
   createRulesFromArrays
-} = _index.languageProcessing;
+} = languageProcessing;
 const vowelRegex = /([aeiouy])/g;
 
 /**
@@ -107,7 +100,6 @@ const normalizePrefixed = function (word, verbPrefixes) {
  *
  * @returns {Array} Array of word forms from the exception list.
  */
-exports.normalizePrefixed = normalizePrefixed;
 const checkIrregulars = function (word, irregularVerbs, verbPrefixes) {
   let irregulars;
   irregularVerbs.forEach(function (paradigm) {
@@ -117,9 +109,9 @@ const checkIrregulars = function (word, irregularVerbs, verbPrefixes) {
       }
     });
   });
-  if ((0, _lodash.isUndefined)(irregulars)) {
+  if (isUndefined(irregulars)) {
     const normalizedIrregular = normalizePrefixed(word, verbPrefixes);
-    if (!(0, _lodash.isUndefined)(normalizedIrregular)) {
+    if (!isUndefined(normalizedIrregular)) {
       irregularVerbs.forEach(function (paradigm) {
         paradigm.forEach(function (wordInParadigm) {
           if (wordInParadigm === normalizedIrregular.normalizedWord) {
@@ -141,7 +133,6 @@ const checkIrregulars = function (word, irregularVerbs, verbPrefixes) {
  *
  * @returns {boolean} True if the word ends with "s".
  */
-exports.checkIrregulars = checkIrregulars;
 const endsWithS = function (word) {
   const wordLength = word.length;
   // Consider only words of four letters or more to be s-forms (otherwise, words like "its" are being treated as verb forms).
@@ -175,7 +166,6 @@ const endsWithIng = function (word) {
  *
  * @returns {boolean} True if the word ends with "ed".
  */
-exports.endsWithIng = endsWithIng;
 const endsWithEd = function (word) {
   const vowelCount = (word.match(vowelRegex) || []).length;
 
@@ -224,5 +214,5 @@ const getInfinitive = function (word, regexVerb) {
     guessedForm: 'inf'
   };
 };
-exports.getInfinitive = getInfinitive;
+export { getInfinitive, checkIrregulars, endsWithIng, normalizePrefixed };
 //# sourceMappingURL=getVerbStem.js.map

package/build/languageProcessing/languages/en/helpers/internal/getVerbStem.js.map

@@ -1 +1 @@
-{"version":3,"file":"getVerbStem.js","names":["_lodash","require","_index","buildFormRule","createRulesFromArrays","languageProcessing","vowelRegex","normalizePrefixed","word","verbPrefixes","property","hasOwnProperty","RegExp","sevenLetterHyphenPrefixes","test","normalizedWord","replace","prefix","substring","sevenLetterPrefixes","fiveLetterHyphenPrefixes","fiveLetterPrefixes","fourLetterHyphenPrefixes","fourLetterPrefixes","threeLetterHyphenPrefixes","threeLetterPrefixes","twoLetterHyphenPrefixes","twoLetterPrefixes","oneLetterPrefixes","exports","checkIrregulars","irregularVerbs","irregulars","forEach","paradigm","wordInParadigm","isUndefined","normalizedIrregular","map","verb","concat","endsWithS","wordLength","length","endsWithIng","vowelCount","match","endsWithEd","getInfinitive","regexVerb","sFormToInfinitiveRegex","sFormToInfinitive","ingFormToInfinitiveRegex","ingFormToInfinitive","edFormToInfinitiveRegex","edFormToInfinitive","infinitive","guessedForm"],"sources":["../../../../../../src/languageProcessing/languages/en/helpers/internal/getVerbStem.js"],"sourcesContent":["// \"use strict\";\nimport {isUndefined} from 'lodash';\nimport {languageProcessing} from '../../../index';\nconst {buildFormRule, createRulesFromArrays} = languageProcessing;\n\nconst vowelRegex = /([aeiouy])/g;\n\n/**\n * Checks if the input word has one of the standard verb prefixes and if so returns a prefix and a de-prefixed verb to be\n * further used to compare with the list of irregular verbs.\n *\n * @param {string} word             The word for which to determine if it has one of the standard verb prefixes.\n * @param {Object} verbPrefixes     The collection of verb prefixes to be used for normalization\n *\n * @returns {Array} Array of word forms from the exception list.\n */\nconst normalizePrefixed = function(word, verbPrefixes) {\n  for (const property in verbPrefixes) {\n    if (verbPrefixes.hasOwnProperty) {\n      verbPrefixes[property] = new RegExp(verbPrefixes[property], 'i');\n    }\n  }\n\n  if (verbPrefixes.sevenLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.sevenLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 8)\n    };\n  }\n\n  if (verbPrefixes.sevenLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.sevenLetterPrefixes, ''),\n      prefix: word.substring(0, 7)\n    };\n  }\n\n  if (verbPrefixes.fiveLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fiveLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 6)\n    };\n  }\n\n  if (verbPrefixes.fiveLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fiveLetterPrefixes, ''),\n      prefix: word.substring(0, 5)\n    };\n  }\n\n  if (verbPrefixes.fourLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fourLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 5)\n    };\n  }\n\n  if (verbPrefixes.fourLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fourLetterPrefixes, ''),\n      prefix: word.substring(0, 4)\n    };\n  }\n\n  if (verbPrefixes.threeLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.threeLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 4)\n    };\n  }\n\n  if (verbPrefixes.threeLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.threeLetterPrefixes, ''),\n      prefix: word.substring(0, 3)\n    };\n  }\n\n  if (verbPrefixes.twoLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.twoLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 3)\n    };\n  }\n\n  if (verbPrefixes.twoLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.twoLetterPrefixes, ''),\n      prefix: word.substring(0, 2)\n    };\n  }\n\n  if (verbPrefixes.oneLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.oneLetterPrefixes, ''),\n      prefix: word.substring(0, 1)\n    };\n  }\n};\n\n/**\n * Checks if the input word occurs in the list of exception verbs and if so returns all its irregular forms.\n * If not checks if it is an irregular verb with one of the standard verb prefixes, if so returns all irregular prefixed forms.\n *\n * @param {string} word             The word for which to determine its irregular forms.\n * @param {Array} irregularVerbs    The array of irregular verbs available for this language.\n * @param {Object} verbPrefixes     The collection of verb prefixes to be used for normalization of irregular verbs.\n *\n * @returns {Array} Array of word forms from the exception list.\n */\nconst checkIrregulars = function(word, irregularVerbs, verbPrefixes) {\n  let irregulars;\n\n  irregularVerbs.forEach(function(paradigm) {\n    paradigm.forEach(function(wordInParadigm) {\n      if (wordInParadigm === word) {\n        irregulars = paradigm;\n      }\n    });\n  });\n\n  if (isUndefined(irregulars)) {\n    const normalizedIrregular = normalizePrefixed(word, verbPrefixes);\n\n    if (!isUndefined(normalizedIrregular)) {\n      irregularVerbs.forEach(function(paradigm) {\n        paradigm.forEach(function(wordInParadigm) {\n          if (wordInParadigm === normalizedIrregular.normalizedWord) {\n            irregulars = paradigm.map(function(verb) {\n              return normalizedIrregular.prefix.concat(verb);\n            });\n          }\n        });\n      });\n    }\n  }\n\n  return irregulars;\n};\n\n/**\n * Checks if the input word ends with \"s\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"s\".\n */\nconst endsWithS = function(word) {\n  const wordLength = word.length;\n  // Consider only words of four letters or more to be s-forms (otherwise, words like \"its\" are being treated as verb forms).\n  if (wordLength > 3) {\n    return word[word.length - 1] === 's';\n  }\n  return false;\n};\n\n/**\n * Checks if the input word ends with \"ing\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"ing\".\n */\nconst endsWithIng = function(word) {\n  const vowelCount = (word.match(vowelRegex) || []).length;\n\n  // Consider only words that have at least one more vowel besides \"i\" in \"ing\" (otherwise, words like \"ping\" are being treated as verb forms).\n  if (vowelCount > 1 && word.length > 4) {\n    return word.substring(word.length - 3, word.length) === 'ing';\n  }\n  return false;\n};\n\n/**\n * Checks if the input word ends with \"ed\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"ed\".\n */\nconst endsWithEd = function(word) {\n  const vowelCount = (word.match(vowelRegex) || []).length;\n\n  // Consider only words that have at least one more vowel besides \"e\" in \"ed\" (otherwise, words like \"red\" are being treated as verb forms).\n  if (\n    vowelCount > 1 ||\n    (vowelCount === 1 && word.substring(word.length - 3, word.length - 2) !== 'e')\n  ) {\n    return word.substring(word.length - 2, word.length) === 'ed';\n  }\n  return false;\n};\n\n/**\n * Forms the infinitive from an input word.\n *\n * @param {string} word                               The word to build the infinitive for.\n * @param {Object} regexVerb                          The list of regex rules used to bring verb forms to infinitive.\n * @param {Array}  regexVerb.sFormToInfinitiveRegex   The array of regex-based rules used to bring -s forms to infinitive.\n * @param {Array}  regexVerb.ingFormToInfinitiveRegex The array of regex-based rules used to bring -ing forms to infinitive.\n * @param {Array}  regexVerb.edFormToInfinitiveRegex  The array of regex-based rules used to bring -ed forms to infinitive.\n *\n * @returns {Object} The infinitive of the input word.\n */\nconst getInfinitive = function(word, regexVerb) {\n  const sFormToInfinitiveRegex = createRulesFromArrays(regexVerb.sFormToInfinitive);\n  const ingFormToInfinitiveRegex = createRulesFromArrays(regexVerb.ingFormToInfinitive);\n  const edFormToInfinitiveRegex = createRulesFromArrays(regexVerb.edFormToInfinitive);\n\n  if (endsWithS(word)) {\n    return {\n      infinitive: buildFormRule(word, sFormToInfinitiveRegex),\n      guessedForm: 's'\n    };\n  }\n\n  if (endsWithIng(word)) {\n    return {\n      infinitive: buildFormRule(word, ingFormToInfinitiveRegex),\n      guessedForm: 'ing'\n    };\n  }\n\n  if (endsWithEd(word)) {\n    return {\n      infinitive: buildFormRule(word, edFormToInfinitiveRegex) || word,\n      guessedForm: 'ed'\n    };\n  }\n  return {\n    infinitive: word,\n    guessedForm: 'inf'\n  };\n};\n\nexport {getInfinitive, checkIrregulars, endsWithIng, normalizePrefixed};\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"getVerbStem.js","names":["isUndefined","languageProcessing","buildFormRule","createRulesFromArrays","vowelRegex","normalizePrefixed","word","verbPrefixes","property","hasOwnProperty","RegExp","sevenLetterHyphenPrefixes","test","normalizedWord","replace","prefix","substring","sevenLetterPrefixes","fiveLetterHyphenPrefixes","fiveLetterPrefixes","fourLetterHyphenPrefixes","fourLetterPrefixes","threeLetterHyphenPrefixes","threeLetterPrefixes","twoLetterHyphenPrefixes","twoLetterPrefixes","oneLetterPrefixes","checkIrregulars","irregularVerbs","irregulars","forEach","paradigm","wordInParadigm","normalizedIrregular","map","verb","concat","endsWithS","wordLength","length","endsWithIng","vowelCount","match","endsWithEd","getInfinitive","regexVerb","sFormToInfinitiveRegex","sFormToInfinitive","ingFormToInfinitiveRegex","ingFormToInfinitive","edFormToInfinitiveRegex","edFormToInfinitive","infinitive","guessedForm"],"sources":["../../../../../../src/languageProcessing/languages/en/helpers/internal/getVerbStem.js"],"sourcesContent":["// \"use strict\";\nimport {isUndefined} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {buildFormRule, createRulesFromArrays} = languageProcessing;\n\nconst vowelRegex = /([aeiouy])/g;\n\n/**\n * Checks if the input word has one of the standard verb prefixes and if so returns a prefix and a de-prefixed verb to be\n * further used to compare with the list of irregular verbs.\n *\n * @param {string} word             The word for which to determine if it has one of the standard verb prefixes.\n * @param {Object} verbPrefixes     The collection of verb prefixes to be used for normalization\n *\n * @returns {Array} Array of word forms from the exception list.\n */\nconst normalizePrefixed = function(word, verbPrefixes) {\n  for (const property in verbPrefixes) {\n    if (verbPrefixes.hasOwnProperty) {\n      verbPrefixes[property] = new RegExp(verbPrefixes[property], 'i');\n    }\n  }\n\n  if (verbPrefixes.sevenLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.sevenLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 8)\n    };\n  }\n\n  if (verbPrefixes.sevenLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.sevenLetterPrefixes, ''),\n      prefix: word.substring(0, 7)\n    };\n  }\n\n  if (verbPrefixes.fiveLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fiveLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 6)\n    };\n  }\n\n  if (verbPrefixes.fiveLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fiveLetterPrefixes, ''),\n      prefix: word.substring(0, 5)\n    };\n  }\n\n  if (verbPrefixes.fourLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fourLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 5)\n    };\n  }\n\n  if (verbPrefixes.fourLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.fourLetterPrefixes, ''),\n      prefix: word.substring(0, 4)\n    };\n  }\n\n  if (verbPrefixes.threeLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.threeLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 4)\n    };\n  }\n\n  if (verbPrefixes.threeLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.threeLetterPrefixes, ''),\n      prefix: word.substring(0, 3)\n    };\n  }\n\n  if (verbPrefixes.twoLetterHyphenPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.twoLetterHyphenPrefixes, ''),\n      prefix: word.substring(0, 3)\n    };\n  }\n\n  if (verbPrefixes.twoLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.twoLetterPrefixes, ''),\n      prefix: word.substring(0, 2)\n    };\n  }\n\n  if (verbPrefixes.oneLetterPrefixes.test(word) === true) {\n    return {\n      normalizedWord: word.replace(verbPrefixes.oneLetterPrefixes, ''),\n      prefix: word.substring(0, 1)\n    };\n  }\n};\n\n/**\n * Checks if the input word occurs in the list of exception verbs and if so returns all its irregular forms.\n * If not checks if it is an irregular verb with one of the standard verb prefixes, if so returns all irregular prefixed forms.\n *\n * @param {string} word             The word for which to determine its irregular forms.\n * @param {Array} irregularVerbs    The array of irregular verbs available for this language.\n * @param {Object} verbPrefixes     The collection of verb prefixes to be used for normalization of irregular verbs.\n *\n * @returns {Array} Array of word forms from the exception list.\n */\nconst checkIrregulars = function(word, irregularVerbs, verbPrefixes) {\n  let irregulars;\n\n  irregularVerbs.forEach(function(paradigm) {\n    paradigm.forEach(function(wordInParadigm) {\n      if (wordInParadigm === word) {\n        irregulars = paradigm;\n      }\n    });\n  });\n\n  if (isUndefined(irregulars)) {\n    const normalizedIrregular = normalizePrefixed(word, verbPrefixes);\n\n    if (!isUndefined(normalizedIrregular)) {\n      irregularVerbs.forEach(function(paradigm) {\n        paradigm.forEach(function(wordInParadigm) {\n          if (wordInParadigm === normalizedIrregular.normalizedWord) {\n            irregulars = paradigm.map(function(verb) {\n              return normalizedIrregular.prefix.concat(verb);\n            });\n          }\n        });\n      });\n    }\n  }\n\n  return irregulars;\n};\n\n/**\n * Checks if the input word ends with \"s\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"s\".\n */\nconst endsWithS = function(word) {\n  const wordLength = word.length;\n  // Consider only words of four letters or more to be s-forms (otherwise, words like \"its\" are being treated as verb forms).\n  if (wordLength > 3) {\n    return word[word.length - 1] === 's';\n  }\n  return false;\n};\n\n/**\n * Checks if the input word ends with \"ing\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"ing\".\n */\nconst endsWithIng = function(word) {\n  const vowelCount = (word.match(vowelRegex) || []).length;\n\n  // Consider only words that have at least one more vowel besides \"i\" in \"ing\" (otherwise, words like \"ping\" are being treated as verb forms).\n  if (vowelCount > 1 && word.length > 4) {\n    return word.substring(word.length - 3, word.length) === 'ing';\n  }\n  return false;\n};\n\n/**\n * Checks if the input word ends with \"ed\".\n *\n * @param {string} word The word to check.\n *\n * @returns {boolean} True if the word ends with \"ed\".\n */\nconst endsWithEd = function(word) {\n  const vowelCount = (word.match(vowelRegex) || []).length;\n\n  // Consider only words that have at least one more vowel besides \"e\" in \"ed\" (otherwise, words like \"red\" are being treated as verb forms).\n  if (\n    vowelCount > 1 ||\n    (vowelCount === 1 && word.substring(word.length - 3, word.length - 2) !== 'e')\n  ) {\n    return word.substring(word.length - 2, word.length) === 'ed';\n  }\n  return false;\n};\n\n/**\n * Forms the infinitive from an input word.\n *\n * @param {string} word                               The word to build the infinitive for.\n * @param {Object} regexVerb                          The list of regex rules used to bring verb forms to infinitive.\n * @param {Array}  regexVerb.sFormToInfinitiveRegex   The array of regex-based rules used to bring -s forms to infinitive.\n * @param {Array}  regexVerb.ingFormToInfinitiveRegex The array of regex-based rules used to bring -ing forms to infinitive.\n * @param {Array}  regexVerb.edFormToInfinitiveRegex  The array of regex-based rules used to bring -ed forms to infinitive.\n *\n * @returns {Object} The infinitive of the input word.\n */\nconst getInfinitive = function(word, regexVerb) {\n  const sFormToInfinitiveRegex = createRulesFromArrays(regexVerb.sFormToInfinitive);\n  const ingFormToInfinitiveRegex = createRulesFromArrays(regexVerb.ingFormToInfinitive);\n  const edFormToInfinitiveRegex = createRulesFromArrays(regexVerb.edFormToInfinitive);\n\n  if (endsWithS(word)) {\n    return {\n      infinitive: buildFormRule(word, sFormToInfinitiveRegex),\n      guessedForm: 's'\n    };\n  }\n\n  if (endsWithIng(word)) {\n    return {\n      infinitive: buildFormRule(word, ingFormToInfinitiveRegex),\n      guessedForm: 'ing'\n    };\n  }\n\n  if (endsWithEd(word)) {\n    return {\n      infinitive: buildFormRule(word, edFormToInfinitiveRegex) || word,\n      guessedForm: 'ed'\n    };\n  }\n  return {\n    infinitive: word,\n    guessedForm: 'inf'\n  };\n};\n\nexport {getInfinitive, checkIrregulars, endsWithIng, normalizePrefixed};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/languages/en/values/Clause.js

@@ -1,20 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _lodash = require("lodash");
-var _functionWords = require("../config/functionWords");
-var _passiveVoiceNonVerbEndingEd = _interopRequireDefault(require("../config/internal/passiveVoiceNonVerbEndingEd"));
-var _getParticiples = _interopRequireDefault(require("../helpers/internal/getParticiples"));
-var _index = require("../../../index");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { includes, intersection, isEmpty } from 'lodash';
+import { cannotBeBetweenPassiveAuxiliaryAndParticiple, cannotDirectlyPrecedePassiveParticiple } from "../config/functionWords";
+import nonVerbsEndingEd from "../config/internal/passiveVoiceNonVerbEndingEd";
+import getParticiples from "../helpers/internal/getParticiples";
+import { languageProcessing } from "../../../../index.js";
 const {
   precedenceException,
   directPrecedenceException,
   values
-} = _index.languageProcessing;
+} = languageProcessing;
 const Clause = values.Clause;
 
 /**
@@ -31,7 +24,7 @@ class EnglishClause extends Clause {
    */
   constructor(clauseText, auxiliaries) {
     super(clauseText, auxiliaries);
-    this._participles = (0, _getParticiples.default)(this.getClauseText());
+    this._participles = getParticiples(this.getClauseText());
     this.checkParticiples();
   }
 
@@ -43,7 +36,7 @@ class EnglishClause extends Clause {
    */
   checkParticiples() {
     const clause = this.getClauseText();
-    const passiveParticiples = this.getParticiples().filter(participle => !(0, _lodash.includes)(_passiveVoiceNonVerbEndingEd.default, participle) && !this.hasRidException(participle) && !directPrecedenceException(clause, participle, _functionWords.cannotDirectlyPrecedePassiveParticiple) && !precedenceException(clause, participle, _functionWords.cannotBeBetweenPassiveAuxiliaryAndParticiple));
+    const passiveParticiples = this.getParticiples().filter(participle => !includes(nonVerbsEndingEd, participle) && !this.hasRidException(participle) && !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple) && !precedenceException(clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticiple));
     this.setPassive(passiveParticiples.length > 0);
   }
 
@@ -59,10 +52,10 @@ class EnglishClause extends Clause {
   hasRidException(participle) {
     if (participle === 'rid') {
       const irregularExclusionArray = ['get', 'gets', 'getting', 'got', 'gotten'];
-      return !(0, _lodash.isEmpty)((0, _lodash.intersection)(irregularExclusionArray, this.getAuxiliaries()));
+      return !isEmpty(intersection(irregularExclusionArray, this.getAuxiliaries()));
     }
     return false;
   }
 }
-var _default = exports.default = EnglishClause;
+export default EnglishClause;
 //# sourceMappingURL=Clause.js.map

package/build/languageProcessing/languages/en/values/Clause.js.map

@@ -1 +1 @@
-{"version":3,"file":"Clause.js","names":["_lodash","require","_functionWords","_passiveVoiceNonVerbEndingEd","_interopRequireDefault","_getParticiples","_index","e","__esModule","default","precedenceException","directPrecedenceException","values","languageProcessing","Clause","EnglishClause","constructor","clauseText","auxiliaries","_participles","getParticiples","getClauseText","checkParticiples","clause","passiveParticiples","filter","participle","includes","nonVerbsEndingEd","hasRidException","cannotDirectlyPrecedePassiveParticiple","cannotBeBetweenPassiveAuxiliaryAndParticiple","setPassive","length","irregularExclusionArray","isEmpty","intersection","getAuxiliaries","_default","exports"],"sources":["../../../../../src/languageProcessing/languages/en/values/Clause.js"],"sourcesContent":["import {includes, intersection, isEmpty} from 'lodash';\nimport {\n  cannotBeBetweenPassiveAuxiliaryAndParticiple,\n  cannotDirectlyPrecedePassiveParticiple\n} from '../config/functionWords';\nimport nonVerbsEndingEd from '../config/internal/passiveVoiceNonVerbEndingEd';\nimport getParticiples from '../helpers/internal/getParticiples';\nimport {languageProcessing} from '../../../index';\nconst {precedenceException, directPrecedenceException, values} = languageProcessing;\nconst Clause = values.Clause;\n\n/**\n * Creates a Clause object for the English language.\n */\nclass EnglishClause extends Clause {\n  /**\n   * Constructor.\n   *\n   * @param {string} clauseText   The text of the clause.\n   * @param {Array} auxiliaries   The auxiliaries.\n   *\n   * @constructor\n   */\n  constructor(clauseText, auxiliaries) {\n    super(clauseText, auxiliaries);\n    this._participles = getParticiples(this.getClauseText());\n    this.checkParticiples();\n  }\n\n  /**\n   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.\n   * If no exceptions are found, the clause is passive.\n   *\n   * @returns {boolean} Returns true if no exception is found.\n   */\n  checkParticiples() {\n    const clause = this.getClauseText();\n\n    const passiveParticiples = this.getParticiples().filter(\n      participle =>\n        !includes(nonVerbsEndingEd, participle) &&\n        !this.hasRidException(participle) &&\n        !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple) &&\n        !precedenceException(clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticiple)\n    );\n\n    this.setPassive(passiveParticiples.length > 0);\n  }\n\n  /**\n   * Checks whether the participle is 'rid' in combination with 'get', 'gets', 'getting', 'got' or 'gotten'.\n   * If this is true, the participle is not passive.\n   *\n   * @param {string} participle   The participle\n   *\n   * @returns {boolean} Returns true if 'rid' is found in combination with a form of 'get'\n   * otherwise returns false.\n   */\n  hasRidException(participle) {\n    if (participle === 'rid') {\n      const irregularExclusionArray = ['get', 'gets', 'getting', 'got', 'gotten'];\n      return !isEmpty(intersection(irregularExclusionArray, this.getAuxiliaries()));\n    }\n    return false;\n  }\n}\n\nexport default EnglishClause;\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AAIA,IAAAE,4BAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,eAAA,GAAAD,sBAAA,CAAAH,OAAA;AACA,IAAAK,MAAA,GAAAL,OAAA;AAAkD,SAAAG,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAClD,MAAM;EAACG,mBAAmB;EAAEC,yBAAyB;EAAEC;AAAM,CAAC,GAAGC,yBAAkB;AACnF,MAAMC,MAAM,GAAGF,MAAM,CAACE,MAAM;;AAE5B;AACA;AACA;AACA,MAAMC,aAAa,SAASD,MAAM,CAAC;EACjC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,WAAWA,CAACC,UAAU,EAAEC,WAAW,EAAE;IACnC,KAAK,CAACD,UAAU,EAAEC,WAAW,CAAC;IAC9B,IAAI,CAACC,YAAY,GAAG,IAAAC,uBAAc,EAAC,IAAI,CAACC,aAAa,CAAC,CAAC,CAAC;IACxD,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEA,gBAAgBA,CAAA,EAAG;IACjB,MAAMC,MAAM,GAAG,IAAI,CAACF,aAAa,CAAC,CAAC;IAEnC,MAAMG,kBAAkB,GAAG,IAAI,CAACJ,cAAc,CAAC,CAAC,CAACK,MAAM,CACrDC,UAAU,IACR,CAAC,IAAAC,gBAAQ,EAACC,oCAAgB,EAAEF,UAAU,CAAC,IACvC,CAAC,IAAI,CAACG,eAAe,CAACH,UAAU,CAAC,IACjC,CAACf,yBAAyB,CAACY,MAAM,EAAEG,UAAU,EAAEI,qDAAsC,CAAC,IACtF,CAACpB,mBAAmB,CAACa,MAAM,EAAEG,UAAU,EAAEK,2DAA4C,CACzF,CAAC;IAED,IAAI,CAACC,UAAU,CAACR,kBAAkB,CAACS,MAAM,GAAG,CAAC,CAAC;EAChD;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEJ,eAAeA,CAACH,UAAU,EAAE;IAC1B,IAAIA,UAAU,KAAK,KAAK,EAAE;MACxB,MAAMQ,uBAAuB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC;MAC3E,OAAO,CAAC,IAAAC,eAAO,EAAC,IAAAC,oBAAY,EAACF,uBAAuB,EAAE,IAAI,CAACG,cAAc,CAAC,CAAC,CAAC,CAAC;IAC/E;IACA,OAAO,KAAK;EACd;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAA9B,OAAA,GAEcM,aAAa","ignoreList":[]}
+{"version":3,"file":"Clause.js","names":["includes","intersection","isEmpty","cannotBeBetweenPassiveAuxiliaryAndParticiple","cannotDirectlyPrecedePassiveParticiple","nonVerbsEndingEd","getParticiples","languageProcessing","precedenceException","directPrecedenceException","values","Clause","EnglishClause","constructor","clauseText","auxiliaries","_participles","getClauseText","checkParticiples","clause","passiveParticiples","filter","participle","hasRidException","setPassive","length","irregularExclusionArray","getAuxiliaries"],"sources":["../../../../../src/languageProcessing/languages/en/values/Clause.js"],"sourcesContent":["import {includes, intersection, isEmpty} from 'lodash';\nimport {\n  cannotBeBetweenPassiveAuxiliaryAndParticiple,\n  cannotDirectlyPrecedePassiveParticiple\n} from '../config/functionWords';\nimport nonVerbsEndingEd from '../config/internal/passiveVoiceNonVerbEndingEd';\nimport getParticiples from '../helpers/internal/getParticiples';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {precedenceException, directPrecedenceException, values} = languageProcessing;\nconst Clause = values.Clause;\n\n/**\n * Creates a Clause object for the English language.\n */\nclass EnglishClause extends Clause {\n  /**\n   * Constructor.\n   *\n   * @param {string} clauseText   The text of the clause.\n   * @param {Array} auxiliaries   The auxiliaries.\n   *\n   * @constructor\n   */\n  constructor(clauseText, auxiliaries) {\n    super(clauseText, auxiliaries);\n    this._participles = getParticiples(this.getClauseText());\n    this.checkParticiples();\n  }\n\n  /**\n   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.\n   * If no exceptions are found, the clause is passive.\n   *\n   * @returns {boolean} Returns true if no exception is found.\n   */\n  checkParticiples() {\n    const clause = this.getClauseText();\n\n    const passiveParticiples = this.getParticiples().filter(\n      participle =>\n        !includes(nonVerbsEndingEd, participle) &&\n        !this.hasRidException(participle) &&\n        !directPrecedenceException(clause, participle, cannotDirectlyPrecedePassiveParticiple) &&\n        !precedenceException(clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticiple)\n    );\n\n    this.setPassive(passiveParticiples.length > 0);\n  }\n\n  /**\n   * Checks whether the participle is 'rid' in combination with 'get', 'gets', 'getting', 'got' or 'gotten'.\n   * If this is true, the participle is not passive.\n   *\n   * @param {string} participle   The participle\n   *\n   * @returns {boolean} Returns true if 'rid' is found in combination with a form of 'get'\n   * otherwise returns false.\n   */\n  hasRidException(participle) {\n    if (participle === 'rid') {\n      const irregularExclusionArray = ['get', 'gets', 'getting', 'got', 'gotten'];\n      return !isEmpty(intersection(irregularExclusionArray, this.getAuxiliaries()));\n    }\n    return false;\n  }\n}\n\nexport default EnglishClause;\n"],"mappings":"AAAA,SAAQA,QAAQ,EAAEC,YAAY,EAAEC,OAAO,QAAO,QAAQ;AACtD,SACEC,4CAA4C,EAC5CC,sCAAsC;AAExC,OAAOC,gBAAgB;AACvB,OAAOC,cAAc;AACrB,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,mBAAmB;EAAEC,yBAAyB;EAAEC;AAAM,CAAC,GAAGH,kBAAkB;AACnF,MAAMI,MAAM,GAAGD,MAAM,CAACC,MAAM;;AAE5B;AACA;AACA;AACA,MAAMC,aAAa,SAASD,MAAM,CAAC;EACjC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,WAAWA,CAACC,UAAU,EAAEC,WAAW,EAAE;IACnC,KAAK,CAACD,UAAU,EAAEC,WAAW,CAAC;IAC9B,IAAI,CAACC,YAAY,GAAGV,cAAc,CAAC,IAAI,CAACW,aAAa,CAAC,CAAC,CAAC;IACxD,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEA,gBAAgBA,CAAA,EAAG;IACjB,MAAMC,MAAM,GAAG,IAAI,CAACF,aAAa,CAAC,CAAC;IAEnC,MAAMG,kBAAkB,GAAG,IAAI,CAACd,cAAc,CAAC,CAAC,CAACe,MAAM,CACrDC,UAAU,IACR,CAACtB,QAAQ,CAACK,gBAAgB,EAAEiB,UAAU,CAAC,IACvC,CAAC,IAAI,CAACC,eAAe,CAACD,UAAU,CAAC,IACjC,CAACb,yBAAyB,CAACU,MAAM,EAAEG,UAAU,EAAElB,sCAAsC,CAAC,IACtF,CAACI,mBAAmB,CAACW,MAAM,EAAEG,UAAU,EAAEnB,4CAA4C,CACzF,CAAC;IAED,IAAI,CAACqB,UAAU,CAACJ,kBAAkB,CAACK,MAAM,GAAG,CAAC,CAAC;EAChD;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEF,eAAeA,CAACD,UAAU,EAAE;IAC1B,IAAIA,UAAU,KAAK,KAAK,EAAE;MACxB,MAAMI,uBAAuB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC;MAC3E,OAAO,CAACxB,OAAO,CAACD,YAAY,CAACyB,uBAAuB,EAAE,IAAI,CAACC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC/E;IACA,OAAO,KAAK;EACd;AACF;AAEA,eAAef,aAAa","ignoreList":[]}

package/build/languageProcessing/languages/es/Researcher.js

@@ -1,33 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _index = require("../../../index");
-var _firstWordExceptions = _interopRequireDefault(require("./config/firstWordExceptions"));
-var _functionWords = require("./config/functionWords");
-var _stopWords = _interopRequireDefault(require("./config/stopWords"));
-var _transitionWords = _interopRequireDefault(require("./config/transitionWords"));
-var _twoPartTransitionWords = _interopRequireDefault(require("./config/twoPartTransitionWords"));
-var _syllables = _interopRequireDefault(require("./config/syllables.json"));
-var _sentenceLength = _interopRequireDefault(require("./config/sentenceLength"));
-var _getClauses = _interopRequireDefault(require("./helpers/getClauses"));
-var _getStemmer = _interopRequireDefault(require("./helpers/getStemmer"));
-var _calculateFleschReadingScore = _interopRequireDefault(require("./helpers/calculateFleschReadingScore"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { languageProcessing } from "../../../index.js";
 const {
   AbstractResearcher
-} = _index.languageProcessing;
+} = languageProcessing;
 
 // All config
+import firstWordExceptions from "./config/firstWordExceptions";
+import { all as functionWords } from "./config/functionWords";
+import stopWords from "./config/stopWords";
+import transitionWords from "./config/transitionWords";
+import twoPartTransitionWords from "./config/twoPartTransitionWords";
+import syllables from "./config/syllables.json";
+import sentenceLength from "./config/sentenceLength";
 
 // All helpers
+import getClauses from "./helpers/getClauses";
+import getStemmer from "./helpers/getStemmer";
+import fleschReadingScore from "./helpers/calculateFleschReadingScore";
 
 /**
  * The researcher contains all the researches, helpers, data, and config.
  */
-class Researcher extends AbstractResearcher {
+export default class Researcher extends AbstractResearcher {
   /**
    * Constructor
    * @param {Paper} paper The Paper object that is needed within the researches.
@@ -38,20 +31,19 @@ class Researcher extends AbstractResearcher {
     Object.assign(this.config, {
       language: 'es',
       passiveConstructionType: 'periphrastic',
-      firstWordExceptions: _firstWordExceptions.default,
-      functionWords: _functionWords.all,
-      stopWords: _stopWords.default,
-      transitionWords: _transitionWords.default,
-      twoPartTransitionWords: _twoPartTransitionWords.default,
-      syllables: _syllables.default,
-      sentenceLength: _sentenceLength.default
+      firstWordExceptions,
+      functionWords,
+      stopWords,
+      transitionWords,
+      twoPartTransitionWords,
+      syllables,
+      sentenceLength
     });
     Object.assign(this.helpers, {
-      getClauses: _getClauses.default,
-      getStemmer: _getStemmer.default,
-      fleschReadingScore: _calculateFleschReadingScore.default
+      getClauses,
+      getStemmer,
+      fleschReadingScore
     });
   }
 }
-exports.default = Researcher;
 //# sourceMappingURL=Researcher.js.map

package/build/languageProcessing/languages/es/Researcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"Researcher.js","names":["_index","require","_firstWordExceptions","_interopRequireDefault","_functionWords","_stopWords","_transitionWords","_twoPartTransitionWords","_syllables","_sentenceLength","_getClauses","_getStemmer","_calculateFleschReadingScore","e","__esModule","default","AbstractResearcher","languageProcessing","Researcher","constructor","paper","Object","assign","config","language","passiveConstructionType","firstWordExceptions","functionWords","stopWords","transitionWords","twoPartTransitionWords","syllables","sentenceLength","helpers","getClauses","getStemmer","fleschReadingScore","exports"],"sources":["../../../../src/languageProcessing/languages/es/Researcher.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport stopWords from './config/stopWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport syllables from './config/syllables.json';\nimport sentenceLength from './config/sentenceLength';\n\n// All helpers\nimport getClauses from './helpers/getClauses';\nimport getStemmer from './helpers/getStemmer';\nimport fleschReadingScore from './helpers/calculateFleschReadingScore';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    Object.assign(this.config, {\n      language: 'es',\n      passiveConstructionType: 'periphrastic',\n      firstWordExceptions,\n      functionWords,\n      stopWords,\n      transitionWords,\n      twoPartTransitionWords,\n      syllables,\n      sentenceLength\n    });\n\n    Object.assign(this.helpers, {\n      getClauses,\n      getStemmer,\n      fleschReadingScore\n    });\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAIA,IAAAC,oBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,gBAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,uBAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,UAAA,GAAAL,sBAAA,CAAAF,OAAA;AACA,IAAAQ,eAAA,GAAAN,sBAAA,CAAAF,OAAA;AAGA,IAAAS,WAAA,GAAAP,sBAAA,CAAAF,OAAA;AACA,IAAAU,WAAA,GAAAR,sBAAA,CAAAF,OAAA;AACA,IAAAW,4BAAA,GAAAT,sBAAA,CAAAF,OAAA;AAAuE,SAAAE,uBAAAU,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAdvE,MAAM;EAACG;AAAkB,CAAC,GAAGC,yBAAkB;;AAE/C;;AASA;;AAKA;AACA;AACA;AACe,MAAMC,UAAU,SAASF,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEG,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;IAEZC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,cAAc;MACvCC,mBAAmB,EAAnBA,4BAAmB;MACnBC,aAAa,EAAbA,kBAAa;MACbC,SAAS,EAATA,kBAAS;MACTC,eAAe,EAAfA,wBAAe;MACfC,sBAAsB,EAAtBA,+BAAsB;MACtBC,SAAS,EAATA,kBAAS;MACTC,cAAc,EAAdA;IACF,CAAC,CAAC;IAEFX,MAAM,CAACC,MAAM,CAAC,IAAI,CAACW,OAAO,EAAE;MAC1BC,UAAU,EAAVA,mBAAU;MACVC,UAAU,EAAVA,mBAAU;MACVC,kBAAkB,EAAlBA;IACF,CAAC,CAAC;EACJ;AACF;AAACC,OAAA,CAAAtB,OAAA,GAAAG,UAAA","ignoreList":[]}
+{"version":3,"file":"Researcher.js","names":["languageProcessing","AbstractResearcher","firstWordExceptions","all","functionWords","stopWords","transitionWords","twoPartTransitionWords","syllables","sentenceLength","getClauses","getStemmer","fleschReadingScore","Researcher","constructor","paper","Object","assign","config","language","passiveConstructionType","helpers"],"sources":["../../../../src/languageProcessing/languages/es/Researcher.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport stopWords from './config/stopWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport syllables from './config/syllables.json';\nimport sentenceLength from './config/sentenceLength';\n\n// All helpers\nimport getClauses from './helpers/getClauses';\nimport getStemmer from './helpers/getStemmer';\nimport fleschReadingScore from './helpers/calculateFleschReadingScore';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    Object.assign(this.config, {\n      language: 'es',\n      passiveConstructionType: 'periphrastic',\n      firstWordExceptions,\n      functionWords,\n      stopWords,\n      transitionWords,\n      twoPartTransitionWords,\n      syllables,\n      sentenceLength\n    });\n\n    Object.assign(this.helpers, {\n      getClauses,\n      getStemmer,\n      fleschReadingScore\n    });\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAkB,CAAC,GAAGD,kBAAkB;;AAE/C;AACA,OAAOE,mBAAmB;AAC1B,SAAQC,GAAG,IAAIC,aAAa;AAC5B,OAAOC,SAAS;AAChB,OAAOC,eAAe;AACtB,OAAOC,sBAAsB;AAC7B,OAAOC,SAAS;AAChB,OAAOC,cAAc;;AAErB;AACA,OAAOC,UAAU;AACjB,OAAOC,UAAU;AACjB,OAAOC,kBAAkB;;AAEzB;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASZ,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEa,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;IAEZC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,cAAc;MACvClB,mBAAmB;MACnBE,aAAa;MACbC,SAAS;MACTC,eAAe;MACfC,sBAAsB;MACtBC,SAAS;MACTC;IACF,CAAC,CAAC;IAEFO,MAAM,CAACC,MAAM,CAAC,IAAI,CAACI,OAAO,EAAE;MAC1BX,UAAU;MACVC,UAAU;MACVC;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

package/build/languageProcessing/languages/es/config/firstWordExceptions.js

@@ -1,14 +1,8 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
 /**
  * Returns an array with exceptions for the sentence beginning researcher.
  * @returns {Array} The array filled with exceptions.
  */
-var _default = exports.default = [
+export default [
 // Definite articles:
 "el", "los", "la", "las",
 // Indefinite articles:

package/build/languageProcessing/languages/es/config/firstWordExceptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"firstWordExceptions.js","names":["_default","exports","default"],"sources":["../../../../../src/languageProcessing/languages/es/config/firstWordExceptions.js"],"sourcesContent":["/**\n * Returns an array with exceptions for the sentence beginning researcher.\n * @returns {Array} The array filled with exceptions.\n */\nexport default [\n\t// Definite articles:\n\t\"el\", \"los\", \"la\", \"las\",\n\t// Indefinite articles:\n\t\"un\", \"una\", \"unas\", \"unos\",\n\t// Numbers 1-10:\n\t\"uno\", \"dos\", \"tres\", \"cuatro\", \"cinco\", \"seis\", \"siete\", \"ocho\", \"nueve\", \"diez\",\n\t// Demonstrative pronouns:\n\t\"este\", \"estos\", \"esta\", \"estas\", \"ese\", \"esos\", \"esa\", \"esas\", \"aquel\",\n\t\"aquellos\", \"aquella\", \"aquellas\", \"esto\", \"eso\", \"aquello\" ];\n\n\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AAHA,IAAAA,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAIe;AACd;AACA,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;AACxB;AACA,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;AAC3B;AACA,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;AACjF;AACA,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EACvE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAE","ignoreList":[]}
+{"version":3,"file":"firstWordExceptions.js","names":[],"sources":["../../../../../src/languageProcessing/languages/es/config/firstWordExceptions.js"],"sourcesContent":["/**\n * Returns an array with exceptions for the sentence beginning researcher.\n * @returns {Array} The array filled with exceptions.\n */\nexport default [\n\t// Definite articles:\n\t\"el\", \"los\", \"la\", \"las\",\n\t// Indefinite articles:\n\t\"un\", \"una\", \"unas\", \"unos\",\n\t// Numbers 1-10:\n\t\"uno\", \"dos\", \"tres\", \"cuatro\", \"cinco\", \"seis\", \"siete\", \"ocho\", \"nueve\", \"diez\",\n\t// Demonstrative pronouns:\n\t\"este\", \"estos\", \"esta\", \"estas\", \"ese\", \"esos\", \"esa\", \"esas\", \"aquel\",\n\t\"aquellos\", \"aquella\", \"aquellas\", \"esto\", \"eso\", \"aquello\" ];\n\n\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA,eAAe;AACd;AACA,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;AACxB;AACA,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;AAC3B;AACA,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;AACjF;AACA,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EACvE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAE","ignoreList":[]}

package/build/languageProcessing/languages/es/config/functionWords.js

@@ -1,12 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.filteredAtEnding = exports.filteredAtBeginningAndEnding = exports.filteredAtBeginning = exports.filteredAnywhere = exports.default = exports.cannotDirectlyPrecedePassiveParticiple = exports.cannotBeBetweenPassiveAuxiliaryAndParticiple = exports.all = void 0;
-var _transitionWords = require("./transitionWords.js");
-var _transformWordsWithHyphens = _interopRequireDefault(require("../../../helpers/transform/transformWordsWithHyphens"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { singleWords as transitionWords } from "./transitionWords.js";
+import transformWordsWithHyphens from "../../../helpers/transform/transformWordsWithHyphens";
+
 /**
  * Returns an array with exceptions for the prominent words researcher
  * @returns {Array} The array filled with exceptions.
@@ -80,26 +74,26 @@ const titlesPreceding = ["sra", "sras", "srta", "sr", "sres", "dra", "dr", "prof
 const titlesFollowing = ["jr", "sr"];
 
 // These word categories are filtered at the beginning of word combinations.
-const filteredAtBeginning = exports.filteredAtBeginning = (0, _transformWordsWithHyphens.default)(generalAdjectivesAdverbs);
+export const filteredAtBeginning = transformWordsWithHyphens(generalAdjectivesAdverbs);
 
 // These word categories are filtered at the ending of word combinations.
-const filteredAtEnding = exports.filteredAtEnding = (0, _transformWordsWithHyphens.default)([].concat(ordinalNumerals, otherAuxiliariesInfinitive, copulaEstarInfinitive, copulaSerInfinitive, delexicalizedVerbsInfinitive));
+export const filteredAtEnding = transformWordsWithHyphens([].concat(ordinalNumerals, otherAuxiliariesInfinitive, copulaEstarInfinitive, copulaSerInfinitive, delexicalizedVerbsInfinitive));
 
 // These word categories are filtered at the beginning and ending of word combinations.
-const filteredAtBeginningAndEnding = exports.filteredAtBeginningAndEnding = (0, _transformWordsWithHyphens.default)([].concat(articles, prepositions, coordinatingConjunctions, demonstrativePronouns, intensifiers, quantifiers, possessivePronouns));
+export const filteredAtBeginningAndEnding = transformWordsWithHyphens([].concat(articles, prepositions, coordinatingConjunctions, demonstrativePronouns, intensifiers, quantifiers, possessivePronouns));
 
 // These word categories are filtered everywhere within word combinations.
-const filteredAnywhere = exports.filteredAnywhere = (0, _transformWordsWithHyphens.default)([].concat(_transitionWords.singleWords, personalPronounsNominative, personalPronounsAccusative, personalPronounsPrepositional, personalPronounsComitative, interjections, cardinalNumerals, otherAuxiliaries, copulaEstar, copulaSer, interviewVerbs, delexicalizedVerbs, indefinitePronouns, correlativeConjunctions, subordinatingConjunctions, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs, locativeAdverbs, miscellaneous, prepositionalAdverbs, recipeWords, timeWords, vagueNouns));
+export const filteredAnywhere = transformWordsWithHyphens([].concat(transitionWords, personalPronounsNominative, personalPronounsAccusative, personalPronounsPrepositional, personalPronounsComitative, interjections, cardinalNumerals, otherAuxiliaries, copulaEstar, copulaSer, interviewVerbs, delexicalizedVerbs, indefinitePronouns, correlativeConjunctions, subordinatingConjunctions, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs, locativeAdverbs, miscellaneous, prepositionalAdverbs, recipeWords, timeWords, vagueNouns));
 
 // These word categories cannot directly precede a passive participle.
-const cannotDirectlyPrecedePassiveParticiple = exports.cannotDirectlyPrecedePassiveParticiple = (0, _transformWordsWithHyphens.default)([].concat(articles, prepositions, personalPronounsAccusative, possessivePronouns, indefinitePronouns, interrogativeProAdverbs, cardinalNumerals, ordinalNumerals, delexicalizedVerbs, delexicalizedVerbsInfinitive, interviewVerbs, interrogativeDeterminers, interrogativePronouns, personalPronounsComitative, personalPronounsPrepositional, prepositionalAdverbs));
+export const cannotDirectlyPrecedePassiveParticiple = transformWordsWithHyphens([].concat(articles, prepositions, personalPronounsAccusative, possessivePronouns, indefinitePronouns, interrogativeProAdverbs, cardinalNumerals, ordinalNumerals, delexicalizedVerbs, delexicalizedVerbsInfinitive, interviewVerbs, interrogativeDeterminers, interrogativePronouns, personalPronounsComitative, personalPronounsPrepositional, prepositionalAdverbs));
 
 // These word categories cannot intervene between an auxiliary and a corresponding passive participle.
-const cannotBeBetweenPassiveAuxiliaryAndParticiple = exports.cannotBeBetweenPassiveAuxiliaryAndParticiple = (0, _transformWordsWithHyphens.default)([].concat(copulaEstar, copulaEstarInfinitive));
+export const cannotBeBetweenPassiveAuxiliaryAndParticiple = transformWordsWithHyphens([].concat(copulaEstar, copulaEstarInfinitive));
 
 // This export contains all of the above words.
-const all = exports.all = (0, _transformWordsWithHyphens.default)([].concat(articles, cardinalNumerals, ordinalNumerals, demonstrativePronouns, possessivePronouns, personalPronounsNominative, personalPronounsComitative, personalPronounsPrepositional, personalPronounsAccusative, quantifiers, indefinitePronouns, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs, locativeAdverbs, prepositionalAdverbs, otherAuxiliaries, otherAuxiliariesInfinitive, copulaEstar, copulaSer, copulaEstarInfinitive, copulaSerInfinitive, prepositions, coordinatingConjunctions, correlativeConjunctions, subordinatingConjunctions, interviewVerbs, _transitionWords.singleWords, additionalTransitionWords, intensifiers, delexicalizedVerbs, delexicalizedVerbsInfinitive, interjections, generalAdjectivesAdverbs, recipeWords, vagueNouns, miscellaneous, timeWords, titlesPreceding, titlesFollowing));
-var _default = exports.default = {
+export const all = transformWordsWithHyphens([].concat(articles, cardinalNumerals, ordinalNumerals, demonstrativePronouns, possessivePronouns, personalPronounsNominative, personalPronounsComitative, personalPronounsPrepositional, personalPronounsAccusative, quantifiers, indefinitePronouns, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs, locativeAdverbs, prepositionalAdverbs, otherAuxiliaries, otherAuxiliariesInfinitive, copulaEstar, copulaSer, copulaEstarInfinitive, copulaSerInfinitive, prepositions, coordinatingConjunctions, correlativeConjunctions, subordinatingConjunctions, interviewVerbs, transitionWords, additionalTransitionWords, intensifiers, delexicalizedVerbs, delexicalizedVerbsInfinitive, interjections, generalAdjectivesAdverbs, recipeWords, vagueNouns, miscellaneous, timeWords, titlesPreceding, titlesFollowing));
+export default {
   filteredAtBeginning,
   filteredAtEnding,
   filteredAtBeginningAndEnding,