axyseo 2.0.0-alpha.0.0.37 → 2.0.0-alpha.0.0.39

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

@@ -0,0 +1 @@
+{"version":3,"file":"transitionWords.js","names":["singleWords","multipleWords","allWords","concat"],"sources":["../../../../../src/languageProcessing/languages/en/config/transitionWords.js"],"sourcesContent":["/** @module config/transitionWords */\n\nexport const singleWords = [ \"accordingly\", \"additionally\", \"afterward\", \"afterwards\", \"albeit\", \"also\", \"although\", \"altogether\",\n\t\"another\", \"basically\", \"because\", \"before\", \"besides\", \"but\", \"certainly\", \"chiefly\", \"comparatively\",\n\t\"concurrently\", \"consequently\", \"contrarily\", \"conversely\", \"correspondingly\", \"despite\", \"doubtedly\", \"during\",\n\t\"e.g.\", \"earlier\", \"emphatically\", \"equally\", \"especially\", \"eventually\", \"evidently\", \"explicitly\", \"finally\",\n\t\"firstly\", \"following\", \"formerly\", \"forthwith\", \"fourthly\", \"further\", \"furthermore\", \"generally\", \"hence\",\n\t\"henceforth\", \"however\", \"i.e.\", \"identically\", \"indeed\", \"initially\", \"instead\", \"last\", \"lastly\", \"later\", \"lest\",\n\t\"likewise\", \"markedly\", \"meanwhile\", \"moreover\", \"nevertheless\", \"nonetheless\", \"nor\",  \"notwithstanding\", \"obviously\",\n\t\"occasionally\", \"otherwise\", \"overall\", \"particularly\", \"presently\", \"previously\", \"rather\", \"regardless\", \"secondly\",\n\t\"shortly\", \"significantly\", \"similarly\", \"simultaneously\", \"since\", \"so\", \"soon\", \"specifically\", \"still\", \"straightaway\",\n\t\"subsequently\", \"surely\", \"surprisingly\", \"than\", \"then\", \"thereafter\", \"therefore\", \"thereupon\", \"thirdly\", \"though\",\n\t\"thus\", \"till\", \"undeniably\", \"undoubtedly\", \"unless\", \"unlike\", \"unquestionably\", \"until\", \"when\", \"whenever\",\n\t\"whereas\", \"while\", \"whether\", \"if\", \"actually\", \"anyway\", \"anyways\", \"anyhow\", \"mostly\", \"namely\", \"including\", \"suddenly\" ];\nexport const multipleWords = [ \"above all\", \"after all\", \"after that\", \"all in all\", \"all of a sudden\", \"all things considered\",\n\t\"analogous to\", \"although this may be true\", \"analogous to\", \"another key point\", \"as a matter of fact\", \"as a result\",\n\t\"as an illustration\", \"as can be seen\", \"as has been noted\", \"as I have noted\", \"as I have said\", \"as I have shown\",\n\t\"as long as\", \"as much as\", \"as opposed to\", \"as shown above\", \"as soon as\", \"as well as\", \"at any rate\", \"at first\", \"at last\",\n\t\"at least\", \"at length\", \"at the present time\", \"at the same time\", \"at this instant\", \"at this point\", \"at this time\",\n\t\"balanced against\", \"being that\", \"by all means\", \"by and large\", \"by comparison\", \"by the same token\", \"by the time\",\n\t\"compared to\", \"be that as it may\", \"coupled with\", \"different from\", \"due to\", \"equally important\", \"even if\",\n\t\"even more\", \"even so\", \"even though\", \"first thing to remember\", \"for example\", \"for fear that\", \"for instance\",\n\t\"for one thing\", \"for that reason\", \"for the most part\", \"for the purpose of\", \"for the same reason\", \"for this purpose\",\n\t\"for this reason\", \"from time to time\", \"given that\", \"given these points\", \"important to realize\", \"in a word\", \"in addition\",\n\t\"in another case\", \"in any case\", \"in any event\", \"in brief\", \"in case\", \"in conclusion\", \"in contrast\",\n\t\"in detail\", \"in due time\", \"in effect\", \"in either case\", \"either way\", \"in essence\", \"in fact\", \"in general\", \"in light of\",\n\t\"in like fashion\", \"in like manner\", \"in order that\", \"in order to\", \"in other words\", \"in particular\", \"in reality\",\n\t\"in short\", \"in similar fashion\", \"in spite of\", \"in sum\", \"in summary\", \"in that case\", \"in the event that\",\n\t\"in the final analysis\", \"in the first place\", \"in the fourth place\", \"in the hope that\", \"in the light of\",\n\t\"in the long run\", \"in the meantime\", \"in the same fashion\", \"in the same way\", \"in the second place\",\n\t\"in the third place\", \"in this case\", \"in this situation\", \"in time\", \"in truth\", \"in view of\", \"inasmuch as\",\n\t\"most compelling evidence\", \"most important\", \"must be remembered\", \"not only\", \"not to mention\", \"note that\",\n\t\"now that\", \"of course\", \"on account of\", \"on balance\", \"on condition that\", \"on one hand\", \"on the condition that\", \"on the contrary\",\n\t\"on the negative side\", \"on the other hand\", \"on the positive side\", \"on the whole\", \"on this occasion\", \"all at once\",\n\t\"once in a while\", \t\"only if\", \"owing to\", \"point often overlooked\", \"prior to\", \"provided that\", \"seeing that\",\n\t\"so as to\", \"so far\", \"so long as\", \"so that\", \"sooner or later\", \"such as\", \"summing up\", \"take the case of\",\n\t\"that is\", \"that is to say\", \"then again\", \"this time\", \"to be sure\", \"to begin with\", \"to clarify\", \"to conclude\",\n\t\"to demonstrate\", \"to emphasize\", \"to enumerate\", \"to explain\", \"to illustrate\", \"to list\", \"to point out\",\n\t\"to put it another way\", \"to put it differently\", \"to repeat\", \"to rephrase it\", \"to say nothing of\", \"to sum up\",\n\t\"to summarize\", \"to that end\", \"to the end that\", \"to this end\", \"together with\", \"under those circumstances\", \"until now\",\n\t\"up against\", \"up to the present time\", \"vis a vis\", \"what's more\", \"what is more\", \"while it may be true\", \"while this may be true\",\n\t\"with attention to\", \"with the result that\", \"with this in mind\", \"with this intention\", \"with this purpose in mind\",\n\t\"without a doubt\", \"without delay\", \"without doubt\", \"without reservation\", \"according to\", \"no sooner\", \"at most\", \"at the most\",\n\t\"from now on\" ];\n\nexport const allWords = singleWords.concat( multipleWords );\n\nexport default allWords;\n"],"mappings":"AAAA;;AAEA,OAAO,MAAMA,WAAW,GAAG,CAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAChI,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe,EACtG,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAC/G,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAC9G,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,EAC3G,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EACnH,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,EAAG,iBAAiB,EAAE,WAAW,EACtH,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EACrH,SAAS,EAAE,eAAe,EAAE,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EACzH,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EACrH,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAC9G,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAE;AAC9H,OAAO,MAAMC,aAAa,GAAG,CAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,uBAAuB,EAC9H,cAAc,EAAE,2BAA2B,EAAE,cAAc,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,aAAa,EACtH,oBAAoB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,iBAAiB,EACnH,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAC/H,UAAU,EAAE,WAAW,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EACtH,kBAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EACrH,aAAa,EAAE,mBAAmB,EAAE,cAAc,EAAE,gBAAgB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,SAAS,EAC9G,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,yBAAyB,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAChH,eAAe,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,kBAAkB,EACxH,iBAAiB,EAAE,mBAAmB,EAAE,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,WAAW,EAAE,aAAa,EAC9H,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EACvG,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAC7H,iBAAiB,EAAE,gBAAgB,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,YAAY,EACpH,UAAU,EAAE,oBAAoB,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAC5G,uBAAuB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,iBAAiB,EAC3G,iBAAiB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,qBAAqB,EACrG,oBAAoB,EAAE,cAAc,EAAE,mBAAmB,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAC7G,0BAA0B,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,UAAU,EAAE,gBAAgB,EAAE,WAAW,EAC7G,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,uBAAuB,EAAE,iBAAiB,EACtI,sBAAsB,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,cAAc,EAAE,kBAAkB,EAAE,aAAa,EACtH,iBAAiB,EAAG,SAAS,EAAE,UAAU,EAAE,wBAAwB,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAC/G,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,kBAAkB,EAC7G,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,aAAa,EAClH,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,cAAc,EAC1G,uBAAuB,EAAE,uBAAuB,EAAE,WAAW,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,WAAW,EACjH,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,2BAA2B,EAAE,WAAW,EAC1H,YAAY,EAAE,wBAAwB,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,sBAAsB,EAAE,wBAAwB,EACpI,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,2BAA2B,EACpH,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,qBAAqB,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EACjI,aAAa,CAAE;AAEhB,OAAO,MAAMC,QAAQ,GAAGF,WAAW,CAACG,MAAM,CAAEF,aAAc,CAAC;AAE3D,eAAeC,QAAQ","ignoreList":[]}

