axyseo 2.0.0-alpha.0.0.20 → 2.0.0-alpha.0.0.4

package/src/languageProcessing/languages/nl/helpers/internal/getStemWordsWithTAndDEnding.js

@@ -0,0 +1,183 @@
+import {languageProcessing} from '../../../index';
+const {
+  regexHelpers: {searchAndReplaceWithRegex, doesWordMatchRegex},
+  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
+} = languageProcessing;
+
+import {isVowelDoublingAllowed} from './stemModificationHelpers';
+
+/**
+ * Checks whether the word ends in suffixes -e or -en which are preceded by -t or -d, and the -t/-d is part of the stem.
+ * If it does, stem the -e/-en. Also checks if after suffix deletion the stemmed word needs modification, and applies it if
+ * needed. e.g. doden -> dod -> dood
+ *
+ * @param {Object} 		morphologyDataNL			 	The Dutch morphology data file.
+ * @param {string[]} 	regexAndReplacement				The regex to check and the string replacement that should be made.
+ * @param {string} 		word							The word to be checked.
+ *
+ * @returns {?string}							The stem created or null.
+ */
+const stemWordsWithEOrEnSuffix = function(morphologyDataNL, regexAndReplacement, word) {
+  if (doesWordMatchRegex(word, regexAndReplacement[0])) {
+    const stemmedWord = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);
+    if (
+      isVowelDoublingAllowed(
+        stemmedWord,
+        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
+        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
+      )
+    ) {
+      const replacement = searchAndReplaceWithRegex(
+        stemmedWord,
+        morphologyDataNL.regularStemmer.stemModifications.doubleVowel
+      );
+      return replacement ? replacement : stemmedWord;
+    }
+    return stemmedWord;
+  }
+
+  return null;
+};
+
+/**
+ * Stems words for which we know that -t/-d is the ending of the stem (so the -t/-d is not stemmed). This is done through
+ * checking lists of words and matching the word with regexes.
+ *
+ * @param {string}	word								The word to check.
+ * @param {Object} 	morphologyDataNL 					The Dutch morphology data.
+ *
+ * @returns {?string} 							The stemmed word, if matched in one of the checks, or null if not matched.
+ */
+const checkWhetherTOrDIsPartOfStem = function(word, morphologyDataNL) {
+  const tAndDPartOfStemData = morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem;
+  /*
+   * Step 1:
+   * - If the stem ends in -tte, -tten, -dde or -dden leave the first -t/-d and stem the remaining ending.
+   * - Example: "katten" (-ten should be stemmed, leaving "kat").
+   */
+  let stemmedWord = searchAndReplaceWithRegex(word, tAndDPartOfStemData.firstTOrDPartOfStem);
+
+  if (stemmedWord) {
+    return stemmedWord;
+  }
+
+  /*
+   * Step 2:
+   * 2a)
+   * - Checks whether the word is in the exception list of verbal forms ending in long vowel + -fden/sden. If so, stems -den off.
+   * - Example: "hoefden" (-den should be stemmed, leaving "hoef").
+   * 2b)
+   * - Check whether the word has the suffix -en preceded by -d, where the -d is part of the stem. If it is, stem only -en.
+   * - Example: "eenden" (-en should be stemmed, leaving "eend").
+   */
+  if (tAndDPartOfStemData.verbsDenShouldBeStemmed.includes(word)) {
+    return word.slice(0, -3);
+  }
+
+  if (
+    checkIfWordEndingIsOnExceptionList(
+      word,
+      tAndDPartOfStemData.wordsStemOnlyEnEnding.endingMatch
+    ) ||
+    checkIfWordIsOnListThatCanHavePrefix(
+      word,
+      tAndDPartOfStemData.wordsStemOnlyEnEnding.verbs,
+      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
+    ) ||
+    doesWordMatchRegex(word, tAndDPartOfStemData.denEnding)
+  ) {
+    stemmedWord = word.slice(0, -2);
+    //	Check if the vowel needs to be doubled after deleting suffix -en.
+    if (
+      isVowelDoublingAllowed(
+        stemmedWord,
+        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,
+        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes
+      )
+    ) {
+      const replacement = searchAndReplaceWithRegex(
+        stemmedWord,
+        morphologyDataNL.regularStemmer.stemModifications.doubleVowel
+      );
+      return replacement ? replacement : stemmedWord;
+    }
+    return stemmedWord;
+  }
+
+  /*
+   * Step 3:
+   * - Checks whether the word matches the regex for words ending in -de with -d being part of the stem. If it is matched,
+   * only stem the -e.
+   * - Example: "beenharde" (-e should be stemmed, leaving "beenhard")
+   */
+  const dIsPartOfStemRegex = tAndDPartOfStemData.deEnding;
+  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, dIsPartOfStemRegex, word);
+
+  if (stemmedWord) {
+    return stemmedWord;
+  }
+
+  /*
+   * Step 4:
+   * - Checks whether the word matches the regex for words ending in -te or -ten with -t being part of the stem. If it is
+   * matched, only stem the -e/-en.
+   * - Example: "castraten" (-en should be stemmed, leaving "castraat")
+   */
+  const tIsPartOfStemRegex = tAndDPartOfStemData.teAndTenEndings;
+  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, tIsPartOfStemRegex, word);
+
+  if (stemmedWord) {
+    return stemmedWord;
+  }
+
+  return null;
+};
+
+/**
+ * Creates the correct stem for words which end in ambiguous endings -t, -te, -ten, -de, or -den.
+ *
+ * @param {Object} 		morphologyDataNL 					The Dutch morphology data.
+ * @param {string} 		word								The word to be checked.
+ *
+ * @returns {?string} 	The stemmed word or null.
+ */
+export function generateCorrectStemWithTAndDEnding(morphologyDataNL, word) {
+  /*
+   * Step 1:
+   * - Check whether the word is in the exception list of words in which -t ending needs to be stemmed. If it is, stem -t.
+   * - Example: "squasht".
+   * - This is an exception to one of the rule in step 2.
+   */
+  if (
+    checkIfWordEndingIsOnExceptionList(
+      word,
+      morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed
+    )
+  ) {
+    return word.slice(0, -1);
+  }
+
+  /*
+   * Step 2:
+   * - Check if word is matched by a regex for a t that shouldn't be stemmed.
+   * - Example: "boot".
+   */
+  if (doesWordMatchRegex(word, morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding)) {
+    return word;
+  }
+
+  /*
+   * Step 3:
+   * - Check whether the word has another suffix that should be stemmed (e.g. -en) preceded by -t or -d which is part of the stem.
+   *  If yes, stem the suffix that should be stemmed and return the stem which ends in -t/-d.
+   * - Example: "tijden" (only -en should be removed, not -den).
+   */
+
+  const stemmedWord = checkWhetherTOrDIsPartOfStem(word, morphologyDataNL);
+
+  if (stemmedWord) {
+    return stemmedWord;
+  }
+
+  return null;
+}

