axyseo 2.0.0-alpha.3 → 2.1.1

package/build/languageProcessing/languages/nl/helpers/internal/stem.js.map

@@ -1 +1 @@
-{"version":3,"file":"stem.js","names":["_index","require","_detectAndStemSuffixes","_interopRequireDefault","_getStemWordsWithTAndDEnding","_checkExceptionsWithFullForms","_detectAndStemRegularParticiple","_stemModificationHelpers","e","__esModule","default","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","stemHelpers","removeSuffixFromFullForm","removeSuffixesFromFullForm","languageProcessing","removeSuffixFromFullForms","morphologyDataNL","word","exceptionClass","stemExceptions","removeSuffixesFromFullForms","stemmedWord","forms","suffixes","suffix","checkOtherStemmingExceptions","stemFromFullForm","isVowelDoublingAllowed","regularStemmer","stemModifications","exceptionsStemModifications","pastParticipleStemmer","compoundVerbsPrefixes","modifyStem","doubleVowel","finalChanges","stem","checkExceptionsWithFullForms","detectAndStemRegularParticiple","wordsNotToBeStemmed","wordsNotToBeStemmedExceptions","verbs","endingMatch","exactMatch","includes","tAndDEndings","ambiguousTAndDEndings","otherTAndDEndings","ending","endsWith","generateCorrectStemWithTAndDEnding","detectAndStemSuffixes"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stem.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix},\n  stemHelpers: {removeSuffixFromFullForm, removeSuffixesFromFullForm}\n} = languageProcessing;\n\nimport detectAndStemSuffixes from './detectAndStemSuffixes';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding.js';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {modifyStem, isVowelDoublingAllowed} from './stemModificationHelpers';\n\n/**\n * Get the stem from noun diminutives and plurals exceptions.\n *\n * @param {Object}    morphologyDataNL The data for stemming exception.\n * @param {string}      word                                The word to check.\n *\n * @returns {string} The stemmed word.\n */\nconst removeSuffixFromFullForms = function(morphologyDataNL, word) {\n  /*\n   * Checks whether the word is in the exception list of words ending in -er and gets either -e or -s suffix\n   * If it is, remove the corresponding suffix.\n   * e.g. lekkere -> lekker, bitters -> bitter\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixesFromFullForms) {\n    const stemmedWord = removeSuffixesFromFullForm(\n      exceptionClass.forms,\n      exceptionClass.suffixes,\n      word\n    );\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n  /*\n   * Checks whether the word is in one of the exception lists of nouns\n   * for which a specific suffix needs to be stemmed (e.g. -s, -es, -eren, -er etc.)\n   * e.g. kuddes -> kud, modes -> mod, revenuen -> revenu\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixFromFullForms) {\n    const stemmedWord = removeSuffixFromFullForm(exceptionClass.forms, exceptionClass.suffix, word);\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n};\n\n/**\n * Checks if the word is on a stemming exception list.\n *\n * @param {string} word The word to check.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n * @returns {string|null} The stem or null if the word was not matched by any of the exception checks.\n */\nconst checkOtherStemmingExceptions = function(word, morphologyDataNL) {\n  /*\n   * Checks whether the word is in the exception list of nouns or adjectives with specific suffixes that needs to be stemmed.\n   * If it is return the stem here and run possible stem modification if it is required. e.g. modes -> mod -> mood\n   */\n  let stemFromFullForm = removeSuffixFromFullForms(morphologyDataNL, word);\n  if (stemFromFullForm) {\n    if (\n      isVowelDoublingAllowed(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n      )\n    ) {\n      stemFromFullForm = modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.doubleVowel\n      );\n      return modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.finalChanges\n      );\n    }\n    return modifyStem(\n      stemFromFullForm,\n      morphologyDataNL.regularStemmer.stemModifications.finalChanges\n    );\n  }\n  return null;\n};\n\n/**\n * Stems Dutch words.\n *\n * @param {string} word  The word to stem.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nexport default function stem(word, morphologyDataNL) {\n  // Check whether the word is in the list of words with full forms for which we define the stem. If it is, return the canonical stem.\n  let stemmedWord = checkExceptionsWithFullForms(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is a participle, and if yes, stem it and return the stem.\n  stemmedWord = detectAndStemRegularParticiple(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is on the list of words that should not be stemmed, and if yes, return the word. Example: gans -> gans\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  if (\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word)\n  ) {\n    return word;\n  }\n\n  /*\n   * Check whether the word ends in -t/-te/-ten/-tend/-de/-den/-dend. If it does, run through a series of checks aimed at\n   * predicting whether the -t/d is part of the stem or the suffix. If the word was matched in one of the checks, stem it\n   * accordingly and return the stem. Example: boot -> boot, squasht -> squash\n   */\n  const tAndDEndings = morphologyDataNL.ambiguousTAndDEndings.otherTAndDEndings;\n  for (const ending of tAndDEndings) {\n    if (word.endsWith(ending)) {\n      stemmedWord = generateCorrectStemWithTAndDEnding(morphologyDataNL, word);\n      if (stemmedWord) {\n        return stemmedWord;\n      }\n    }\n  }\n\n  // Check if the word is on any other stemming exception list, and if yes, return the correct stem.\n  stemmedWord = checkOtherStemmingExceptions(word, morphologyDataNL);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // If the word was not stemmed in any of the previous steps, run through the stemming algorithm which detects and stems suffixes.\n  return detectAndStemSuffixes(word, morphologyDataNL);\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"stem.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","stemHelpers","removeSuffixFromFullForm","removeSuffixesFromFullForm","detectAndStemSuffixes","generateCorrectStemWithTAndDEnding","checkExceptionsWithFullForms","detectAndStemRegularParticiple","modifyStem","isVowelDoublingAllowed","removeSuffixFromFullForms","morphologyDataNL","word","exceptionClass","stemExceptions","removeSuffixesFromFullForms","stemmedWord","forms","suffixes","suffix","checkOtherStemmingExceptions","stemFromFullForm","regularStemmer","stemModifications","exceptionsStemModifications","pastParticipleStemmer","compoundVerbsPrefixes","doubleVowel","finalChanges","stem","wordsNotToBeStemmed","wordsNotToBeStemmedExceptions","verbs","endingMatch","exactMatch","includes","tAndDEndings","ambiguousTAndDEndings","otherTAndDEndings","ending","endsWith"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stem.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix},\n  stemHelpers: {removeSuffixFromFullForm, removeSuffixesFromFullForm}\n} = languageProcessing;\n\nimport detectAndStemSuffixes from './detectAndStemSuffixes';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding.js';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {modifyStem, isVowelDoublingAllowed} from './stemModificationHelpers';\n\n/**\n * Get the stem from noun diminutives and plurals exceptions.\n *\n * @param {Object}    morphologyDataNL The data for stemming exception.\n * @param {string}      word                                The word to check.\n *\n * @returns {string} The stemmed word.\n */\nconst removeSuffixFromFullForms = function(morphologyDataNL, word) {\n  /*\n   * Checks whether the word is in the exception list of words ending in -er and gets either -e or -s suffix\n   * If it is, remove the corresponding suffix.\n   * e.g. lekkere -> lekker, bitters -> bitter\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixesFromFullForms) {\n    const stemmedWord = removeSuffixesFromFullForm(\n      exceptionClass.forms,\n      exceptionClass.suffixes,\n      word\n    );\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n  /*\n   * Checks whether the word is in one of the exception lists of nouns\n   * for which a specific suffix needs to be stemmed (e.g. -s, -es, -eren, -er etc.)\n   * e.g. kuddes -> kud, modes -> mod, revenuen -> revenu\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixFromFullForms) {\n    const stemmedWord = removeSuffixFromFullForm(exceptionClass.forms, exceptionClass.suffix, word);\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n};\n\n/**\n * Checks if the word is on a stemming exception list.\n *\n * @param {string} word The word to check.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n * @returns {string|null} The stem or null if the word was not matched by any of the exception checks.\n */\nconst checkOtherStemmingExceptions = function(word, morphologyDataNL) {\n  /*\n   * Checks whether the word is in the exception list of nouns or adjectives with specific suffixes that needs to be stemmed.\n   * If it is return the stem here and run possible stem modification if it is required. e.g. modes -> mod -> mood\n   */\n  let stemFromFullForm = removeSuffixFromFullForms(morphologyDataNL, word);\n  if (stemFromFullForm) {\n    if (\n      isVowelDoublingAllowed(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n      )\n    ) {\n      stemFromFullForm = modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.doubleVowel\n      );\n      return modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.finalChanges\n      );\n    }\n    return modifyStem(\n      stemFromFullForm,\n      morphologyDataNL.regularStemmer.stemModifications.finalChanges\n    );\n  }\n  return null;\n};\n\n/**\n * Stems Dutch words.\n *\n * @param {string} word  The word to stem.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nexport default function stem(word, morphologyDataNL) {\n  // Check whether the word is in the list of words with full forms for which we define the stem. If it is, return the canonical stem.\n  let stemmedWord = checkExceptionsWithFullForms(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is a participle, and if yes, stem it and return the stem.\n  stemmedWord = detectAndStemRegularParticiple(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is on the list of words that should not be stemmed, and if yes, return the word. Example: gans -> gans\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  if (\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word)\n  ) {\n    return word;\n  }\n\n  /*\n   * Check whether the word ends in -t/-te/-ten/-tend/-de/-den/-dend. If it does, run through a series of checks aimed at\n   * predicting whether the -t/d is part of the stem or the suffix. If the word was matched in one of the checks, stem it\n   * accordingly and return the stem. Example: boot -> boot, squasht -> squash\n   */\n  const tAndDEndings = morphologyDataNL.ambiguousTAndDEndings.otherTAndDEndings;\n  for (const ending of tAndDEndings) {\n    if (word.endsWith(ending)) {\n      stemmedWord = generateCorrectStemWithTAndDEnding(morphologyDataNL, word);\n      if (stemmedWord) {\n        return stemmedWord;\n      }\n    }\n  }\n\n  // Check if the word is on any other stemming exception list, and if yes, return the correct stem.\n  stemmedWord = checkOtherStemmingExceptions(word, morphologyDataNL);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // If the word was not stemmed in any of the previous steps, run through the stemming algorithm which detects and stems suffixes.\n  return detectAndStemSuffixes(word, morphologyDataNL);\n}\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js

