axyseo 2.0.0-alpha.1

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

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

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,68 @@
+"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 }; }
+const {
+  precedenceException,
+  directPrecedenceException,
+  values
+} = _index.languageProcessing;
+const Clause = values.Clause;
+
+/**
+ * Creates a Clause object for the English language.
+ */
+class EnglishClause extends Clause {
+  /**
+   * Constructor.
+   *
+   * @param {string} clauseText   The text of the clause.
+   * @param {Array} auxiliaries   The auxiliaries.
+   *
+   * @constructor
+   */
+  constructor(clauseText, auxiliaries) {
+    super(clauseText, auxiliaries);
+    this._participles = (0, _getParticiples.default)(this.getClauseText());
+    this.checkParticiples();
+  }
+
+  /**
+   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
+   * If no exceptions are found, the clause is passive.
+   *
+   * @returns {boolean} Returns true if no exception is found.
+   */
+  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));
+    this.setPassive(passiveParticiples.length > 0);
+  }
+
+  /**
+   * Checks whether the participle is 'rid' in combination with 'get', 'gets', 'getting', 'got' or 'gotten'.
+   * If this is true, the participle is not passive.
+   *
+   * @param {string} participle   The participle
+   *
+   * @returns {boolean} Returns true if 'rid' is found in combination with a form of 'get'
+   * otherwise returns false.
+   */
+  hasRidException(participle) {
+    if (participle === 'rid') {
+      const irregularExclusionArray = ['get', 'gets', 'getting', 'got', 'gotten'];
+      return !(0, _lodash.isEmpty)((0, _lodash.intersection)(irregularExclusionArray, this.getAuxiliaries()));
+    }
+    return false;
+  }
+}
+var _default = exports.default = EnglishClause;
+//# sourceMappingURL=Clause.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,57 @@
+"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 }; }
+const {
+  AbstractResearcher
+} = _index.languageProcessing;
+
+// All config
+
+// All helpers
+
+/**
+ * The researcher contains all the researches, helpers, data, and config.
+ */
+class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+    Object.assign(this.config, {
+      language: 'es',
+      passiveConstructionType: 'periphrastic',
+      firstWordExceptions: _firstWordExceptions.default,
+      functionWords: _functionWords.all,
+      stopWords: _stopWords.default,
+      transitionWords: _transitionWords.default,
+      twoPartTransitionWords: _twoPartTransitionWords.default,
+      syllables: _syllables.default,
+      sentenceLength: _sentenceLength.default
+    });
+    Object.assign(this.helpers, {
+      getClauses: _getClauses.default,
+      getStemmer: _getStemmer.default,
+      fleschReadingScore: _calculateFleschReadingScore.default
+    });
+  }
+}
+exports.default = Researcher;
+//# sourceMappingURL=Researcher.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,20 @@
+"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 = [
+// Definite articles:
+"el", "los", "la", "las",
+// Indefinite articles:
+"un", "una", "unas", "unos",
+// Numbers 1-10:
+"uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez",
+// Demonstrative pronouns:
+"este", "estos", "esta", "estas", "ese", "esos", "esa", "esas", "aquel", "aquellos", "aquella", "aquellas", "esto", "eso", "aquello"];
+//# sourceMappingURL=firstWordExceptions.js.map

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

@@ -0,0 +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":[]}