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

package/build/languageProcessing/languages/en/config/wordComplexity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordComplexity.js","names":["_default","exports","default","wordLength","doesUpperCaseDecreaseComplexity"],"sources":["../../../../../src/languageProcessing/languages/en/config/wordComplexity.js"],"sourcesContent":["// This is a config for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.\nexport default {\n\twordLength: 7,\n\tdoesUpperCaseDecreaseComplexity: true,\n};\n"],"mappings":";;;;;;AAAA;AAAA,IAAAA,QAAA,GAAAC,OAAA,CAAAC,OAAA,GACe;EACdC,UAAU,EAAE,CAAC;EACbC,+BAA+B,EAAE;AAClC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = calculateScore;
+var _index = require("../../../../index.js");
+const {
+  formatNumber
+} = _index.helpers;
+
+/**
+ * Returns the Flesch reading score for English.
+ *
+ * @param {Object} statistics The Flesch reading statistics.
+ *
+ * @returns {number} The Flesch reading score for English.
+ */
+function calculateScore(statistics) {
+  const score = 206.835 - 1.015 * statistics.averageWordsPerSentence - 84.6 * (statistics.numberOfSyllables / statistics.numberOfWords);
+  return formatNumber(score);
+}
+//# sourceMappingURL=calculateFleschReadingScore.js.map