@@ -1,17 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isVowelDoublingAllowed = isVowelDoublingAllowed;
-exports.modifyStem = modifyStem;
-var _index = require("../../../index");
+import { languageProcessing } from "../../../../../index.js";
 const {
   exceptionListHelpers: {
     checkIfWordEndingIsOnExceptionList,
     checkIfWordIsOnListThatCanHavePrefix
   }
-} = _index.languageProcessing;
+} = languageProcessing;
 
 /**
  * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,
@@ -65,7 +58,7 @@ const doesPrecedingSyllableContainDiphthong = function (word, noVowelDoublingReg
  * @param {string[]} modificationGroup The type of modification that needs to be done.
  * @returns {string} The modified stem, or the same stem if no modification was made.
  */
-function modifyStem(word, modificationGroup) {
+export function modifyStem(word, modificationGroup) {
   const neededReplacement = modificationGroup.find(replacement => word.search(new RegExp(replacement[0])) !== -1);
   if (typeof neededReplacement !== 'undefined') {
     word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);
@@ -82,7 +75,7 @@ function modifyStem(word, modificationGroup) {
  *
  * @returns {boolean} Whether the vowel should be doubled or not.
  */
-function isVowelDoublingAllowed(word, morphologyDataNLStemmingExceptions, morphologyDataNLVerbPrefixes) {
+export function isVowelDoublingAllowed(word, morphologyDataNLStemmingExceptions, morphologyDataNLVerbPrefixes) {
   // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)
   const firstCheck = checkIfWordIsOnListThatCanHavePrefix(word, morphologyDataNLStemmingExceptions.getVowelDoubling, morphologyDataNLVerbPrefixes);
   // Check whether the word is on the list of words which should NOT have the vowel doubled

package/build/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"stemModificationHelpers.js","names":["_index","require","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","languageProcessing","checkIfWordIsOnNoVowelDoublingList","word","noVowelDoublingList","compoundVerbPrefixes","endingMatch","verbs","exactMatch","includes","isVowelPrecededByDoubleConsonant","fourthToLastLetter","charAt","length","thirdToLastLetter","doesPrecedingSyllableContainDiphthong","noVowelDoublingRegex","search","RegExp","modifyStem","modificationGroup","neededReplacement","find","replacement","replace","isVowelDoublingAllowed","morphologyDataNLStemmingExceptions","morphologyDataNLVerbPrefixes","firstCheck","getVowelDoubling","secondCheck","noVowelDoubling","thirdCheck","fourthCheck","rule"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\n/**\n * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,\n * and verbs) and returns true if it is.\n *\n * @param {string}\tword\t\t\t\t\t\t\tThe word to check.\n * @param {Object}\tnoVowelDoublingList\tThe list of stems that should not have the vowel doubled.\n * @param {Object}\tcompoundVerbPrefixes\t\t\tThe list of inseparable and separable verb prefixes.\n *\n * @returns {boolean} Whether the word was found on one of the lists\n */\nconst checkIfWordIsOnNoVowelDoublingList = function(\n  word,\n  noVowelDoublingList,\n  compoundVerbPrefixes\n) {\n  if (\n    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||\n    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||\n    noVowelDoublingList.exactMatch.includes(word)\n  ) {\n    return true;\n  }\n};\n\n/**\n * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks\n * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).\n * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the\n * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.\n *\n * @param {string} word The stemmed word to check.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst isVowelPrecededByDoubleConsonant = function(word) {\n  const fourthToLastLetter = word.charAt(word.length - 4);\n  const thirdToLastLetter = word.charAt(word.length - 3);\n  return fourthToLastLetter !== thirdToLastLetter;\n};\n\n/**\n * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should\n * not be doubled.\n *\n * @param {string} word                 The stemmed word to check.\n * @param {string} noVowelDoublingRegex The regex to match a word with.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {\n  return word.search(new RegExp(noVowelDoublingRegex)) === -1;\n};\n\n/**\n * Modifies the stem of the word according to the specified modification type.\n *\n * @param {string} word The stem that needs to be modified.\n * @param {string[]} modificationGroup The type of modification that needs to be done.\n * @returns {string} The modified stem, or the same stem if no modification was made.\n */\nexport function modifyStem(word, modificationGroup) {\n  const neededReplacement = modificationGroup.find(\n    replacement => word.search(new RegExp(replacement[0])) !== -1\n  );\n  if (typeof neededReplacement !== 'undefined') {\n    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);\n  }\n  return word;\n}\n\n/**\n * Checks whether the final vowel of the stem should be doubled by going through four checks.\n *\n * @param {string}  word                               The stemmed word that the check should be executed on.\n * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.\n * @param {Object}  morphologyDataNLVerbPrefixes\t   The separable and inseparable verb prefixes.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nexport function isVowelDoublingAllowed(\n  word,\n  morphologyDataNLStemmingExceptions,\n  morphologyDataNLVerbPrefixes\n) {\n  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)\n  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(\n    word,\n    morphologyDataNLStemmingExceptions.getVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  // Check whether the word is on the list of words which should NOT have the vowel doubled\n  const secondCheck = checkIfWordIsOnNoVowelDoublingList(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  const thirdCheck = isVowelPrecededByDoubleConsonant(word);\n  const fourthCheck = doesPrecedingSyllableContainDiphthong(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling.rule\n  );\n\n  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGC,yBAAkB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,kCAAkC,GAAG,SAAAA,CACzCC,IAAI,EACJC,mBAAmB,EACnBC,oBAAoB,EACpB;EACA,IACEN,kCAAkC,CAACI,IAAI,EAAEC,mBAAmB,CAACE,WAAW,CAAC,IACzEN,oCAAoC,CAACG,IAAI,EAAEC,mBAAmB,CAACG,KAAK,EAAEF,oBAAoB,CAAC,IAC3FD,mBAAmB,CAACI,UAAU,CAACC,QAAQ,CAACN,IAAI,CAAC,EAC7C;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMO,gCAAgC,GAAG,SAAAA,CAASP,IAAI,EAAE;EACtD,MAAMQ,kBAAkB,GAAGR,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACvD,MAAMC,iBAAiB,GAAGX,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACtD,OAAOF,kBAAkB,KAAKG,iBAAiB;AACjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAASZ,IAAI,EAAEa,oBAAoB,EAAE;EACjF,OAAOb,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACF,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAAChB,IAAI,EAAEiB,iBAAiB,EAAE;EAClD,MAAMC,iBAAiB,GAAGD,iBAAiB,CAACE,IAAI,CAC9CC,WAAW,IAAIpB,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAC9D,CAAC;EACD,IAAI,OAAOF,iBAAiB,KAAK,WAAW,EAAE;IAC5ClB,IAAI,GAAGA,IAAI,CAACqB,OAAO,CAAC,IAAIN,MAAM,CAACG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAEA,iBAAiB,CAAC,CAAC,CAAC,CAAC;EAC7E;EACA,OAAOlB,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASsB,sBAAsBA,CACpCtB,IAAI,EACJuB,kCAAkC,EAClCC,4BAA4B,EAC5B;EACA;EACA,MAAMC,UAAU,GAAG5B,oCAAoC,CACrDG,IAAI,EACJuB,kCAAkC,CAACG,gBAAgB,EACnDF,4BACF,CAAC;EACD;EACA,MAAMG,WAAW,GAAG5B,kCAAkC,CACpDC,IAAI,EACJuB,kCAAkC,CAACK,eAAe,EAClDJ,4BACF,CAAC;EACD,MAAMK,UAAU,GAAGtB,gCAAgC,CAACP,IAAI,CAAC;EACzD,MAAM8B,WAAW,GAAGlB,qCAAqC,CACvDZ,IAAI,EACJuB,kCAAkC,CAACK,eAAe,CAACG,IACrD,CAAC;EAED,OAAON,UAAU,IAAK,CAACE,WAAW,IAAIE,UAAU,IAAIC,WAAY;AAClE","ignoreList":[]}
+{"version":3,"file":"stemModificationHelpers.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","checkIfWordIsOnNoVowelDoublingList","word","noVowelDoublingList","compoundVerbPrefixes","endingMatch","verbs","exactMatch","includes","isVowelPrecededByDoubleConsonant","fourthToLastLetter","charAt","length","thirdToLastLetter","doesPrecedingSyllableContainDiphthong","noVowelDoublingRegex","search","RegExp","modifyStem","modificationGroup","neededReplacement","find","replacement","replace","isVowelDoublingAllowed","morphologyDataNLStemmingExceptions","morphologyDataNLVerbPrefixes","firstCheck","getVowelDoubling","secondCheck","noVowelDoubling","thirdCheck","fourthCheck","rule"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\n/**\n * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,\n * and verbs) and returns true if it is.\n *\n * @param {string}\tword\t\t\t\t\t\t\tThe word to check.\n * @param {Object}\tnoVowelDoublingList\tThe list of stems that should not have the vowel doubled.\n * @param {Object}\tcompoundVerbPrefixes\t\t\tThe list of inseparable and separable verb prefixes.\n *\n * @returns {boolean} Whether the word was found on one of the lists\n */\nconst checkIfWordIsOnNoVowelDoublingList = function(\n  word,\n  noVowelDoublingList,\n  compoundVerbPrefixes\n) {\n  if (\n    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||\n    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||\n    noVowelDoublingList.exactMatch.includes(word)\n  ) {\n    return true;\n  }\n};\n\n/**\n * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks\n * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).\n * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the\n * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.\n *\n * @param {string} word The stemmed word to check.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst isVowelPrecededByDoubleConsonant = function(word) {\n  const fourthToLastLetter = word.charAt(word.length - 4);\n  const thirdToLastLetter = word.charAt(word.length - 3);\n  return fourthToLastLetter !== thirdToLastLetter;\n};\n\n/**\n * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should\n * not be doubled.\n *\n * @param {string} word                 The stemmed word to check.\n * @param {string} noVowelDoublingRegex The regex to match a word with.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {\n  return word.search(new RegExp(noVowelDoublingRegex)) === -1;\n};\n\n/**\n * Modifies the stem of the word according to the specified modification type.\n *\n * @param {string} word The stem that needs to be modified.\n * @param {string[]} modificationGroup The type of modification that needs to be done.\n * @returns {string} The modified stem, or the same stem if no modification was made.\n */\nexport function modifyStem(word, modificationGroup) {\n  const neededReplacement = modificationGroup.find(\n    replacement => word.search(new RegExp(replacement[0])) !== -1\n  );\n  if (typeof neededReplacement !== 'undefined') {\n    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);\n  }\n  return word;\n}\n\n/**\n * Checks whether the final vowel of the stem should be doubled by going through four checks.\n *\n * @param {string}  word                               The stemmed word that the check should be executed on.\n * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.\n * @param {Object}  morphologyDataNLVerbPrefixes\t   The separable and inseparable verb prefixes.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nexport function isVowelDoublingAllowed(\n  word,\n  morphologyDataNLStemmingExceptions,\n  morphologyDataNLVerbPrefixes\n) {\n  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)\n  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(\n    word,\n    morphologyDataNLStemmingExceptions.getVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  // Check whether the word is on the list of words which should NOT have the vowel doubled\n  const secondCheck = checkIfWordIsOnNoVowelDoublingList(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  const thirdCheck = isVowelPrecededByDoubleConsonant(word);\n  const fourthCheck = doesPrecedingSyllableContainDiphthong(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling.rule\n  );\n\n  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGH,kBAAkB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,kCAAkC,GAAG,SAAAA,CACzCC,IAAI,EACJC,mBAAmB,EACnBC,oBAAoB,EACpB;EACA,IACEL,kCAAkC,CAACG,IAAI,EAAEC,mBAAmB,CAACE,WAAW,CAAC,IACzEL,oCAAoC,CAACE,IAAI,EAAEC,mBAAmB,CAACG,KAAK,EAAEF,oBAAoB,CAAC,IAC3FD,mBAAmB,CAACI,UAAU,CAACC,QAAQ,CAACN,IAAI,CAAC,EAC7C;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMO,gCAAgC,GAAG,SAAAA,CAASP,IAAI,EAAE;EACtD,MAAMQ,kBAAkB,GAAGR,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACvD,MAAMC,iBAAiB,GAAGX,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACtD,OAAOF,kBAAkB,KAAKG,iBAAiB;AACjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAASZ,IAAI,EAAEa,oBAAoB,EAAE;EACjF,OAAOb,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACF,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,UAAUA,CAAChB,IAAI,EAAEiB,iBAAiB,EAAE;EAClD,MAAMC,iBAAiB,GAAGD,iBAAiB,CAACE,IAAI,CAC9CC,WAAW,IAAIpB,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAC9D,CAAC;EACD,IAAI,OAAOF,iBAAiB,KAAK,WAAW,EAAE;IAC5ClB,IAAI,GAAGA,IAAI,CAACqB,OAAO,CAAC,IAAIN,MAAM,CAACG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAEA,iBAAiB,CAAC,CAAC,CAAC,CAAC;EAC7E;EACA,OAAOlB,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASsB,sBAAsBA,CACpCtB,IAAI,EACJuB,kCAAkC,EAClCC,4BAA4B,EAC5B;EACA;EACA,MAAMC,UAAU,GAAG3B,oCAAoC,CACrDE,IAAI,EACJuB,kCAAkC,CAACG,gBAAgB,EACnDF,4BACF,CAAC;EACD;EACA,MAAMG,WAAW,GAAG5B,kCAAkC,CACpDC,IAAI,EACJuB,kCAAkC,CAACK,eAAe,EAClDJ,4BACF,CAAC;EACD,MAAMK,UAAU,GAAGtB,gCAAgC,CAACP,IAAI,CAAC;EACzD,MAAM8B,WAAW,GAAGlB,qCAAqC,CACvDZ,IAAI,EACJuB,kCAAkC,CAACK,eAAe,CAACG,IACrD,CAAC;EAED,OAAON,UAAU,IAAK,CAACE,WAAW,IAAIE,UAAU,IAAIC,WAAY;AAClE","ignoreList":[]}

package/build/languageProcessing/languages/nl/helpers/internal/stemTOrDFromEndOfWord.js

@@ -1,20 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stemTOrDFromEndOfWord = stemTOrDFromEndOfWord;
-var _index = require("../../../index");
-var _detectAndStemRegularParticiple = require("./detectAndStemRegularParticiple");
-var _getStemWordsWithTAndDEnding = require("./getStemWordsWithTAndDEnding");
-var _checkExceptionsWithFullForms = _interopRequireDefault(require("./checkExceptionsWithFullForms"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { languageProcessing } from "../../../../../index.js";
 const {
   exceptionListHelpers: {
     checkIfWordEndingIsOnExceptionList,
     checkIfWordIsOnListThatCanHavePrefix
   }
-} = _index.languageProcessing;
+} = languageProcessing;
+import { detectAndStemRegularParticiple } from "./detectAndStemRegularParticiple";
+import { generateCorrectStemWithTAndDEnding } from "./getStemWordsWithTAndDEnding";
+import checkExceptionsWithFullForms from "./checkExceptionsWithFullForms";
+
 /**
  * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, other checks still need
  * to be done in order to be sure whether we need to stem the word further or not.
@@ -31,7 +25,7 @@ const checkIfTorDIsUnambiguous = function (morphologyDataNL, stemmedWord, word)
   const wordsEndingInTOrDExceptionList = morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;
 
   // Run the checks below. If one of the conditions returns true, return the stem.
-  if ((0, _detectAndStemRegularParticiple.detectAndStemRegularParticiple)(morphologyDataNL, word) || (0, _getStemWordsWithTAndDEnding.generateCorrectStemWithTAndDEnding)(morphologyDataNL, word) || checkIfWordIsOnListThatCanHavePrefix(word, wordsNotToBeStemmed.verbs, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes) || checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) || wordsNotToBeStemmed.exactMatch.includes(word) || adjectivesEndingInRd.includes(stemmedWord) || (0, _checkExceptionsWithFullForms.default)(morphologyDataNL, word) || stemmedWord.endsWith('heid') || checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)) {
+  if (detectAndStemRegularParticiple(morphologyDataNL, word) || generateCorrectStemWithTAndDEnding(morphologyDataNL, word) || checkIfWordIsOnListThatCanHavePrefix(word, wordsNotToBeStemmed.verbs, morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes) || checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) || wordsNotToBeStemmed.exactMatch.includes(word) || adjectivesEndingInRd.includes(stemmedWord) || checkExceptionsWithFullForms(morphologyDataNL, word) || stemmedWord.endsWith('heid') || checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)) {
     return true;
   }
 };
@@ -49,7 +43,7 @@ const checkIfTorDIsUnambiguous = function (morphologyDataNL, stemmedWord, word)
  *
  * @returns {?string}				    The stemmed word or null if the -t/-d should not be stemmed.
  */
-function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {
+export function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {
   if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {
     return null;
   }

package/build/languageProcessing/languages/nl/helpers/internal/stemTOrDFromEndOfWord.js.map

@@ -1 +1 @@
-{"version":3,"file":"stemTOrDFromEndOfWord.js","names":["_index","require","_detectAndStemRegularParticiple","_getStemWordsWithTAndDEnding","_checkExceptionsWithFullForms","_interopRequireDefault","e","__esModule","default","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","languageProcessing","checkIfTorDIsUnambiguous","morphologyDataNL","stemmedWord","word","wordsNotToBeStemmed","stemExceptions","wordsNotToBeStemmedExceptions","adjectivesEndingInRd","removeSuffixesFromFullForms","forms","wordsEndingInTOrDExceptionList","ambiguousTAndDEndings","tOrDArePartOfStem","doNotStemTOrD","detectAndStemRegularParticiple","generateCorrectStemWithTAndDEnding","verbs","pastParticipleStemmer","compoundVerbsPrefixes","endingMatch","exactMatch","includes","checkExceptionsWithFullForms","endsWith","stemTOrDFromEndOfWord","slice"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemTOrDFromEndOfWord.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, other checks still need\n * to be done in order to be sure whether we need to stem the word further or not.\n * If one of these checks returns true, we do not need to stem the word further.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n * @returns {boolean}\tWhether one of the conditions returns true or not.\n */\nconst checkIfTorDIsUnambiguous = function(morphologyDataNL, stemmedWord, word) {\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  const adjectivesEndingInRd = morphologyDataNL.stemExceptions.removeSuffixesFromFullForms[1].forms;\n  const wordsEndingInTOrDExceptionList =\n    morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;\n\n  // Run the checks below. If one of the conditions returns true, return the stem.\n  if (\n    detectAndStemRegularParticiple(morphologyDataNL, word) ||\n    generateCorrectStemWithTAndDEnding(morphologyDataNL, word) ||\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word) ||\n    adjectivesEndingInRd.includes(stemmedWord) ||\n    checkExceptionsWithFullForms(morphologyDataNL, word) ||\n    stemmedWord.endsWith('heid') ||\n    checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)\n  ) {\n    return true;\n  }\n};\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, and if it\n * is not a participle (which has its separate check), then it is still ambiguous whether -t/-d is part of the stem or a suffix.\n * Therefore, a second stem should be created with the -t/-d removed in case it was a suffix. For example, in the verb 'poolt',\n * -t is a suffix, but we could not predict in any of the previous checks that -t should be stemmed. To account for such cases,\n * we stem the -t here.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n *\n * @returns {?string}\t\t\t\t    The stemmed word or null if the -t/-d should not be stemmed.\n */\nexport function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {\n  if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {\n    return null;\n  }\n  // If none of the conditions above is true, stem the t/d from the word.\n  return stemmedWord.slice(0, -1);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,+BAAA,GAAAD,OAAA;AACA,IAAAE,4BAAA,GAAAF,OAAA;AACA,IAAAG,6BAAA,GAAAC,sBAAA,CAAAJ,OAAA;AAA0E,SAAAI,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAN1E,MAAM;EACJG,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGC,yBAAkB;AAMtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,GAAG,SAAAA,CAASC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EAC7E,MAAMC,mBAAmB,GAAGH,gBAAgB,CAACI,cAAc,CAACC,6BAA6B;EACzF,MAAMC,oBAAoB,GAAGN,gBAAgB,CAACI,cAAc,CAACG,2BAA2B,CAAC,CAAC,CAAC,CAACC,KAAK;EACjG,MAAMC,8BAA8B,GAClCT,gBAAgB,CAACU,qBAAqB,CAACC,iBAAiB,CAACC,aAAa;;EAExE;EACA,IACE,IAAAC,8DAA8B,EAACb,gBAAgB,EAAEE,IAAI,CAAC,IACtD,IAAAY,+DAAkC,EAACd,gBAAgB,EAAEE,IAAI,CAAC,IAC1DL,oCAAoC,CAClCK,IAAI,EACJC,mBAAmB,CAACY,KAAK,EACzBf,gBAAgB,CAACgB,qBAAqB,CAACC,qBACzC,CAAC,IACDrB,kCAAkC,CAACM,IAAI,EAAEC,mBAAmB,CAACe,WAAW,CAAC,IACzEf,mBAAmB,CAACgB,UAAU,CAACC,QAAQ,CAAClB,IAAI,CAAC,IAC7CI,oBAAoB,CAACc,QAAQ,CAACnB,WAAW,CAAC,IAC1C,IAAAoB,qCAA4B,EAACrB,gBAAgB,EAAEE,IAAI,CAAC,IACpDD,WAAW,CAACqB,QAAQ,CAAC,MAAM,CAAC,IAC5B1B,kCAAkC,CAACK,WAAW,EAAEQ,8BAA8B,CAAC,EAC/E;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASc,qBAAqBA,CAACvB,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EACzE,IAAIH,wBAAwB,CAACC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,CAAC,EAAE;IACjE,OAAO,IAAI;EACb;EACA;EACA,OAAOD,WAAW,CAACuB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACjC","ignoreList":[]}
+{"version":3,"file":"stemTOrDFromEndOfWord.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","detectAndStemRegularParticiple","generateCorrectStemWithTAndDEnding","checkExceptionsWithFullForms","checkIfTorDIsUnambiguous","morphologyDataNL","stemmedWord","word","wordsNotToBeStemmed","stemExceptions","wordsNotToBeStemmedExceptions","adjectivesEndingInRd","removeSuffixesFromFullForms","forms","wordsEndingInTOrDExceptionList","ambiguousTAndDEndings","tOrDArePartOfStem","doNotStemTOrD","verbs","pastParticipleStemmer","compoundVerbsPrefixes","endingMatch","exactMatch","includes","endsWith","stemTOrDFromEndOfWord","slice"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemTOrDFromEndOfWord.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, other checks still need\n * to be done in order to be sure whether we need to stem the word further or not.\n * If one of these checks returns true, we do not need to stem the word further.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n * @returns {boolean}\tWhether one of the conditions returns true or not.\n */\nconst checkIfTorDIsUnambiguous = function(morphologyDataNL, stemmedWord, word) {\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  const adjectivesEndingInRd = morphologyDataNL.stemExceptions.removeSuffixesFromFullForms[1].forms;\n  const wordsEndingInTOrDExceptionList =\n    morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;\n\n  // Run the checks below. If one of the conditions returns true, return the stem.\n  if (\n    detectAndStemRegularParticiple(morphologyDataNL, word) ||\n    generateCorrectStemWithTAndDEnding(morphologyDataNL, word) ||\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word) ||\n    adjectivesEndingInRd.includes(stemmedWord) ||\n    checkExceptionsWithFullForms(morphologyDataNL, word) ||\n    stemmedWord.endsWith('heid') ||\n    checkIfWordEndingIsOnExceptionList(stemmedWord, wordsEndingInTOrDExceptionList)\n  ) {\n    return true;\n  }\n};\n\n/**\n * If the word ending in -t/-d was not matched in any of the checks for whether -t/-d should be stemmed or not, and if it\n * is not a participle (which has its separate check), then it is still ambiguous whether -t/-d is part of the stem or a suffix.\n * Therefore, a second stem should be created with the -t/-d removed in case it was a suffix. For example, in the verb 'poolt',\n * -t is a suffix, but we could not predict in any of the previous checks that -t should be stemmed. To account for such cases,\n * we stem the -t here.\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}\tstemmedWord\t\t\tThe stemmed word.\n * @param {string}\tword\t\t\t\tThe unstemmed word.\n *\n * @returns {?string}\t\t\t\t    The stemmed word or null if the -t/-d should not be stemmed.\n */\nexport function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {\n  if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {\n    return null;\n  }\n  // If none of the conditions above is true, stem the t/d from the word.\n  return stemmedWord.slice(0, -1);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGH,kBAAkB;AAEtB,SAAQI,8BAA8B;AACtC,SAAQC,kCAAkC;AAC1C,OAAOC,4BAA4B;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,GAAG,SAAAA,CAASC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EAC7E,MAAMC,mBAAmB,GAAGH,gBAAgB,CAACI,cAAc,CAACC,6BAA6B;EACzF,MAAMC,oBAAoB,GAAGN,gBAAgB,CAACI,cAAc,CAACG,2BAA2B,CAAC,CAAC,CAAC,CAACC,KAAK;EACjG,MAAMC,8BAA8B,GAClCT,gBAAgB,CAACU,qBAAqB,CAACC,iBAAiB,CAACC,aAAa;;EAExE;EACA,IACEhB,8BAA8B,CAACI,gBAAgB,EAAEE,IAAI,CAAC,IACtDL,kCAAkC,CAACG,gBAAgB,EAAEE,IAAI,CAAC,IAC1DP,oCAAoC,CAClCO,IAAI,EACJC,mBAAmB,CAACU,KAAK,EACzBb,gBAAgB,CAACc,qBAAqB,CAACC,qBACzC,CAAC,IACDrB,kCAAkC,CAACQ,IAAI,EAAEC,mBAAmB,CAACa,WAAW,CAAC,IACzEb,mBAAmB,CAACc,UAAU,CAACC,QAAQ,CAAChB,IAAI,CAAC,IAC7CI,oBAAoB,CAACY,QAAQ,CAACjB,WAAW,CAAC,IAC1CH,4BAA4B,CAACE,gBAAgB,EAAEE,IAAI,CAAC,IACpDD,WAAW,CAACkB,QAAQ,CAAC,MAAM,CAAC,IAC5BzB,kCAAkC,CAACO,WAAW,EAAEQ,8BAA8B,CAAC,EAC/E;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASW,qBAAqBA,CAACpB,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,EAAE;EACzE,IAAIH,wBAAwB,CAACC,gBAAgB,EAAEC,WAAW,EAAEC,IAAI,CAAC,EAAE;IACjE,OAAO,IAAI;EACb;EACA;EACA,OAAOD,WAAW,CAACoB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACjC","ignoreList":[]}

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

@@ -1,22 +1,16 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _lodash = require("lodash");
-var _index = require("../../../index");
-var _functionWords = require("../config/functionWords");
-var _nonParticiples = _interopRequireDefault(require("../config/internal/nonParticiples"));
-var _getParticiples = _interopRequireDefault(require("../helpers/internal/getParticiples"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { includes } from 'lodash';
+import { languageProcessing } from "../../../../index.js";
 const {
   directPrecedenceException,
   values
-} = _index.languageProcessing;
+} = languageProcessing;
 const {
   Clause
 } = values;
+import { cannotDirectlyPrecedePassiveParticiple } from "../config/functionWords";
+import nonParticiples from "../config/internal/nonParticiples";
+import getParticiples from "../helpers/internal/getParticiples";
+
 /**
  * Creates a Clause object for the Dutch language.
  */
@@ -31,7 +25,7 @@ class DutchClause extends Clause {
    */
   constructor(clauseText, auxiliaries) {
     super(clauseText, auxiliaries);
-    this._participles = (0, _getParticiples.default)(this.getClauseText());
+    this._participles = getParticiples(this.getClauseText());
     this.checkParticiples();
   }
 
@@ -43,7 +37,7 @@ class DutchClause extends Clause {
    */
   checkParticiples() {
     const foundParticiples = this.getParticiples().filter(participle => {
-      return !(0, _lodash.includes)(_nonParticiples.default, participle) && !this.hasNonParticipleEnding(participle) && !directPrecedenceException(this.getClauseText(), participle, _functionWords.cannotDirectlyPrecedePassiveParticiple);
+      return !includes(nonParticiples, participle) && !this.hasNonParticipleEnding(participle) && !directPrecedenceException(this.getClauseText(), participle, cannotDirectlyPrecedePassiveParticiple);
     });
     this.setPassive(foundParticiples.length > 0);
   }
@@ -59,5 +53,5 @@ class DutchClause extends Clause {
     return /\S+(heid|teit|tijd)($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi.test(participle);
   }
 }
-var _default = exports.default = DutchClause;
+export default DutchClause;
 //# sourceMappingURL=Clause.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"Clause.js","names":["_lodash","require","_index","_functionWords","_nonParticiples","_interopRequireDefault","_getParticiples","e","__esModule","default","directPrecedenceException","values","languageProcessing","Clause","DutchClause","constructor","clauseText","auxiliaries","_participles","getParticiples","getClauseText","checkParticiples","foundParticiples","filter","participle","includes","nonParticiples","hasNonParticipleEnding","cannotDirectlyPrecedePassiveParticiple","setPassive","length","test","_default","exports"],"sources":["../../../../../src/languageProcessing/languages/nl/values/Clause.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '../../../index';\nconst {directPrecedenceException, values} = languageProcessing;\nconst {Clause} = values;\n\nimport {cannotDirectlyPrecedePassiveParticiple} from '../config/functionWords';\nimport nonParticiples from '../config/internal/nonParticiples';\nimport getParticiples from '../helpers/internal/getParticiples';\n\n/**\n * Creates a Clause object for the Dutch language.\n */\nclass DutchClause extends Clause {\n  /**\n   * Constructor.\n   *\n   * @param {string} clauseText   The text of the clause.\n   * @param {Array} auxiliaries   The auxiliaries.\n   *\n   * @constructor\n   */\n  constructor(clauseText, auxiliaries) {\n    super(clauseText, auxiliaries);\n    this._participles = getParticiples(this.getClauseText());\n    this.checkParticiples();\n  }\n\n  /**\n   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.\n   * If no exceptions are found and there is an auxiliary present, the clause is passive.\n   *\n   * @returns {void}\n   */\n  checkParticiples() {\n    const foundParticiples = this.getParticiples().filter(participle => {\n      return (\n        !includes(nonParticiples, participle) &&\n        !this.hasNonParticipleEnding(participle) &&\n        !directPrecedenceException(\n          this.getClauseText(),\n          participle,\n          cannotDirectlyPrecedePassiveParticiple\n        )\n      );\n    });\n\n    this.setPassive(foundParticiples.length > 0);\n  }\n\n  /**\n   * Checks whether a found participle has a non-participle ending and is therefore not really a participle.\n   *\n   * @param {string} participle   The participle to check.\n   *\n   * @returns {boolean} Returns true if the participle has a non-participle ending, otherwise returns false.\n   */\n  hasNonParticipleEnding(participle) {\n    return /\\S+(heid|teit|tijd)($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi.test(participle);\n  }\n}\n\nexport default DutchClause;\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAIA,IAAAE,cAAA,GAAAF,OAAA;AACA,IAAAG,eAAA,GAAAC,sBAAA,CAAAJ,OAAA;AACA,IAAAK,eAAA,GAAAD,sBAAA,CAAAJ,OAAA;AAAgE,SAAAI,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AALhE,MAAM;EAACG,yBAAyB;EAAEC;AAAM,CAAC,GAAGC,yBAAkB;AAC9D,MAAM;EAACC;AAAM,CAAC,GAAGF,MAAM;AAMvB;AACA;AACA;AACA,MAAMG,WAAW,SAASD,MAAM,CAAC;EAC/B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,WAAWA,CAACC,UAAU,EAAEC,WAAW,EAAE;IACnC,KAAK,CAACD,UAAU,EAAEC,WAAW,CAAC;IAC9B,IAAI,CAACC,YAAY,GAAG,IAAAC,uBAAc,EAAC,IAAI,CAACC,aAAa,CAAC,CAAC,CAAC;IACxD,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEA,gBAAgBA,CAAA,EAAG;IACjB,MAAMC,gBAAgB,GAAG,IAAI,CAACH,cAAc,CAAC,CAAC,CAACI,MAAM,CAACC,UAAU,IAAI;MAClE,OACE,CAAC,IAAAC,gBAAQ,EAACC,uBAAc,EAAEF,UAAU,CAAC,IACrC,CAAC,IAAI,CAACG,sBAAsB,CAACH,UAAU,CAAC,IACxC,CAACd,yBAAyB,CACxB,IAAI,CAACU,aAAa,CAAC,CAAC,EACpBI,UAAU,EACVI,qDACF,CAAC;IAEL,CAAC,CAAC;IAEF,IAAI,CAACC,UAAU,CAACP,gBAAgB,CAACQ,MAAM,GAAG,CAAC,CAAC;EAC9C;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEH,sBAAsBA,CAACH,UAAU,EAAE;IACjC,OAAO,wDAAwD,CAACO,IAAI,CAACP,UAAU,CAAC;EAClF;AACF;AAAC,IAAAQ,QAAA,GAAAC,OAAA,CAAAxB,OAAA,GAEcK,WAAW","ignoreList":[]}
+{"version":3,"file":"Clause.js","names":["includes","languageProcessing","directPrecedenceException","values","Clause","cannotDirectlyPrecedePassiveParticiple","nonParticiples","getParticiples","DutchClause","constructor","clauseText","auxiliaries","_participles","getClauseText","checkParticiples","foundParticiples","filter","participle","hasNonParticipleEnding","setPassive","length","test"],"sources":["../../../../../src/languageProcessing/languages/nl/values/Clause.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {directPrecedenceException, values} = languageProcessing;\nconst {Clause} = values;\n\nimport {cannotDirectlyPrecedePassiveParticiple} from '../config/functionWords';\nimport nonParticiples from '../config/internal/nonParticiples';\nimport getParticiples from '../helpers/internal/getParticiples';\n\n/**\n * Creates a Clause object for the Dutch language.\n */\nclass DutchClause extends Clause {\n  /**\n   * Constructor.\n   *\n   * @param {string} clauseText   The text of the clause.\n   * @param {Array} auxiliaries   The auxiliaries.\n   *\n   * @constructor\n   */\n  constructor(clauseText, auxiliaries) {\n    super(clauseText, auxiliaries);\n    this._participles = getParticiples(this.getClauseText());\n    this.checkParticiples();\n  }\n\n  /**\n   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.\n   * If no exceptions are found and there is an auxiliary present, the clause is passive.\n   *\n   * @returns {void}\n   */\n  checkParticiples() {\n    const foundParticiples = this.getParticiples().filter(participle => {\n      return (\n        !includes(nonParticiples, participle) &&\n        !this.hasNonParticipleEnding(participle) &&\n        !directPrecedenceException(\n          this.getClauseText(),\n          participle,\n          cannotDirectlyPrecedePassiveParticiple\n        )\n      );\n    });\n\n    this.setPassive(foundParticiples.length > 0);\n  }\n\n  /**\n   * Checks whether a found participle has a non-participle ending and is therefore not really a participle.\n   *\n   * @param {string} participle   The participle to check.\n   *\n   * @returns {boolean} Returns true if the participle has a non-participle ending, otherwise returns false.\n   */\n  hasNonParticipleEnding(participle) {\n    return /\\S+(heid|teit|tijd)($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi.test(participle);\n  }\n}\n\nexport default DutchClause;\n"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,QAAQ;AAC/B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,yBAAyB;EAAEC;AAAM,CAAC,GAAGF,kBAAkB;AAC9D,MAAM;EAACG;AAAM,CAAC,GAAGD,MAAM;AAEvB,SAAQE,sCAAsC;AAC9C,OAAOC,cAAc;AACrB,OAAOC,cAAc;;AAErB;AACA;AACA;AACA,MAAMC,WAAW,SAASJ,MAAM,CAAC;EAC/B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEK,WAAWA,CAACC,UAAU,EAAEC,WAAW,EAAE;IACnC,KAAK,CAACD,UAAU,EAAEC,WAAW,CAAC;IAC9B,IAAI,CAACC,YAAY,GAAGL,cAAc,CAAC,IAAI,CAACM,aAAa,CAAC,CAAC,CAAC;IACxD,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEA,gBAAgBA,CAAA,EAAG;IACjB,MAAMC,gBAAgB,GAAG,IAAI,CAACR,cAAc,CAAC,CAAC,CAACS,MAAM,CAACC,UAAU,IAAI;MAClE,OACE,CAACjB,QAAQ,CAACM,cAAc,EAAEW,UAAU,CAAC,IACrC,CAAC,IAAI,CAACC,sBAAsB,CAACD,UAAU,CAAC,IACxC,CAACf,yBAAyB,CACxB,IAAI,CAACW,aAAa,CAAC,CAAC,EACpBI,UAAU,EACVZ,sCACF,CAAC;IAEL,CAAC,CAAC;IAEF,IAAI,CAACc,UAAU,CAACJ,gBAAgB,CAACK,MAAM,GAAG,CAAC,CAAC;EAC9C;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEF,sBAAsBA,CAACD,UAAU,EAAE;IACjC,OAAO,wDAAwD,CAACI,IAAI,CAACJ,UAAU,CAAC;EAClF;AACF;AAEA,eAAeT,WAAW","ignoreList":[]}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"Researcher.js","names":["_index","require","_firstWordExceptions","_interopRequireDefault","_functionWords","_stopWords","_transitionWords","_twoPartTransitionWords","_sentenceLength","_getClauses","_getStemmer","e","__esModule","default","AbstractResearcher","languageProcessing","Researcher","constructor","paper","defaultResearches","getFleschReadingScore","Object","assign","config","language","passiveConstructionType","firstWordExceptions","functionWords","stopWords","transitionWords","twoPartTransitionWords","sentenceLength","helpers","getClauses","getStemmer","exports"],"sources":["../../../../src/languageProcessing/languages/pl/Researcher.js"],"sourcesContent":["import {languageProcessing} from '../../../index';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport stopWords from './config/stopWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport sentenceLength from './config/sentenceLength';\n\n// All helpers\nimport getClauses from './helpers/getClauses';\nimport getStemmer from './helpers/getStemmer';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    // Delete a research(es) that is not available in Polish\n    delete this.defaultResearches.getFleschReadingScore;\n\n    Object.assign(this.config, {\n      language: 'pl',\n      passiveConstructionType: 'periphrastic',\n      firstWordExceptions,\n      functionWords,\n      stopWords,\n      transitionWords,\n      twoPartTransitionWords,\n      sentenceLength: sentenceLength\n    });\n\n    Object.assign(this.helpers, {\n      getClauses,\n      getStemmer\n    });\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAIA,IAAAC,oBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,gBAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,uBAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,eAAA,GAAAL,sBAAA,CAAAF,OAAA;AAGA,IAAAQ,WAAA,GAAAN,sBAAA,CAAAF,OAAA;AACA,IAAAS,WAAA,GAAAP,sBAAA,CAAAF,OAAA;AAA8C,SAAAE,uBAAAQ,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAZ9C,MAAM;EAACG;AAAkB,CAAC,GAAGC,yBAAkB;;AAE/C;;AAQA;;AAIA;AACA;AACA;AACe,MAAMC,UAAU,SAASF,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEG,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;;IAEZ;IACA,OAAO,IAAI,CAACC,iBAAiB,CAACC,qBAAqB;IAEnDC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,cAAc;MACvCC,mBAAmB,EAAnBA,4BAAmB;MACnBC,aAAa,EAAbA,kBAAa;MACbC,SAAS,EAATA,kBAAS;MACTC,eAAe,EAAfA,wBAAe;MACfC,sBAAsB,EAAtBA,+BAAsB;MACtBC,cAAc,EAAEA;IAClB,CAAC,CAAC;IAEFV,MAAM,CAACC,MAAM,CAAC,IAAI,CAACU,OAAO,EAAE;MAC1BC,UAAU,EAAVA,mBAAU;MACVC,UAAU,EAAVA;IACF,CAAC,CAAC;EACJ;AACF;AAACC,OAAA,CAAAtB,OAAA,GAAAG,UAAA","ignoreList":[]}
+{"version":3,"file":"Researcher.js","names":["languageProcessing","AbstractResearcher","firstWordExceptions","all","functionWords","stopWords","transitionWords","twoPartTransitionWords","sentenceLength","getClauses","getStemmer","Researcher","constructor","paper","defaultResearches","getFleschReadingScore","Object","assign","config","language","passiveConstructionType","helpers"],"sources":["../../../../src/languageProcessing/languages/pl/Researcher.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport stopWords from './config/stopWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport sentenceLength from './config/sentenceLength';\n\n// All helpers\nimport getClauses from './helpers/getClauses';\nimport getStemmer from './helpers/getStemmer';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    // Delete a research(es) that is not available in Polish\n    delete this.defaultResearches.getFleschReadingScore;\n\n    Object.assign(this.config, {\n      language: 'pl',\n      passiveConstructionType: 'periphrastic',\n      firstWordExceptions,\n      functionWords,\n      stopWords,\n      transitionWords,\n      twoPartTransitionWords,\n      sentenceLength: sentenceLength\n    });\n\n    Object.assign(this.helpers, {\n      getClauses,\n      getStemmer\n    });\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAkB,CAAC,GAAGD,kBAAkB;;AAE/C;AACA,OAAOE,mBAAmB;AAC1B,SAAQC,GAAG,IAAIC,aAAa;AAC5B,OAAOC,SAAS;AAChB,OAAOC,eAAe;AACtB,OAAOC,sBAAsB;AAC7B,OAAOC,cAAc;;AAErB;AACA,OAAOC,UAAU;AACjB,OAAOC,UAAU;;AAEjB;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASV,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEW,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;;IAEZ;IACA,OAAO,IAAI,CAACC,iBAAiB,CAACC,qBAAqB;IAEnDC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,cAAc;MACvClB,mBAAmB;MACnBE,aAAa;MACbC,SAAS;MACTC,eAAe;MACfC,sBAAsB;MACtBC,cAAc,EAAEA;IAClB,CAAC,CAAC;IAEFQ,MAAM,CAACC,MAAM,CAAC,IAAI,CAACI,OAAO,EAAE;MAC1BZ,UAAU;MACVC;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

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

@@ -1,14 +1,8 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
 /**
  *  Returns an array with exceptions for the sentence beginning researcher.
  *  @returns {Array} The array filled with exceptions.
  *  */
-var _default = exports.default = [
+export default [
 // Numbers 1-10:
 "jeden", "jedna", "jedno", "dwa", "dwie", "trzy", "cztery", "pięć", "sześć", "siedem", "osiem", "dziewięć", "dziesięć",
 // Demonstrative pronouns:

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

@@ -1 +1 @@
-{"version":3,"file":"firstWordExceptions.js","names":["_default","exports","default"],"sources":["../../../../../src/languageProcessing/languages/pl/config/firstWordExceptions.js"],"sourcesContent":["/**\n *  Returns an array with exceptions for the sentence beginning researcher.\n *  @returns {Array} The array filled with exceptions.\n *  */\nexport default [\n\t// Numbers 1-10:\n\t\"jeden\", \"jedna\", \"jedno\", \"dwa\", \"dwie\", \"trzy\", \"cztery\", \"pięć\", \"sześć\", \"siedem\", \"osiem\", \"dziewięć\", \"dziesięć\",\n\t// Demonstrative pronouns:\n\t\"ta\", \"to\", \"ten\", \"te\", \"ci\", \"taki\", \"tacy\", \"taka\", \"taką\", \"takich\", \"takie\", \"takiego\", \"takiej\", \"takiemu\",\n\t\"takim\", \"takimi\", \"tamten\", \"tamta\", \"tamto\", \"tamci\", \"tamte\", \"tamtą\", \"tamtego\", \"tamtej\", \"tamtemu\", \"tamtych\",\n\t\"tamtym\", \"tamtymi\", \"tą\", \"tę\", \"tego\", \"tej\", \"temu\", \"tych\", \"tymi\", \"tym\", \"tak\",\n];\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AAHA,IAAAA,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAIe;AACd;AACA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU;AACtH;AACA,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAChH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EACnH,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CACpF","ignoreList":[]}
+{"version":3,"file":"firstWordExceptions.js","names":[],"sources":["../../../../../src/languageProcessing/languages/pl/config/firstWordExceptions.js"],"sourcesContent":["/**\n *  Returns an array with exceptions for the sentence beginning researcher.\n *  @returns {Array} The array filled with exceptions.\n *  */\nexport default [\n\t// Numbers 1-10:\n\t\"jeden\", \"jedna\", \"jedno\", \"dwa\", \"dwie\", \"trzy\", \"cztery\", \"pięć\", \"sześć\", \"siedem\", \"osiem\", \"dziewięć\", \"dziesięć\",\n\t// Demonstrative pronouns:\n\t\"ta\", \"to\", \"ten\", \"te\", \"ci\", \"taki\", \"tacy\", \"taka\", \"taką\", \"takich\", \"takie\", \"takiego\", \"takiej\", \"takiemu\",\n\t\"takim\", \"takimi\", \"tamten\", \"tamta\", \"tamto\", \"tamci\", \"tamte\", \"tamtą\", \"tamtego\", \"tamtej\", \"tamtemu\", \"tamtych\",\n\t\"tamtym\", \"tamtymi\", \"tą\", \"tę\", \"tego\", \"tej\", \"temu\", \"tych\", \"tymi\", \"tym\", \"tak\",\n];\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA,eAAe;AACd;AACA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU;AACtH;AACA,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAChH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EACnH,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CACpF","ignoreList":[]}

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

@@ -1,12 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.filteredAtEnding = exports.filteredAtBeginningAndEnding = exports.filteredAnywhere = exports.default = exports.cannotDirectlyPrecedePassiveParticiple = exports.cannotBeBetweenPassiveAuxiliaryAndParticiple = exports.all = void 0;
-var _transitionWords = require("./transitionWords.js");
-var _transformWordsWithHyphens = _interopRequireDefault(require("../../../helpers/transform/transformWordsWithHyphens"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { singleWords as transitionWords } from "./transitionWords.js";
+import transformWordsWithHyphens from "../../../helpers/transform/transformWordsWithHyphens";
 const cardinalNumerals = ["czterech", "czterem", "czterema", "czternaście", "czternastce", "czternastek", "czternastka", "czternastką", "czternastkach", "czternastkami", "czternastkę", "czternastki", "czternastko", "czternastkom", "czternastoma", "czternastu", "cztery", "czwórce", "czwórek", "czwórka", "czwórką", "czwórkach", "czwórkami", "czwórkę", "czwórki", "czwórko", "czwórkom", "czworo", "dwa", "dwadzieścia", "dwanaście", "dwie", "dwiema", "dwóch", "dwójce", "dwoje", "dwójek", "dwójka", "dwójką", "dwójkach", "dwójkami", "dwójki", "dwójko", "dwójkom", "dwóm", "dwoma", "dwudziestce", "dwudziestek", "dwudziestka", "dwudziestką", "dwudziestkach", "dwudziestkami", "dwudziestkę", "dwudziestki", "dwudziestkom", "dwudziestoma", "dwudziestu", "dwunastce", "dwunastek", "dwunastka", "dwunastką", "dwunastkach", "dwunastkami", "dwunastkę", "dwunastki", "dwunastko", "dwunastkom", "dwunastoma", "dwunastu", "dziesiątce", "dziesiątek", "dziesiątka", "dziesiątką", "dziesiątkach", "dziesiątkami", "dziesiątkę", "dziesiątki", "dziesiątko", "dziesiątkom", "dziesięć", "dziesięcioma", "dziesięciu", "dziewiątce", "dziewiątek", "dziewiątka", "dziewiątką", "dziewiątkach", "dziewiątkami", "dziewiątkę", "dziewiątki", "dziewiątko", "dziewiątkom", "dziewięć", "dziewięcioma", "dziewięciorga", "dziewięciorgiem", "dziewięciorgu", "dziewięcioro", "dziewięciu", "dziewiętnaście", "dziewiętnastce", "dziewiętnastek", "dziewiętnastka", "dziewiętnastką", "dziewiętnastkach", "dziewiętnastkami", "dziewiętnastkę", "dziewiętnastki", "dziewiętnastkom", "dziewiętnastoma", "dziewiętnastu", "jeden", "jedenaście", "jedenastce", "jedenastek", "jedenastka", "jedenastką", "jedenastkach", "jedenastkami", "jedenastkę", "jedenastki", "jedenastko", "jedenastkom", "jedenastoma", "jedenastu", "jedna", "jedną", "jednego", "jednej", "jednemu", "jedno", "jednym", "jedynce", "jedynek", "jedynka", "jedynką", "jedynkach", "jedynkami", "jedynkę", "jedynki", "jedynko", "jedynkom", "miliard", "miliarda", "miliardach", "miliardami", "miliardem", "miliardom", "miliardów", "miliardowi", "miliardy", "miliardzie", "milion", "miliona", "milionach", "milionami", "milionem", "milionie", "milionom", "milionów", "milionowi", "miliony", "ósemce", "ósemek", "ósemka", "ósemką", "ósemkach", "ósemkami", "ósemkę", "ósemki", "ósemko", "ósemkom", "osiem", "osiemnaście", "osiemnastce", "osiemnastek", "osiemnastka", "osiemnastką", "osiemnastkach", "osiemnastkam", "osiemnastkę", "osiemnastki", "osiemnastko", "osiemnastkom", "osiemnastoma", "osiemnastu", "ośmioma", "ośmiorga", "ośmiorgiem", "ośmiorgu", "ośmioro", "ośmiu", "piątce", "piątek", "piątka", "piątką", "piątkach", "piątkami", "piątkę", "piątki", "piątko", "piątkom", "pięć", "pięcioma", "pięciorga", "pięciorgiem", "pięciorgu", "pięcioro", "pięciu", "piętnaście", "piętnastce", "piętnastek", "piętnastka", "piętnastką", "piętnastkach", "piętnastkami", "piętnastkę", "piętnastki", "piętnastko", "piętnastkom", "piętnastoma", "piętnastu", "raz", "setce", "setek", "setka", "setkach", "setkami", "setkę", "setki", "setkom", "siedem", "siedemnaście", "siedemnastce", "siedemnastek", "siedemnastka", "siedemnastką", "siedemnastkach", "siedemnastkami", "siedemnastkę", "siedemnastki", "siedemnastko", "siedemnastkom", "siedemnastoma", "siedemnastu", "siedmioma", "siedmiorga", "siedmiorgiem", "siedmiorgu", "siedmioro", "siedmiu", "siódemce", "siódemek", "siódemka", "siódemką", "siódemkach", "siódemkami", "siódemkę", "siódemki", "siódemko", "siódemkom", "sto", "stoma", "stu", "sześć", "sześcioma", "sześciorga", "sześciorgiem", "sześciorgu", "sześcioro", "sześciu", "szesnaście", "szesnastce", "szesnastek", "szesnastka", "szesnastką", "szesnastkach", "szesnastkami", "szesnastkę", "szesnastki", "szesnastko", "szesnastkom", "szesnastoma", "szesnastu", "szóstce", "szóstek", "szóstka", "szóstką", "szóstkach", "szóstkami", "szóstkę", "szóstki", "szóstko", "szóstkom", "trójce", "troje", "trójek", "trójka", "trójką", "trójkach", "trójkami", "trójki", "trójko", "trójkom", "trzech", "trzem", "trzema", "trzy", "trzynaście", "trzynastce", "trzynastek", "trzynastka", "trzynastką", "trzynastkach", "trzynastkami", "trzynastkę", "trzynastki", "trzynastko", "trzynastkom", "trzynastoma", "trzynastu", "tysiąc", "tysiąca", "tysiącach", "tysiącami", "tysiące", "tysiącem", "tysiącom", "tysiącowi", "tysiącu", "tysięcy"];
 const ordinalNumerals = ["czternaści", "czternasta", "czternastą", "czternaste", "czternastego", "czternastej", "czternastemu", "czternasty", "czternastych", "czternastym", "czternastymi", "czwarci", "czwarta", "czwartą", "czwarte", "czwartego", "czwartej", "czwartemu", "czwarty", "czwartych", "czwartym", "czwartymi", "drudzy", "druga", "drugą", "drugi", "drugich", "drugie", "drugiego", "drugiej", "drugiemu", "drugim", "drugimi", "dwudzieści", "dwudziesta", "dwudziestą", "dwudzieste", "dwudziestego", "dwudziestej", "dwudziestemu", "dwudziesty", "dwudziestych", "dwudziestym", "dwudziestymi", "dwunaści", "dwunasta", "dwunastą", "dwunaste", "dwunastego", "dwunastej", "dwunastemu", "dwunasty", "dwunastych", "dwunastym", "dwunastymi", "dziesiąci", "dziesiąta", "dziesiątą", "dziesiąte", "dziesiątego", "dziesiątej", "dziesiątemu", "dziesiąty", "dziesiątych", "dziesiątym", "dziesiątymi", "dziewiąci", "dziewiąta", "dziewiątą", "dziewiąte", "dziewiątego", "dziewiątej", "dziewiątemu", "dziewiąty", "dziewiątych", "dziewiątym", "dziewiątymi", "dziewiętnaści", "dziewiętnasta", "dziewiętnastą", "dziewiętnaste", "dziewiętnastego", "dziewiętnastej", "dziewiętnastemu", "dziewiętnasty", "dziewiętnastych", "dziewiętnastym", "dziewiętnastymi", "jedenaści", "jedenasta", "jedenastą", "jedenaste", "jedenastego", "jedenastej", "jedenastemu", "jedenasty", "jedenastych", "jedenastym", "jedenastymi", "osiemnaści", "osiemnasta", "osiemnastą", "osiemnaste", "osiemnastego", "osiemnastej", "osiemnastemu", "osiemnasty", "osiemnastych", "osiemnastym", "osiemnastymi", "ósma", "ósmą", "ósme", "ósmego", "ósmej", "ósmemu", "óśmi", "ósmy", "ósmych", "ósmym", "ósmymi", "piąci", "piąta", "piątą", "piąte", "piątego", "piątej", "piątemu", "piąty", "piątych", "piątym", "piątymi", "pierwsi", "pierwsza", "pierwszą", "pierwsze", "pierwszego", "pierwszej", "pierwszemu", "pierwszy", "pierwszych", "pierwszym", "pierwszymi", "piętnaści", "piętnasta", "piętnastą", "piętnaste", "piętnastego", "piętnastej", "piętnastemu", "piętnasty", "piętnastych", "piętnastym", "piętnastymi", "siedemnaści", "siedemnasta", "siedemnastą", "siedemnaste", "siedemnastego", "siedemnastej", "siedemnastemu", "siedemnasty", "siedemnastych", "siedemnastym", "siedemnastymi", "siódma", "siódmą", "siódme", "siódmego", "siódmej", "siódmemu", "siódmi", "siódmy", "siódmych", "siódmym", "siódmymi", "szesnaści", "szesnasta", "szesnastą", "szesnaste", "szesnastego", "szesnastej", "szesnastemu", "szesnasty", "szesnastych", "szesnastymi", "szóści", "szósta", "szóstą", "szóste", "szóstego", "szóstej", "szóstemu", "szósty", "szóstych", "szóstym", "szóstymi", "trzeci", "trzecia", "trzecią", "trzecich", "trzecie", "trzeciego", "trzeciej", "trzeciemu", "trzecim", "trzecimi", "trzynaści", "trzynasta", "trzynastą", "trzynaste", "trzynastego", "trzynastej", "trzynastemu", "trzynasty", "trzynastych", "trzynastym", "trzynastymi"];
 const personalPronounsNominative = ["ja", "my", "on", "ona", "one", "oni", "ono", "ty", "wy"];
@@ -51,23 +44,23 @@ const measurementUnits = ["°C", "°F", "ar", "ary", "arów", "arach", "c", "cl"
 const miscellaneous = ["nie", "no", "oto", "tak", "sobie", "ok", "okej", "itp", "itd", "tzw"];
 
 // These word categories are filtered at the ending of word combinations.
-const filteredAtEnding = exports.filteredAtEnding = (0, _transformWordsWithHyphens.default)([].concat(ordinalNumerals, generalAdjectives, generalAdverbs, delexicalisedVerbsInfinitive, otherAuxiliariesInfinitive, passiveAuxiliariesInfinitive));
+export const filteredAtEnding = transformWordsWithHyphens([].concat(ordinalNumerals, generalAdjectives, generalAdverbs, delexicalisedVerbsInfinitive, otherAuxiliariesInfinitive, passiveAuxiliariesInfinitive));
 
 // These word categories are filtered at the beginning and ending of word combinations.
-const filteredAtBeginningAndEnding = exports.filteredAtBeginningAndEnding = (0, _transformWordsWithHyphens.default)([].concat(prepositions, coordinatingConjunctions, demonstrativePronouns, quantifiers, intensifiers, possessivePronouns, reflexivePronounsNominative, reflexivePronounsOther));
+export const filteredAtBeginningAndEnding = transformWordsWithHyphens([].concat(prepositions, coordinatingConjunctions, demonstrativePronouns, quantifiers, intensifiers, possessivePronouns, reflexivePronounsNominative, reflexivePronounsOther));
 
 // These word categories are filtered everywhere within word combinations.
-const filteredAnywhere = exports.filteredAnywhere = (0, _transformWordsWithHyphens.default)([].concat(_transitionWords.singleWords, additionalTransitionWords, cardinalNumerals, personalPronounsNominative, personalPronounsAccusative, personalPronounsGenitive, personalPronounsDative, personalPronounsInstrumental, personalPronounsPast, personalPronounsPrepositional, interrogativePronouns, interrogativeProAdverbs, interrogativeDeterminers, indefinitePronouns, adverbialGenitives, prepositionalAdverbs, subordinatingConjunctions, delexicalizedVerbs, interviewVerbs, timeWords, vagueNouns, titles, interjections, measurementUnits, miscellaneous, otherAuxiliaries));
+export const filteredAnywhere = transformWordsWithHyphens([].concat(transitionWords, additionalTransitionWords, cardinalNumerals, personalPronounsNominative, personalPronounsAccusative, personalPronounsGenitive, personalPronounsDative, personalPronounsInstrumental, personalPronounsPast, personalPronounsPrepositional, interrogativePronouns, interrogativeProAdverbs, interrogativeDeterminers, indefinitePronouns, adverbialGenitives, prepositionalAdverbs, subordinatingConjunctions, delexicalizedVerbs, interviewVerbs, timeWords, vagueNouns, titles, interjections, measurementUnits, miscellaneous, otherAuxiliaries));
 
 // These word categories cannot directly precede a passive participle.
-const cannotDirectlyPrecedePassiveParticiple = exports.cannotDirectlyPrecedePassiveParticiple = (0, _transformWordsWithHyphens.default)([].concat(prepositions, personalPronounsPast, possessivePronouns, cardinalNumerals, ordinalNumerals, delexicalizedVerbs, delexicalisedVerbsInfinitive, interviewVerbs, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs));
+export const cannotDirectlyPrecedePassiveParticiple = transformWordsWithHyphens([].concat(prepositions, personalPronounsPast, possessivePronouns, cardinalNumerals, ordinalNumerals, delexicalizedVerbs, delexicalisedVerbsInfinitive, interviewVerbs, interrogativeDeterminers, interrogativePronouns, interrogativeProAdverbs));
 
 // These word categories cannot intervene between an auxiliary and a corresponding passive participle.
-const cannotBeBetweenPassiveAuxiliaryAndParticiple = exports.cannotBeBetweenPassiveAuxiliaryAndParticiple = (0, _transformWordsWithHyphens.default)([].concat(otherAuxiliaries, otherAuxiliariesInfinitive, reflexivePronounsNominative));
+export const cannotBeBetweenPassiveAuxiliaryAndParticiple = transformWordsWithHyphens([].concat(otherAuxiliaries, otherAuxiliariesInfinitive, reflexivePronounsNominative));
 
 // This export contains all of the above words.
-const all = exports.all = (0, _transformWordsWithHyphens.default)([].concat(_transitionWords.singleWords, additionalTransitionWords, cardinalNumerals, personalPronounsNominative, personalPronounsAccusative, personalPronounsGenitive, personalPronounsDative, personalPronounsInstrumental, personalPronounsPast, personalPronounsPrepositional, interrogativePronouns, interrogativeProAdverbs, interrogativeDeterminers, indefinitePronouns, adverbialGenitives, otherAuxiliaries, prepositionalAdverbs, subordinatingConjunctions, delexicalizedVerbs, interviewVerbs, timeWords, vagueNouns, titles, interjections, measurementUnits, miscellaneous, passiveAuxiliaries, prepositions, coordinatingConjunctions, demonstrativePronouns, quantifiers, intensifiers, possessivePronouns, reflexivePronounsNominative, reflexivePronounsOther, ordinalNumerals, generalAdjectives, generalAdverbs, delexicalisedVerbsInfinitive, otherAuxiliariesInfinitive, passiveAuxiliariesInfinitive));
-var _default = exports.default = {
+export const all = transformWordsWithHyphens([].concat(transitionWords, additionalTransitionWords, cardinalNumerals, personalPronounsNominative, personalPronounsAccusative, personalPronounsGenitive, personalPronounsDative, personalPronounsInstrumental, personalPronounsPast, personalPronounsPrepositional, interrogativePronouns, interrogativeProAdverbs, interrogativeDeterminers, indefinitePronouns, adverbialGenitives, otherAuxiliaries, prepositionalAdverbs, subordinatingConjunctions, delexicalizedVerbs, interviewVerbs, timeWords, vagueNouns, titles, interjections, measurementUnits, miscellaneous, passiveAuxiliaries, prepositions, coordinatingConjunctions, demonstrativePronouns, quantifiers, intensifiers, possessivePronouns, reflexivePronounsNominative, reflexivePronounsOther, ordinalNumerals, generalAdjectives, generalAdverbs, delexicalisedVerbsInfinitive, otherAuxiliariesInfinitive, passiveAuxiliariesInfinitive));
+export default {
   filteredAtEnding,
   filteredAtBeginningAndEnding,
   filteredAnywhere,