package/build/languageProcessing/languages/en/config/twoPartTransitionWords.js

@@ -0,0 +1,8 @@
+/** @module config/twoPartTransitionWords */
+
+/**
+ * Returns an array with two-part transition words to be used by the assessments.
+ * @type {Array} The array filled with two-part transition words.
+ */
+export default [["both", "and"], ["not only", "but also"], ["neither", "nor"], ["either", "or"], ["not", "but"]];
+//# sourceMappingURL=twoPartTransitionWords.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"twoPartTransitionWords.js","names":[],"sources":["../../../../../src/languageProcessing/languages/en/config/twoPartTransitionWords.js"],"sourcesContent":["/** @module config/twoPartTransitionWords */\n\n/**\n * Returns an array with two-part transition words to be used by the assessments.\n * @type {Array} The array filled with two-part transition words.\n */\nexport default [ [ \"both\", \"and\" ], [ \"not only\", \"but also\" ], [ \"neither\", \"nor\" ], [ \"either\", \"or\" ], [ \"not\", \"but\" ] ];\n"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA,eAAe,CAAE,CAAE,MAAM,EAAE,KAAK,CAAE,EAAE,CAAE,UAAU,EAAE,UAAU,CAAE,EAAE,CAAE,SAAS,EAAE,KAAK,CAAE,EAAE,CAAE,QAAQ,EAAE,IAAI,CAAE,EAAE,CAAE,KAAK,EAAE,KAAK,CAAE,CAAE","ignoreList":[]}

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