package/build/languageProcessing/languages/en/helpers/calculateFleschReadingScore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateFleschReadingScore.js","names":["_index","require","formatNumber","helpers","calculateScore","statistics","score","averageWordsPerSentence","numberOfSyllables","numberOfWords"],"sources":["../../../../../src/languageProcessing/languages/en/helpers/calculateFleschReadingScore.js"],"sourcesContent":["import {helpers} from '@axyseo/index.js';\nconst {formatNumber} = helpers;\n\n/**\n * Returns the Flesch reading score for English.\n *\n * @param {Object} statistics The Flesch reading statistics.\n *\n * @returns {number} The Flesch reading score for English.\n */\nexport default function calculateScore(statistics) {\n  const score =\n    206.835 -\n    1.015 * statistics.averageWordsPerSentence -\n    84.6 * (statistics.numberOfSyllables / statistics.numberOfWords);\n\n  return formatNumber(score);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,MAAM;EAACC;AAAY,CAAC,GAAGC,cAAO;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GACT,OAAO,GACP,KAAK,GAAGD,UAAU,CAACE,uBAAuB,GAC1C,IAAI,IAAIF,UAAU,CAACG,iBAAiB,GAAGH,UAAU,CAACI,aAAa,CAAC;EAElE,OAAOP,YAAY,CAACI,KAAK,CAAC;AAC5B","ignoreList":[]}

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = checkIfWordIsComplex;
+var _buildFormRule = _interopRequireDefault(require("../../../helpers/morphology/buildFormRule"));
+var _createRulesFromArrays = _interopRequireDefault(require("../../../helpers/morphology/createRulesFromArrays"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Checks if a word is complex.
+ * This is a helper for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
+ *
+ * @param {object} config The configuration needed for assessing the word's complexity, e.g., the frequency list.
+ * @param {string} word The word to check.
+ * @param {object}	premiumData The object that contains data for the assessment including the frequency list.
+ *
+ * @returns {boolean} Whether or not a word is complex.
+ */
+function checkIfWordIsComplex(config, word, premiumData) {
+  const lengthLimit = config.wordLength;
+  const frequencyList = premiumData.frequencyList.list;
+
+  // Whether uppercased beginning of a word decreases its complexity.
+  const doesUpperCaseDecreaseComplexity = config.doesUpperCaseDecreaseComplexity;
+
+  // The word is not complex if it's less than or the same as the length limit, i.e. 7 characters for English.
+  if (word.length <= lengthLimit) {
+    return false;
+  }
+
+  // The word is not complex if it starts with a capital and thus is assumed to be a named entity.
+  if (doesUpperCaseDecreaseComplexity && word[0].toLowerCase() !== word[0]) {
+    return false;
+  }
+
+  // The word is not complex if it's in the frequency list.
+  if (frequencyList.includes(word)) {
+    return false;
+  }
+
+  // The word is not complex if its singular form is in the frequency list.
+  if (premiumData) {
+    const singular = (0, _buildFormRule.default)(word, (0, _createRulesFromArrays.default)(premiumData.nouns.regexNoun.singularize));
+    return !frequencyList.includes(singular);
+  }
+  return true;
+}
+//# sourceMappingURL=checkIfWordIsComplex.js.map

package/build/languageProcessing/languages/en/helpers/checkIfWordIsComplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkIfWordIsComplex.js","names":["_buildFormRule","_interopRequireDefault","require","_createRulesFromArrays","e","__esModule","default","checkIfWordIsComplex","config","word","premiumData","lengthLimit","wordLength","frequencyList","list","doesUpperCaseDecreaseComplexity","length","toLowerCase","includes","singular","buildFormRule","createRulesFromArrays","nouns","regexNoun","singularize"],"sources":["../../../../../src/languageProcessing/languages/en/helpers/checkIfWordIsComplex.js"],"sourcesContent":["import buildFormRule from \"../../../helpers/morphology/buildFormRule\";\nimport createRulesFromArrays from \"../../../helpers/morphology/createRulesFromArrays\";\n\n/**\n * Checks if a word is complex.\n * This is a helper for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.\n *\n * @param {object} config The configuration needed for assessing the word's complexity, e.g., the frequency list.\n * @param {string} word The word to check.\n * @param {object}\tpremiumData The object that contains data for the assessment including the frequency list.\n *\n * @returns {boolean} Whether or not a word is complex.\n */\nexport default function checkIfWordIsComplex( config, word, premiumData ) {\n\tconst lengthLimit = config.wordLength;\n\tconst frequencyList = premiumData.frequencyList.list;\n\n\t// Whether uppercased beginning of a word decreases its complexity.\n\tconst doesUpperCaseDecreaseComplexity = config.doesUpperCaseDecreaseComplexity;\n\n\t// The word is not complex if it's less than or the same as the length limit, i.e. 7 characters for English.\n\tif ( word.length <= lengthLimit ) {\n\t\treturn false;\n\t}\n\n\t// The word is not complex if it starts with a capital and thus is assumed to be a named entity.\n\tif ( doesUpperCaseDecreaseComplexity && word[ 0 ].toLowerCase() !== word[ 0 ] ) {\n\t\treturn false;\n\t}\n\n\t// The word is not complex if it's in the frequency list.\n\tif ( frequencyList.includes( word ) ) {\n\t\treturn false;\n\t}\n\n\t// The word is not complex if its singular form is in the frequency list.\n\tif ( premiumData ) {\n\t\tconst singular = buildFormRule( word, createRulesFromArrays( premiumData.nouns.regexNoun.singularize ) );\n\t\treturn ! frequencyList.includes( singular );\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,cAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAF,sBAAA,CAAAC,OAAA;AAAsF,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASG,oBAAoBA,CAAEC,MAAM,EAAEC,IAAI,EAAEC,WAAW,EAAG;EACzE,MAAMC,WAAW,GAAGH,MAAM,CAACI,UAAU;EACrC,MAAMC,aAAa,GAAGH,WAAW,CAACG,aAAa,CAACC,IAAI;;EAEpD;EACA,MAAMC,+BAA+B,GAAGP,MAAM,CAACO,+BAA+B;;EAE9E;EACA,IAAKN,IAAI,CAACO,MAAM,IAAIL,WAAW,EAAG;IACjC,OAAO,KAAK;EACb;;EAEA;EACA,IAAKI,+BAA+B,IAAIN,IAAI,CAAE,CAAC,CAAE,CAACQ,WAAW,CAAC,CAAC,KAAKR,IAAI,CAAE,CAAC,CAAE,EAAG;IAC/E,OAAO,KAAK;EACb;;EAEA;EACA,IAAKI,aAAa,CAACK,QAAQ,CAAET,IAAK,CAAC,EAAG;IACrC,OAAO,KAAK;EACb;;EAEA;EACA,IAAKC,WAAW,EAAG;IAClB,MAAMS,QAAQ,GAAG,IAAAC,sBAAa,EAAEX,IAAI,EAAE,IAAAY,8BAAqB,EAAEX,WAAW,CAACY,KAAK,CAACC,SAAS,CAACC,WAAY,CAAE,CAAC;IACxG,OAAO,CAAEX,aAAa,CAACK,QAAQ,CAAEC,QAAS,CAAC;EAC5C;EAEA,OAAO,IAAI;AACZ","ignoreList":[]}

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

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

package/build/languageProcessing/languages/en/helpers/getClauses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClauses.js","names":["_index","require","_Clause","_interopRequireDefault","_passiveVoiceAuxiliaries","_stopWords","_lodash","_stripSpaces","_indices","e","__esModule","default","createRegexFromArray","getClauses","languageProcessing","options","Clause","stopwords","auxiliaries","ingExclusions","regexes","auxiliaryRegex","stopCharacterRegex","verbEndingInIngRegex","otherStopWordIndices","getVerbsEndingInIngIndices","sentence","matches","match","filter","includes","stripSpaces","getIndicesOfList","getEnglishClauses"],"sources":["../../../../../src/languageProcessing/languages/en/helpers/getClauses.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {createRegexFromArray, getClauses} = languageProcessing;\n\nimport Clause from '../values/Clause';\nimport auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';\nimport stopwords from '../config/stopWords.js';\nimport {includes} from 'lodash';\nimport stripSpaces from '../../../helpers/sanitize/stripSpaces';\nimport {getIndicesByWordList as getIndicesOfList} from '../../../helpers/word/indices';\n\nconst options = {\n  Clause,\n  stopwords,\n  auxiliaries: auxiliaries,\n  ingExclusions: ['king', 'cling', 'ring', 'being', 'thing', 'something', 'anything'],\n  regexes: {\n    auxiliaryRegex: createRegexFromArray(auxiliaries),\n    stopCharacterRegex: /([:,]|('ll)|('ve))(?=[ \\n\\r\\t'\"+\\-»«‹›<>])/gi,\n    verbEndingInIngRegex: /\\w+ing(?=$|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi\n  },\n  otherStopWordIndices: []\n};\n\n/**\n * Gets active verbs (ending in ing) to determine sentence breakers in English.\n *\n * @param {string} sentence The sentence to get the active verbs from.\n *\n * @returns {Array} The array with valid matches.\n */\nconst getVerbsEndingInIngIndices = function(sentence) {\n  // Matches the sentences with words ending in ing.\n  let matches = sentence.match(options.regexes.verbEndingInIngRegex) || [];\n  // Filters out words ending in -ing that aren't verbs.\n  matches = matches.filter(match => !includes(options.ingExclusions, stripSpaces(match)));\n  return getIndicesOfList(matches, sentence);\n};\n\n/**\n * Gets the clauses from a sentence by determining sentence breakers.\n *\n * @param {string} sentence The sentence to split up in clauses.\n *\n * @returns {Array} The array with all clauses that have an auxiliary.\n */\nexport default function getEnglishClauses(sentence) {\n  options.otherStopWordIndices = getVerbsEndingInIngIndices(sentence);\n  return getClauses(sentence, options);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,wBAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,UAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,YAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,QAAA,GAAAP,OAAA;AAAuF,SAAAE,uBAAAM,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAPvF,MAAM;EAACG,oBAAoB;EAAEC;AAAU,CAAC,GAAGC,yBAAkB;AAS7D,MAAMC,OAAO,GAAG;EACdC,MAAM,EAANA,eAAM;EACNC,SAAS,EAATA,kBAAS;EACTC,WAAW,EAAEA,gCAAW;EACxBC,aAAa,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;EACnFC,OAAO,EAAE;IACPC,cAAc,EAAET,oBAAoB,CAACM,gCAAW,CAAC;IACjDI,kBAAkB,EAAE,8CAA8C;IAClEC,oBAAoB,EAAE;EACxB,CAAC;EACDC,oBAAoB,EAAE;AACxB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,0BAA0B,GAAG,SAAAA,CAASC,QAAQ,EAAE;EACpD;EACA,IAAIC,OAAO,GAAGD,QAAQ,CAACE,KAAK,CAACb,OAAO,CAACK,OAAO,CAACG,oBAAoB,CAAC,IAAI,EAAE;EACxE;EACAI,OAAO,GAAGA,OAAO,CAACE,MAAM,CAACD,KAAK,IAAI,CAAC,IAAAE,gBAAQ,EAACf,OAAO,CAACI,aAAa,EAAE,IAAAY,oBAAW,EAACH,KAAK,CAAC,CAAC,CAAC;EACvF,OAAO,IAAAI,6BAAgB,EAACL,OAAO,EAAED,QAAQ,CAAC;AAC5C,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASO,iBAAiBA,CAACP,QAAQ,EAAE;EAClDX,OAAO,CAACS,oBAAoB,GAAGC,0BAA0B,CAACC,QAAQ,CAAC;EACnE,OAAOb,UAAU,CAACa,QAAQ,EAAEX,OAAO,CAAC;AACtC","ignoreList":[]}

package/build/languageProcessing/languages/en/helpers/getStemmer.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getStemmer;
+var _lodash = require("lodash");
+var _index = require("../../../../index.js");
+var _determineStem = _interopRequireDefault(require("./internal/determineStem"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  baseStemmer
+} = _index.languageProcessing;
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+function getStemmer(researcher) {
+  const morphologyData = (0, _lodash.get)(researcher.getData('morphology'), 'en', false);
+  if (morphologyData) {
+    return word => (0, _determineStem.default)(word, morphologyData);
+  }
+  return baseStemmer;
+}
+//# sourceMappingURL=getStemmer.js.map

package/build/languageProcessing/languages/en/helpers/getStemmer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStemmer.js","names":["_lodash","require","_index","_determineStem","_interopRequireDefault","e","__esModule","default","baseStemmer","languageProcessing","getStemmer","researcher","morphologyData","get","getData","word","determineStem"],"sources":["../../../../../src/languageProcessing/languages/en/helpers/getStemmer.js"],"sourcesContent":["import {get} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {baseStemmer} = languageProcessing;\n\nimport determineStem from './internal/determineStem';\n\n/**\n * Returns the stemmer for a researcher.\n *\n * @param {Researcher} researcher The researcher.\n *\n * @returns {Function} The stemmer.\n */\nexport default function getStemmer(researcher) {\n  const morphologyData = get(researcher.getData('morphology'), 'en', false);\n\n  if (morphologyData) {\n    return word => determineStem(word, morphologyData);\n  }\n\n  return baseStemmer;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,cAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAqD,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAFrD,MAAM;EAACG;AAAW,CAAC,GAAGC,yBAAkB;AAIxC;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,UAAUA,CAACC,UAAU,EAAE;EAC7C,MAAMC,cAAc,GAAG,IAAAC,WAAG,EAACF,UAAU,CAACG,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;EAEzE,IAAIF,cAAc,EAAE;IAClB,OAAOG,IAAI,IAAI,IAAAC,sBAAa,EAACD,IAAI,EAAEH,cAAc,CAAC;EACpD;EAEA,OAAOJ,WAAW;AACpB","ignoreList":[]}

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

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

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

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

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

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

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

@@ -0,0 +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 '@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

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

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

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