package/src/languageProcessing/languages/nl/helpers/internal/stem.js

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

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

@@ -0,0 +1,109 @@
+import {languageProcessing} from '../../../index';
+const {
+  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
+} = languageProcessing;
+
+/**
+ * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,
+ * and verbs) and returns true if it is.
+ *
+ * @param {string}	word							The word to check.
+ * @param {Object}	noVowelDoublingList	The list of stems that should not have the vowel doubled.
+ * @param {Object}	compoundVerbPrefixes			The list of inseparable and separable verb prefixes.
+ *
+ * @returns {boolean} Whether the word was found on one of the lists
+ */
+const checkIfWordIsOnNoVowelDoublingList = function(
+  word,
+  noVowelDoublingList,
+  compoundVerbPrefixes
+) {
+  if (
+    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||
+    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||
+    noVowelDoublingList.exactMatch.includes(word)
+  ) {
+    return true;
+  }
+};
+
+/**
+ * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks
+ * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).
+ * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the
+ * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.
+ *
+ * @param {string} word The stemmed word to check.
+ *
+ * @returns {boolean} Whether the vowel should be doubled or not.
+ */
+const isVowelPrecededByDoubleConsonant = function(word) {
+  const fourthToLastLetter = word.charAt(word.length - 4);
+  const thirdToLastLetter = word.charAt(word.length - 3);
+  return fourthToLastLetter !== thirdToLastLetter;
+};
+
+/**
+ * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should
+ * not be doubled.
+ *
+ * @param {string} word                 The stemmed word to check.
+ * @param {string} noVowelDoublingRegex The regex to match a word with.
+ *
+ * @returns {boolean} Whether the vowel should be doubled or not.
+ */
+const doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {
+  return word.search(new RegExp(noVowelDoublingRegex)) === -1;
+};
+
+/**
+ * Modifies the stem of the word according to the specified modification type.
+ *
+ * @param {string} word The stem that needs to be modified.
+ * @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.
+ */
+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]);
+  }
+  return word;
+}
+
+/**
+ * Checks whether the final vowel of the stem should be doubled by going through four checks.
+ *
+ * @param {string}  word                               The stemmed word that the check should be executed on.
+ * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.
+ * @param {Object}  morphologyDataNLVerbPrefixes	   The separable and inseparable verb prefixes.
+ *
+ * @returns {boolean} Whether the vowel should be doubled or not.
+ */
+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
+  const secondCheck = checkIfWordIsOnNoVowelDoublingList(
+    word,
+    morphologyDataNLStemmingExceptions.noVowelDoubling,
+    morphologyDataNLVerbPrefixes
+  );
+  const thirdCheck = isVowelPrecededByDoubleConsonant(word);
+  const fourthCheck = doesPrecedingSyllableContainDiphthong(
+    word,
+    morphologyDataNLStemmingExceptions.noVowelDoubling.rule
+  );
+
+  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);
+}

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