@@ -0,0 +1,6 @@
+// This is a config for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
+export default {
+  wordLength: 7,
+  doesUpperCaseDecreaseComplexity: true
+};
+//# sourceMappingURL=wordComplexity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wordComplexity.js","names":["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;AACA,eAAe;EACdA,UAAU,EAAE,CAAC;EACbC,+BAA+B,EAAE;AAClC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,17 @@
+import { helpers } from "../../../../index.js";
+const {
+  formatNumber
+} = helpers;
+
+/**
+ * Returns the Flesch reading score for English.
+ *
+ * @param {Object} statistics The Flesch reading statistics.
+ *
+ * @returns {number} The Flesch reading score for English.
+ */
+export default 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":["helpers","formatNumber","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,SAAQA,OAAO;AACf,MAAM;EAACC;AAAY,CAAC,GAAGD,OAAO;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASE,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,OAAON,YAAY,CAACG,KAAK,CAAC;AAC5B","ignoreList":[]}

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

@@ -0,0 +1,43 @@
+import buildFormRule from "../../../helpers/morphology/buildFormRule";
+import createRulesFromArrays from "../../../helpers/morphology/createRulesFromArrays";
+
+/**
+ * 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.
+ */
+export default 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 = buildFormRule(word, createRulesFromArrays(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","createRulesFromArrays","checkIfWordIsComplex","config","word","premiumData","lengthLimit","wordLength","frequencyList","list","doesUpperCaseDecreaseComplexity","length","toLowerCase","includes","singular","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,OAAOA,aAAa;AACpB,OAAOC,qBAAqB;;AAE5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,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,GAAGd,aAAa,CAAEI,IAAI,EAAEH,qBAAqB,CAAEI,WAAW,CAACU,KAAK,CAACC,SAAS,CAACC,WAAY,CAAE,CAAC;IACxG,OAAO,CAAET,aAAa,CAACK,QAAQ,CAAEC,QAAS,CAAC;EAC5C;EAEA,OAAO,IAAI;AACZ","ignoreList":[]}

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

@@ -0,0 +1,51 @@
+import { languageProcessing } from "../../../../index.js";
+const {
+  createRegexFromArray,
+  getClauses
+} = languageProcessing;
+import Clause from "../values/Clause";
+import auxiliaries from "../config/internal/passiveVoiceAuxiliaries.js";
+import stopwords from "../config/stopWords.js";
+import { includes } from 'lodash';
+import stripSpaces from "../../../helpers/sanitize/stripSpaces";
+import { getIndicesByWordList as getIndicesOfList } from "../../../helpers/word/indices";
+const options = {
+  Clause,
+  stopwords,
+  auxiliaries: auxiliaries,
+  ingExclusions: ['king', 'cling', 'ring', 'being', 'thing', 'something', 'anything'],
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    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 => !includes(options.ingExclusions, stripSpaces(match)));
+  return getIndicesOfList(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.
+ */
+export default 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":["languageProcessing","createRegexFromArray","getClauses","Clause","auxiliaries","stopwords","includes","stripSpaces","getIndicesByWordList","getIndicesOfList","options","ingExclusions","regexes","auxiliaryRegex","stopCharacterRegex","verbEndingInIngRegex","otherStopWordIndices","getVerbsEndingInIngIndices","sentence","matches","match","filter","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,SAAQA,kBAAkB;AAC1B,MAAM;EAACC,oBAAoB;EAAEC;AAAU,CAAC,GAAGF,kBAAkB;AAE7D,OAAOG,MAAM;AACb,OAAOC,WAAW;AAClB,OAAOC,SAAS;AAChB,SAAQC,QAAQ,QAAO,QAAQ;AAC/B,OAAOC,WAAW;AAClB,SAAQC,oBAAoB,IAAIC,gBAAgB;AAEhD,MAAMC,OAAO,GAAG;EACdP,MAAM;EACNE,SAAS;EACTD,WAAW,EAAEA,WAAW;EACxBO,aAAa,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;EACnFC,OAAO,EAAE;IACPC,cAAc,EAAEZ,oBAAoB,CAACG,WAAW,CAAC;IACjDU,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,CAACV,OAAO,CAACE,OAAO,CAACG,oBAAoB,CAAC,IAAI,EAAE;EACxE;EACAI,OAAO,GAAGA,OAAO,CAACE,MAAM,CAACD,KAAK,IAAI,CAACd,QAAQ,CAACI,OAAO,CAACC,aAAa,EAAEJ,WAAW,CAACa,KAAK,CAAC,CAAC,CAAC;EACvF,OAAOX,gBAAgB,CAACU,OAAO,EAAED,QAAQ,CAAC;AAC5C,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASI,iBAAiBA,CAACJ,QAAQ,EAAE;EAClDR,OAAO,CAACM,oBAAoB,GAAGC,0BAA0B,CAACC,QAAQ,CAAC;EACnE,OAAOhB,UAAU,CAACgB,QAAQ,EAAER,OAAO,CAAC;AACtC","ignoreList":[]}

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

@@ -0,0 +1,22 @@
+import { get } from 'lodash';
+import { languageProcessing } from "../../../../index.js";
+const {
+  baseStemmer
+} = languageProcessing;
+import determineStem from "./internal/determineStem";
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer(researcher) {
+  const morphologyData = get(researcher.getData('morphology'), 'en', false);
+  if (morphologyData) {
+    return word => determineStem(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":["get","languageProcessing","baseStemmer","determineStem","getStemmer","researcher","morphologyData","getData","word"],"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,SAAQA,GAAG,QAAO,QAAQ;AAC1B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC;AAAW,CAAC,GAAGD,kBAAkB;AAExC,OAAOE,aAAa;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,UAAUA,CAACC,UAAU,EAAE;EAC7C,MAAMC,cAAc,GAAGN,GAAG,CAACK,UAAU,CAACE,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;EAEzE,IAAID,cAAc,EAAE;IAClB,OAAOE,IAAI,IAAIL,aAAa,CAACK,IAAI,EAAEF,cAAc,CAAC;EACpD;EAEA,OAAOJ,WAAW;AACpB","ignoreList":[]}

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

@@ -0,0 +1,150 @@
+import { isUndefined, flatten } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
+const {
+  buildFormRule,
+  createRulesFromArrays
+} = languageProcessing;
+import getAdjectiveStem from "./getAdjectiveStem";
+import { getInfinitive, checkIrregulars as getIrregularVerbParadigm, endsWithIng } from "./getVerbStem.js";
+
+/**
+ * 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.
+ */
+export function findShortestAndAlphabeticallyFirst(array) {
+  const strings = 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.
+ */
+export 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.
+ */
+export function determineIrregularVerbStem(word, verbMorphology) {
+  const paradigmIfIrregularVerb = getIrregularVerbParadigm(word, verbMorphology.irregularVerbs, verbMorphology.regexVerb.verbPrefixes);
+  if (!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.
+ */
+export 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 (!isUndefined(baseIfPluralNoun)) {
+    // Bring ing-nouns to base forms ("blessings" -> "bless").
+    if (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 (!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 = 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 = getAdjectiveStem(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.
+ */
+export 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 (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);
+}
+export 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":["isUndefined","flatten","languageProcessing","buildFormRule","createRulesFromArrays","getAdjectiveStem","getInfinitive","checkIrregulars","getIrregularVerbParadigm","endsWithIng","findShortestAndAlphabeticallyFirst","array","strings","result","pop","forEach","str","lengthDifference","length","localeCompare","determineIrregularStem","word","irregulars","paradigm","includes","determineIrregularVerbStem","verbMorphology","paradigmIfIrregularVerb","irregularVerbs","regexVerb","verbPrefixes","determineRegularStem","morphologyData","verbs","baseIfPluralNoun","nouns","regexNoun","singularize","ingFormToInfinitive","regexAdjective","adjectives","baseIfIcally","icallyToBase","possibleRegularBases","baseIfVerb","infinitive","push","stopAdjectives","multiSyllableAdjWithSuffixes","multiSyllableAdjectives","list","baseIfAdjective","base","determineStem","nounMorphology","baseIfPossessive","possessiveToBase","stem","irregular","irregularNouns","irregularAdjectives"],"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":"AAAA,SAAQA,WAAW,EAAEC,OAAO,QAAO,QAAQ;AAC3C,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,aAAa;EAAEC;AAAqB,CAAC,GAAGF,kBAAkB;AAEjE,OAAOG,gBAAgB;AACvB,SACEC,aAAa,EACbC,eAAe,IAAIC,wBAAwB,EAC3CC,WAAW;;AAGb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kCAAkCA,CAACC,KAAK,EAAE;EACxD,MAAMC,OAAO,GAAGX,OAAO,CAACU,KAAK,CAAC;EAC9B,IAAIE,MAAM,GAAGD,OAAO,CAACE,GAAG,CAAC,CAAC;EAE1BF,OAAO,CAACG,OAAO,CAACC,GAAG,IAAI;IACrB,MAAMC,gBAAgB,GAAGD,GAAG,CAACE,MAAM,GAAGL,MAAM,CAACK,MAAM;IACnD,IAAID,gBAAgB,KAAK,CAAC,EAAE;MAC1B,IAAID,GAAG,CAACG,aAAa,CAACN,MAAM,CAAC,GAAG,CAAC,EAAE;QACjCA,MAAM,GAAGG,GAAG;MACd;IACF,CAAC,MAAM,IAAIC,gBAAgB,GAAG,CAAC,EAAE;MAC/BJ,MAAM,GAAGG,GAAG;IACd;EACF,CAAC,CAAC;EAEF,OAAOH,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,sBAAsBA,CAACC,IAAI,EAAEC,UAAU,EAAE;EACvD,KAAK,MAAMC,QAAQ,IAAID,UAAU,EAAE;IACjC,IAAIC,QAAQ,CAACC,QAAQ,CAACH,IAAI,CAAC,EAAE;MAC3B,OAAOE,QAAQ,CAAC,CAAC,CAAC;IACpB;EACF;EACA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,0BAA0BA,CAACJ,IAAI,EAAEK,cAAc,EAAE;EAC/D,MAAMC,uBAAuB,GAAGnB,wBAAwB,CACtDa,IAAI,EACJK,cAAc,CAACE,cAAc,EAC7BF,cAAc,CAACG,SAAS,CAACC,YAC3B,CAAC;EACD,IAAI,CAAC9B,WAAW,CAAC2B,uBAAuB,CAAC,EAAE;IACzC,OAAOA,uBAAuB,CAAC,CAAC,CAAC;EACnC;EACA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,oBAAoBA,CAACV,IAAI,EAAEW,cAAc,EAAE;EACzD;EACA,MAAMH,SAAS,GAAGG,cAAc,CAACC,KAAK,CAACJ,SAAS;EAChD,MAAMK,gBAAgB,GAAG/B,aAAa,CACpCkB,IAAI,EACJjB,qBAAqB,CAAC4B,cAAc,CAACG,KAAK,CAACC,SAAS,CAACC,WAAW,CAClE,CAAC;EACD,IAAI,CAACrC,WAAW,CAACkC,gBAAgB,CAAC,EAAE;IAClC;IACA,IAAIzB,WAAW,CAACyB,gBAAgB,CAAC,EAAE;MACjC,OAAO/B,aAAa,CAAC+B,gBAAgB,EAAE9B,qBAAqB,CAACyB,SAAS,CAACS,mBAAmB,CAAC,CAAC;IAC9F;IACA,OAAOJ,gBAAgB;EACzB;;EAEA;EACA,MAAMK,cAAc,GAAGP,cAAc,CAACQ,UAAU,CAACD,cAAc;EAC/D,MAAME,YAAY,GAAGtC,aAAa,CAACkB,IAAI,EAAEjB,qBAAqB,CAACmC,cAAc,CAACG,YAAY,CAAC,CAAC;EAC5F,IAAI,CAAC1C,WAAW,CAACyC,YAAY,CAAC,EAAE;IAC9B,OAAOA,YAAY;EACrB;;EAEA;EACA,MAAME,oBAAoB,GAAG,EAAE;;EAE/B;EACA,MAAMC,UAAU,GAAGtC,aAAa,CAACe,IAAI,EAAEQ,SAAS,CAAC,CAACgB,UAAU;EAE5DF,oBAAoB,CAACG,IAAI,CAACF,UAAU,CAAC;;EAErC;EACA,MAAMG,cAAc,GAAGf,cAAc,CAACQ,UAAU,CAACO,cAAc;EAC/D;AACF;AACA;AACA;AACA;EACE,MAAMC,4BAA4B,GAAGhB,cAAc,CAACQ,UAAU,CAACS,uBAAuB,CAACC,IAAI;EAE3F,MAAMC,eAAe,GAAG9C,gBAAgB,CACtCgB,IAAI,EACJkB,cAAc,EACdQ,cAAc,EACdC,4BACF,CAAC,CAACI,IAAI;EACNT,oBAAoB,CAACG,IAAI,CAACK,eAAe,CAAC;EAE1C,OAAOzC,kCAAkC,CAACiC,oBAAoB,CAAC;AACjE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASU,aAAaA,CAAChC,IAAI,EAAEW,cAAc,EAAE;EAClD,MAAMsB,cAAc,GAAGtB,cAAc,CAACG,KAAK;EAE3C,MAAMoB,gBAAgB,GAAGpD,aAAa,CACpCkB,IAAI,EACJjB,qBAAqB,CAACkD,cAAc,CAAClB,SAAS,CAACoB,gBAAgB,CACjE,CAAC;EAED,IAAIC,IAAI;EACR,IAAIC,SAAS;;EAEb;EACA,IAAI1D,WAAW,CAACuD,gBAAgB,CAAC,EAAE;IACjCE,IAAI,GAAGpC,IAAI;IACX;IACAqC,SAAS,GACPtC,sBAAsB,CAACC,IAAI,EAAEiC,cAAc,CAACK,cAAc,CAAC,IAC3DvC,sBAAsB,CAACC,IAAI,EAAEW,cAAc,CAACQ,UAAU,CAACoB,mBAAmB,CAAC,IAC3EnC,0BAA0B,CAACJ,IAAI,EAAEW,cAAc,CAACC,KAAK,CAAC;EAC1D,CAAC,MAAM;IACLwB,IAAI,GAAGF,gBAAgB;IACvB;IACAG,SAAS,GAAGtC,sBAAsB,CAACmC,gBAAgB,EAAED,cAAc,CAACK,cAAc,CAAC;EACrF;EAEA,IAAID,SAAS,EAAE;IACb;IACA,OAAOA,SAAS;EAClB;;EAEA;EACA,OAAO3B,oBAAoB,CAAC0B,IAAI,EAAEzB,cAAc,CAAC;AACnD;AAEA,eAAeqB,aAAa","ignoreList":[]}

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

@@ -0,0 +1,142 @@
+import { languageProcessing } from "../../../../../index.js";
+import { countSyllablesInWord } from "../../../../helpers/syllables/countSyllables";
+import syllables from "../../config/syllables.json";
+const {
+  buildFormRule,
+  createRulesFromArrays
+} = 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 = 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.
+   * 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.
+ */
+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).
+   */
+  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":["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

@@ -0,0 +1,27 @@
+import { forEach, includes } from 'lodash';
+import { languageProcessing } from "../../../../../index.js";
+const {
+  matchRegularParticiples,
+  getWords
+} = languageProcessing;
+import irregularParticiples from "../../config/internal/passiveVoiceIrregulars";
+
+/**
+ * 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.
+ */
+export default function getParticiples(clauseText) {
+  const words = getWords(clauseText);
+  const foundParticiples = [];
+  forEach(words, function (word) {
+    const regex = [/\w+ed($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi];
+    if (matchRegularParticiples(word, regex).length !== 0 || includes(irregularParticiples, 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":["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":[]}