@@ -0,0 +1,65 @@
+import {languageProcessing} from '../../../index';
+const {
+  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}
+} = 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.
+ * If one of these checks returns true, we do not need to stem the word further.
+ *
+ * @param {Object}  morphologyDataNL	The Dutch morphology data.
+ * @param {string}	stemmedWord			The stemmed word.
+ * @param {string}	word				The unstemmed word.
+ * @returns {boolean}	Whether one of the conditions returns true or not.
+ */
+const checkIfTorDIsUnambiguous = function(morphologyDataNL, stemmedWord, word) {
+  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;
+  const adjectivesEndingInRd = morphologyDataNL.stemExceptions.removeSuffixesFromFullForms[1].forms;
+  const wordsEndingInTOrDExceptionList =
+    morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.doNotStemTOrD;
+
+  // Run the checks below. If one of the conditions returns true, return the stem.
+  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;
+  }
+};
+
+/**
+ * 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
+ * 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.
+ * Therefore, a second stem should be created with the -t/-d removed in case it was a suffix. For example, in the verb 'poolt',
+ * -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,
+ * we stem the -t here.
+ *
+ * @param {Object}  morphologyDataNL	The Dutch morphology data.
+ * @param {string}	stemmedWord			The stemmed word.
+ * @param {string}	word				The unstemmed word.
+ *
+ * @returns {?string}				    The stemmed word or null if the -t/-d should not be stemmed.
+ */
+export function stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word) {
+  if (checkIfTorDIsUnambiguous(morphologyDataNL, stemmedWord, word)) {
+    return null;
+  }
+  // If none of the conditions above is true, stem the t/d from the word.
+  return stemmedWord.slice(0, -1);
+}

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

@@ -0,0 +1,62 @@
+import {includes} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {directPrecedenceException, values} = 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.
+ */
+class DutchClause extends Clause {
+  /**
+   * Constructor.
+   *
+   * @param {string} clauseText   The text of the clause.
+   * @param {Array} auxiliaries   The auxiliaries.
+   *
+   * @constructor
+   */
+  constructor(clauseText, auxiliaries) {
+    super(clauseText, auxiliaries);
+    this._participles = getParticiples(this.getClauseText());
+    this.checkParticiples();
+  }
+
+  /**
+   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
+   * If no exceptions are found and there is an auxiliary present, the clause is passive.
+   *
+   * @returns {void}
+   */
+  checkParticiples() {
+    const foundParticiples = this.getParticiples().filter(participle => {
+      return (
+        !includes(nonParticiples, participle) &&
+        !this.hasNonParticipleEnding(participle) &&
+        !directPrecedenceException(
+          this.getClauseText(),
+          participle,
+          cannotDirectlyPrecedePassiveParticiple
+        )
+      );
+    });
+
+    this.setPassive(foundParticiples.length > 0);
+  }
+
+  /**
+   * Checks whether a found participle has a non-participle ending and is therefore not really a participle.
+   *
+   * @param {string} participle   The participle to check.
+   *
+   * @returns {boolean} Returns true if the participle has a non-participle ending, otherwise returns false.
+   */
+  hasNonParticipleEnding(participle) {
+    return /\S+(heid|teit|tijd)($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi.test(participle);
+  }
+}
+
+export default DutchClause;

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

@@ -0,0 +1,47 @@
+import {languageProcessing} from '../../../index';
+const {AbstractResearcher} = 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.
+ */
+export default class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+
+    // Delete a research(es) that is not available in Polish
+    delete this.defaultResearches.getFleschReadingScore;
+
+    Object.assign(this.config, {
+      language: 'pl',
+      passiveConstructionType: 'periphrastic',
+      firstWordExceptions,
+      functionWords,
+      stopWords,
+      transitionWords,
+      twoPartTransitionWords,
+      sentenceLength: sentenceLength
+    });
+
+    Object.assign(this.helpers, {
+      getClauses,
+      getStemmer
+    });
+  }
+}

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

@@ -0,0 +1,12 @@
+/**
+ *  Returns an array with exceptions for the sentence beginning researcher.
+ *  @returns {Array} The array filled with exceptions.
+ *  */
+export default [
+	// Numbers 1-10:
+	"jeden", "jedna", "jedno", "dwa", "dwie", "trzy", "cztery", "pięć", "sześć", "siedem", "osiem", "dziewięć", "dziesięć",
+	// Demonstrative pronouns:
+	"ta", "to", "ten", "te", "ci", "taki", "tacy", "taka", "taką", "takich", "takie", "takiego", "takiej", "takiemu",
+	"takim", "takimi", "tamten", "tamta", "tamto", "tamci", "tamte", "tamtą", "tamtego", "tamtej", "tamtemu", "tamtych",
+	"tamtym", "tamtymi", "tą", "tę", "tego", "tej", "temu", "tych", "tymi", "tym", "tak",
+];