axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.20

package/build/languageProcessing/languages/id/helpers/internal/stem.js

@@ -0,0 +1,394 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stem;
+var _index = require("../../../../../index.js");
+var _stemHelpers = require("./stemHelpers");
+const {
+  flattenSortLength,
+  buildFormRule,
+  createRulesFromArrays
+} = _index.languageProcessing;
+/**
+ * MIT License
+ *
+ * Adapted from: Copyright (c) 2013 Adinda Praditya
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the \"Software\"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish,  distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,  EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
+ */
+
+/**
+ * Checks if a single syllable word has one of the suffixes/suffix combination.
+ *
+ * @param {string} word         The word to check.
+ * @param {Array} suffixesArray The array of suffixes
+ * @returns {boolean}   Whether the word ends in one of the suffixes or not.
+ */
+const checkSingleSyllableWordSuffix = function (word, suffixesArray) {
+  for (const suffix of suffixesArray) {
+    if (word.match(suffix)) {
+      return true;
+    }
+  }
+};
+
+/**
+ * Stems the prefix of the single syllable words, i.e. di-/penge-/menge-
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Indonesian morphology data file.
+ *
+ * @returns {string} The stemmed word.
+ */
+const stemSingleSyllableWordsPrefixes = function (word, morphologyData) {
+  // If the word gets prefix di-, stem the prefix here. E.g. dicekkanlah -> cekkanlah, dibomi -> bomi
+  if (word.startsWith('di') && (0, _stemHelpers.checkBeginningsList)(word, 2, morphologyData.stemming.singleSyllableWords)) {
+    return word.substring(2, word.length);
+  }
+  /*
+   * If the word gets prefix menge-/penge- and is followed by one of the words in the list, stem the prefix here.
+   * E.g. pengeboman -> boman
+   */
+  if (/^[mp]enge/i.test(word) && (0, _stemHelpers.checkBeginningsList)(word, 5, morphologyData.stemming.singleSyllableWords)) {
+    return word.substring(5, word.length);
+  }
+  return word;
+};
+
+/**
+ * Stems Indonesian single syllable words. This function concerns single syllable words
+ * with this possible word format [di/penge/menge] + single syllable word + [kan/an/i] + [ku/mu/nya] + [kah/lah/pun], with [] being optional.
+ * E.g. dipel -> pel, dipelkan -> pel, dipelkanlah -> pel, pelkan -> pel, pelmulah -> pel, pengeboman -> bom, mengesahkan -> sah
+ *
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Indonesian morphology data file.
+ *
+ * @returns {string} The stemmed word.
+ */
+const stemSingleSyllableWords = function (word, morphologyData) {
+  const singleSyllableWords = morphologyData.stemming.singleSyllableWords;
+  const suffixCombination = morphologyData.stemming.singleSyllableWordsSuffixes;
+  const inputWord = word;
+  // If the word starts with prefix di-/penge-/menge-, stem the prefix here. E.g. pengeboman -> boman, dipelkan -> pelkan
+  word = stemSingleSyllableWordsPrefixes(word, morphologyData);
+
+  // Check if a word starts with one of the words in the list, has maximum 3 syllables, and ends in one of the single syllable suffixes
+  if (singleSyllableWords.some(shortWord => word.startsWith(shortWord)) && (0, _stemHelpers.calculateTotalNumberOfSyllables)(word) <= 3 && checkSingleSyllableWordSuffix(word, suffixCombination)) {
+    // If the word gets a particle suffix, stem the particle. E.g. cekkanlah -> cekkan, pelkan -> pel, vasmulah -> vasmu
+    word = (0, _stemHelpers.removeEnding)(word, morphologyData.stemming.regexRules.removeParticle, morphologyData.stemming.doNotStemWords.doNotStemParticle, morphologyData);
+
+    // If the word gets a possessive pronoun suffix, stem the possessive pronoun. E.g. vasmu -> vas
+    word = (0, _stemHelpers.removeEnding)(word, morphologyData.stemming.regexRules.removePronoun, morphologyData.stemming.doNotStemWords.doNotStemPronounSuffix, morphologyData);
+
+    // If the word ends in -kan/-an/-i suffix, stem the suffix. E.g. cekkan -> cek, bomi -> bom
+    const wordWithoutDerivationalSuffix = (0, _stemHelpers.removeEnding)(word, morphologyData.stemming.regexRules.removeSuffixes, morphologyData.stemming.doNotStemWords.doNotStemSuffix, morphologyData);
+    if (singleSyllableWords.includes(wordWithoutDerivationalSuffix)) {
+      word = wordWithoutDerivationalSuffix;
+    }
+  }
+  /*
+   * We only want to stem single syllable words here.
+   * Thus, if the output word has more than one syllable, we don't stem the input word at all.
+   */
+  if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 1 || word.length === 1) {
+    word = inputWord;
+  }
+  return word;
+};
+
+/**
+ * Tries stemming prefixes ke- and ter-. Ke- is always stemmed, and ter- only if it is a prefix and not part of the stem.
+ * Also if the stem of the word begins with r-, only te- is stemmed, not ter-.
+ *
+ * @param {Object}	morphologyData	The Indonesian morphology data file.
+ * @param {string}	word			The word to check.
+ *
+ * @returns {string|null}	The stem or null if the word did not start with ter/keter.
+ */
+const tryStemmingKeAndTer = function (morphologyData, word) {
+  const terException = morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemFirstOrderPrefix.doNotStemTer;
+
+  // If prefix -ter is preceded by prefix -ke, remove it first.
+  if (word.startsWith('keter')) {
+    word = word.substring(2, word.length);
+  }
+  if (word.startsWith('ter')) {
+    // If word is on an exception list of words where -ter should not be stemmed, do not stem -ter and return the word.
+    if (terException.some(wordWithTer => word.startsWith(wordWithTer))) {
+      return word;
+    }
+    // If word (without prefixes) is on the list of words beginning with -r, remove only -te instead of -ter.
+    if ((0, _stemHelpers.checkBeginningsList)(word, 3, morphologyData.stemming.beginningModification.rBeginning)) {
+      return word.replace(/^ter/i, 'r');
+    }
+    // Otherwise, remove -ter.
+    return word.substring(3, word.length);
+  }
+};
+/**
+ * Checks whether a word has a first order prefix and whether it is on an exception list of words which require a stem mofification
+ * after removing the prefix. Returns the stem if the prefix was found and the word was matched on an exception list.
+ *
+ *
+ * @param {string}	word			The word to check.
+ * @param {Object}	morphologyData	The Indonesian morphology data file.
+ *
+ * @returns {string|null}	The stem or null if a prefix was not found, or was found but the word was not on the exception list.
+ */
+const checkFirstOrderPrefixExceptions = function (word, morphologyData) {
+  const beginningModification = morphologyData.stemming.beginningModification;
+
+  // If a word starts with "men" or "pen" and is present in the nBeginning exception list, the prefix should be replaced with "n".
+  if (/^[mp]en/i.test(word)) {
+    if ((0, _stemHelpers.checkBeginningsList)(word, 3, beginningModification.nBeginning)) {
+      return word.replace(/^[mp]en/i, 'n');
+    }
+  }
+  if (/^[mp]eng/i.test(word) && (0, _stemHelpers.checkBeginningsList)(word, 4, beginningModification.kBeginning)) {
+    return word.replace(/^[mp]eng/i, 'k');
+  }
+  if (/^[mp]em/i.test(word)) {
+    if ((0, _stemHelpers.checkBeginningsList)(word, 3, beginningModification.pBeginning)) {
+      return word.replace(/^(mem|pem)/i, 'p');
+    } else if ((0, _stemHelpers.checkBeginningsList)(word, 3, beginningModification.mBeginning)) {
+      return word.replace(/^(mem|pem)/i, 'm');
+    }
+  }
+  // Stem prefix ke- if found. Stem te(r)- unless the word was found on the exception list of words with stem beginning in -ter.
+  const wordAfterKeTerCheck = tryStemmingKeAndTer(morphologyData, word);
+  if (wordAfterKeTerCheck) {
+    return wordAfterKeTerCheck;
+  }
+};
+
+/**
+ * Stems the first-order prefix of a word based on regexRules. If the word is found in an exception list, implements a stem modification.
+ *
+ * @param {string} word           The word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string} The stemmed word.
+ */
+const removeFirstOrderPrefix = function (word, morphologyData) {
+  // Checks whether the word has a first order prefix and requires a stem modification.
+  const firstOrderPrefixException = checkFirstOrderPrefixExceptions(word, morphologyData);
+  if (firstOrderPrefixException) {
+    return firstOrderPrefixException;
+  }
+  const regex = createRulesFromArrays(morphologyData.stemming.regexRules.removeFirstOrderPrefixes);
+  const withRemovedFirstOrderPrefix = buildFormRule(word, regex);
+  return withRemovedFirstOrderPrefix || word;
+};
+
+/**
+ * Stems the second-order prefix of a word based on regexRules. If the word is found in an exception list, implements a stem modification.
+ *
+ * @param {string} word           The word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string} The stemmed word.
+ */
+const removeSecondOrderPrefix = function (word, morphologyData) {
+  // If a word starts with "ber" or "per" and is present in the rBeginning exception list, the prefix should be replaced with "r".
+  if ((word.startsWith('ber') || word.startsWith('per')) && (0, _stemHelpers.checkBeginningsList)(word, 3, morphologyData.stemming.beginningModification.rBeginning)) {
+    return word.replace(/^(ber|per)/i, 'r');
+  }
+  // If a word starts with a first order prefix followed by peng- and is in the kBeginning exception list, then peng- should be replaced with k.
+  if (/^peng/i.test(word) && (0, _stemHelpers.checkBeginningsList)(word, 4, morphologyData.stemming.beginningModification.kBeginning)) {
+    return word.replace(/^peng/i, 'k');
+  }
+  const regex = createRulesFromArrays(morphologyData.stemming.regexRules.removeSecondOrderPrefixes);
+  const withRemovedSecondOrderPrefix = buildFormRule(word, regex);
+  return withRemovedSecondOrderPrefix || word;
+};
+
+/**
+ * Stems derivational affixes of Indonesian words.
+ *
+ * @param {string} word           The word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string} The stemmed word.
+ */
+const stemDerivational = function (word, morphologyData) {
+  let wordLength = word.length;
+  const removeSuffixRules = morphologyData.stemming.regexRules.removeSuffixes;
+  const removeSuffixExceptions = morphologyData.stemming.doNotStemWords.doNotStemSuffix;
+  const doNotStemFirstOrderPrefix = flattenSortLength(morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemFirstOrderPrefix);
+  const doNotStemSecondOrderPrefix = flattenSortLength(morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemSecondOrderPrefix);
+
+  // If a word is in the list of words with a beginning that looks like a valid suffix, do not stem the suffix
+  if (!doNotStemFirstOrderPrefix.some(wordWithPrefixLookAlike => word.startsWith(wordWithPrefixLookAlike))) {
+    /*
+     * If the word has more than 2 syllables and starts with one of first order prefixes (i.e. meng-, meny-, men-, mem-, me-,
+     * peng-, peny-, pen-, pem-, di-, ter-, ke- ), the prefix will be stemmed here. e.g. penyebaran -> sebaran, diperlebarkan -> perlebarkan
+     */
+    word = removeFirstOrderPrefix(word, morphologyData);
+  }
+  if (wordLength === word.length) {
+    if (!doNotStemSecondOrderPrefix.some(wordWithPrefixLookAlike => word.startsWith(wordWithPrefixLookAlike))) {
+      /*
+       * If the word does not start with one of the first order prefixes but starts with one of the second order prefixes,
+       * the prefix will be stemmed here, e.g., peranakan -> anakan
+       */
+      word = removeSecondOrderPrefix(word, morphologyData);
+    }
+    // If the word has more than 2 syllables and ends in either -kan, -an, or -i suffixes, the suffix will be deleted here, e.g., anakan -> anak
+    if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 2) {
+      word = (0, _stemHelpers.removeEnding)(word, removeSuffixRules, removeSuffixExceptions, morphologyData);
+    }
+  } else {
+    // If the word previously had a first order prefix, assign wordLength to the length of the word after prefix deletion.
+    wordLength = word.length;
+    /*
+     * If the word after first order prefix deletion is bigger than 2 and ends in either -kan, -an, or -i suffixes,
+     * the suffix will be stemmed here. e.g. penyebaran - sebar.
+     */
+    if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 2) {
+      word = (0, _stemHelpers.removeEnding)(word, removeSuffixRules, removeSuffixExceptions, morphologyData);
+    }
+    /*
+     * If the word previously had a suffix, we check further if the word after first order prefix and suffix deletion has more than 2 syllables.
+     * If it does have more than 2 syllables and starts with one of the second order prefixes (i.e. ber-, be-, per-, pe-), the prefix will
+     * be stemmed here unless the word is in the exception list of words with a beginning that looks like a second order prefix.
+     */
+    if (wordLength !== word.length && !doNotStemSecondOrderPrefix.includes(word)) {
+      if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 2) {
+        word = removeSecondOrderPrefix(word, morphologyData);
+      }
+    }
+  }
+  return word;
+};
+
+/**
+ * Stems Indonesian singular words.
+ *
+ * @param {string} word           The singular word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string} The stem of an Indonesian singular word.
+ */
+const stemSingular = function (word, morphologyData) {
+  const singleSyllableWords = stemSingleSyllableWords(word, morphologyData);
+  // Stem the single syllable words
+  word = singleSyllableWords;
+  const doNotStemParticle = morphologyData.stemming.doNotStemWords.doNotStemParticle;
+  const doNotStemPronoun = morphologyData.stemming.doNotStemWords.doNotStemPronounSuffix;
+  if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) <= 2) {
+    return word;
+  }
+
+  // Check if a word after its derivational affixes stemmed exists in the exception list.
+  const firstDerivationalStem = stemDerivational(word, morphologyData);
+  if (doNotStemParticle.includes(firstDerivationalStem) || doNotStemPronoun.includes(firstDerivationalStem)) {
+    // If it does exist in the exception list, the ending that looks like a particle or a pronoun suffix should not be stemmed.
+    return firstDerivationalStem;
+  }
+
+  /*
+   * If the word has more than 2 syllables and ends in of the particle endings (i.e. -kah, -lah, -pun), stem the particle here.
+   * e.g. bajumulah -> bajumu, bawalah -> bawa
+   */
+  word = (0, _stemHelpers.removeEnding)(word, morphologyData.stemming.regexRules.removeParticle, doNotStemParticle, morphologyData);
+
+  // If the word (still) has more than 2 syllables and ends in of the possessive pronoun endings (i.e. -ku, -mu, -nya), stem the ending here.
+  if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 2) {
+    // E.g. bajumu -> baju
+    word = (0, _stemHelpers.removeEnding)(word, morphologyData.stemming.regexRules.removePronoun, doNotStemPronoun, morphologyData);
+  }
+
+  // If the word (still) has more than 2 syllables and has derivational affixes, the affix(es) will be stemmed here.
+  if ((0, _stemHelpers.calculateTotalNumberOfSyllables)(word) > 2) {
+    word = stemDerivational(word, morphologyData);
+  }
+  return word;
+};
+
+/**
+ * Stems Indonesian plural words.
+ *
+ * @param {string} word           The plural word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string|null} The stem of an Indonesian plural word or null if no plural was detected.
+ */
+const stemPlural = function (word, morphologyData) {
+  const hyphenIndex = word.indexOf('-');
+
+  // If there is no hyphen in the word, it can't be a reduplicated plural.
+  if (hyphenIndex === -1) {
+    return null;
+  }
+  const splitWord = word.split('-');
+  if (splitWord.length === 2) {
+    let firstPart = splitWord[0];
+    let secondPart = splitWord[1];
+    firstPart = stemSingular(firstPart, morphologyData);
+    secondPart = stemSingular(secondPart, morphologyData);
+
+    /*
+     * To compare the first and second part and see whether it's actually a reduplication:
+     * Trim the beginning of the word since it might be variable due to stem changes caused by prefixes.
+     * For example, in "meniru-nirukan" the singular stemmer will correctly stem the first "niru" to "tiru" because
+     * of the prefix "me". Since the second part of the word is stemmed individually, there is no "me" and hence
+     * "niru" remains "niru". To still be able to link these two forms to each other,
+     * we compare the two parts of the word after stripping the variable first or first and second letter.
+     *
+     */
+    const firstPartBeginningTrimmed = firstPart.substring(1);
+    const secondPartBeginningTrimmed = secondPart.startsWith('ng') || secondPart.startsWith('ny') ? secondPart.substring(2) : secondPart.substring(1);
+    if (firstPartBeginningTrimmed === secondPartBeginningTrimmed) {
+      const nonPlurals = morphologyData.stemming.nonPluralReduplications;
+
+      // Check non-plural reduplication.
+      if (nonPlurals.includes(firstPart) && nonPlurals.includes(secondPart)) {
+        /*
+         * In words such as "mengira-ngira" prefix "me" causes a modification on both words (k->ng). This will
+         * be correctly stemmed for the first word, but not the second. Therefore, the correct base form
+         * "kira-kira" is created based on a reduplication of the correctly stemmed first part, "kira".
+         */
+        return firstPart + '-' + firstPart;
+      }
+
+      // Return the stemmed singular form of a reduplicated plural.
+      return firstPart;
+    }
+  }
+  return null;
+};
+
+/**
+ * Stems Indonesian words
+ *
+ * @param {string} word           The word to stem.
+ * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.
+ *
+ * @returns {string} The stem of an Indonesian word.
+ */
+function stem(word, morphologyData) {
+  // Check words that shouldn't receive any stemming.
+  if (morphologyData.stemming.shouldNotBeStemmed.includes(word)) {
+    return word;
+  }
+  const stemmedPlural = stemPlural(word, morphologyData);
+  if (stemmedPlural) {
+    return stemmedPlural;
+  }
+  word = stemSingular(word, morphologyData);
+  return word;
+}
+//# sourceMappingURL=stem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stem.js","names":["_index","require","_stemHelpers","flattenSortLength","buildFormRule","createRulesFromArrays","languageProcessing","checkSingleSyllableWordSuffix","word","suffixesArray","suffix","match","stemSingleSyllableWordsPrefixes","morphologyData","startsWith","checkBeginningsList","stemming","singleSyllableWords","substring","length","test","stemSingleSyllableWords","suffixCombination","singleSyllableWordsSuffixes","inputWord","some","shortWord","calculateTotalNumberOfSyllables","removeEnding","regexRules","removeParticle","doNotStemWords","doNotStemParticle","removePronoun","doNotStemPronounSuffix","wordWithoutDerivationalSuffix","removeSuffixes","doNotStemSuffix","includes","tryStemmingKeAndTer","terException","doNotStemPrefix","doNotStemFirstOrderPrefix","doNotStemTer","wordWithTer","beginningModification","rBeginning","replace","checkFirstOrderPrefixExceptions","nBeginning","kBeginning","pBeginning","mBeginning","wordAfterKeTerCheck","removeFirstOrderPrefix","firstOrderPrefixException","regex","removeFirstOrderPrefixes","withRemovedFirstOrderPrefix","removeSecondOrderPrefix","removeSecondOrderPrefixes","withRemovedSecondOrderPrefix","stemDerivational","wordLength","removeSuffixRules","removeSuffixExceptions","doNotStemSecondOrderPrefix","wordWithPrefixLookAlike","stemSingular","doNotStemPronoun","firstDerivationalStem","stemPlural","hyphenIndex","indexOf","splitWord","split","firstPart","secondPart","firstPartBeginningTrimmed","secondPartBeginningTrimmed","nonPlurals","nonPluralReduplications","stem","shouldNotBeStemmed","stemmedPlural"],"sources":["../../../../../../src/languageProcessing/languages/id/helpers/internal/stem.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {flattenSortLength, buildFormRule, createRulesFromArrays} = languageProcessing;\n\nimport {calculateTotalNumberOfSyllables, removeEnding, checkBeginningsList} from './stemHelpers';\n\n/**\n * MIT License\n *\n * Adapted from: Copyright (c) 2013 Adinda Praditya\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy of this software\n * and associated documentation files (the \\\"Software\\\"), to deal in the Software without restriction,\n * including without limitation the rights to use, copy, modify, merge, publish,  distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,\n * subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n * THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND,  EXPRESS OR IMPLIED,\n * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\"\n */\n\n/**\n * Checks if a single syllable word has one of the suffixes/suffix combination.\n *\n * @param {string} word         The word to check.\n * @param {Array} suffixesArray The array of suffixes\n * @returns {boolean}   Whether the word ends in one of the suffixes or not.\n */\nconst checkSingleSyllableWordSuffix = function(word, suffixesArray) {\n  for (const suffix of suffixesArray) {\n    if (word.match(suffix)) {\n      return true;\n    }\n  }\n};\n\n/**\n * Stems the prefix of the single syllable words, i.e. di-/penge-/menge-\n *\n * @param {string}\tword\t\t\tThe word to check.\n * @param {Object}\tmorphologyData\tThe Indonesian morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nconst stemSingleSyllableWordsPrefixes = function(word, morphologyData) {\n  // If the word gets prefix di-, stem the prefix here. E.g. dicekkanlah -> cekkanlah, dibomi -> bomi\n  if (\n    word.startsWith('di') &&\n    checkBeginningsList(word, 2, morphologyData.stemming.singleSyllableWords)\n  ) {\n    return word.substring(2, word.length);\n  }\n  /*\n   * If the word gets prefix menge-/penge- and is followed by one of the words in the list, stem the prefix here.\n   * E.g. pengeboman -> boman\n   */\n  if (\n    /^[mp]enge/i.test(word) &&\n    checkBeginningsList(word, 5, morphologyData.stemming.singleSyllableWords)\n  ) {\n    return word.substring(5, word.length);\n  }\n  return word;\n};\n\n/**\n * Stems Indonesian single syllable words. This function concerns single syllable words\n * with this possible word format [di/penge/menge] + single syllable word + [kan/an/i] + [ku/mu/nya] + [kah/lah/pun], with [] being optional.\n * E.g. dipel -> pel, dipelkan -> pel, dipelkanlah -> pel, pelkan -> pel, pelmulah -> pel, pengeboman -> bom, mengesahkan -> sah\n *\n *\n * @param {string}\tword\t\t\tThe word to check.\n * @param {Object}\tmorphologyData\tThe Indonesian morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nconst stemSingleSyllableWords = function(word, morphologyData) {\n  const singleSyllableWords = morphologyData.stemming.singleSyllableWords;\n  const suffixCombination = morphologyData.stemming.singleSyllableWordsSuffixes;\n  const inputWord = word;\n  // If the word starts with prefix di-/penge-/menge-, stem the prefix here. E.g. pengeboman -> boman, dipelkan -> pelkan\n  word = stemSingleSyllableWordsPrefixes(word, morphologyData);\n\n  // Check if a word starts with one of the words in the list, has maximum 3 syllables, and ends in one of the single syllable suffixes\n  if (\n    singleSyllableWords.some(shortWord => word.startsWith(shortWord)) &&\n    calculateTotalNumberOfSyllables(word) <= 3 &&\n    checkSingleSyllableWordSuffix(word, suffixCombination)\n  ) {\n    // If the word gets a particle suffix, stem the particle. E.g. cekkanlah -> cekkan, pelkan -> pel, vasmulah -> vasmu\n    word = removeEnding(\n      word,\n      morphologyData.stemming.regexRules.removeParticle,\n      morphologyData.stemming.doNotStemWords.doNotStemParticle,\n      morphologyData\n    );\n\n    // If the word gets a possessive pronoun suffix, stem the possessive pronoun. E.g. vasmu -> vas\n    word = removeEnding(\n      word,\n      morphologyData.stemming.regexRules.removePronoun,\n      morphologyData.stemming.doNotStemWords.doNotStemPronounSuffix,\n      morphologyData\n    );\n\n    // If the word ends in -kan/-an/-i suffix, stem the suffix. E.g. cekkan -> cek, bomi -> bom\n    const wordWithoutDerivationalSuffix = removeEnding(\n      word,\n      morphologyData.stemming.regexRules.removeSuffixes,\n      morphologyData.stemming.doNotStemWords.doNotStemSuffix,\n      morphologyData\n    );\n\n    if (singleSyllableWords.includes(wordWithoutDerivationalSuffix)) {\n      word = wordWithoutDerivationalSuffix;\n    }\n  }\n  /*\n   * We only want to stem single syllable words here.\n   * Thus, if the output word has more than one syllable, we don't stem the input word at all.\n   */\n  if (calculateTotalNumberOfSyllables(word) > 1 || word.length === 1) {\n    word = inputWord;\n  }\n  return word;\n};\n\n/**\n * Tries stemming prefixes ke- and ter-. Ke- is always stemmed, and ter- only if it is a prefix and not part of the stem.\n * Also if the stem of the word begins with r-, only te- is stemmed, not ter-.\n *\n * @param {Object}\tmorphologyData\tThe Indonesian morphology data file.\n * @param {string}\tword\t\t\tThe word to check.\n *\n * @returns {string|null}\tThe stem or null if the word did not start with ter/keter.\n */\nconst tryStemmingKeAndTer = function(morphologyData, word) {\n  const terException =\n    morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemFirstOrderPrefix.doNotStemTer;\n\n  // If prefix -ter is preceded by prefix -ke, remove it first.\n  if (word.startsWith('keter')) {\n    word = word.substring(2, word.length);\n  }\n  if (word.startsWith('ter')) {\n    // If word is on an exception list of words where -ter should not be stemmed, do not stem -ter and return the word.\n    if (terException.some(wordWithTer => word.startsWith(wordWithTer))) {\n      return word;\n    }\n    // If word (without prefixes) is on the list of words beginning with -r, remove only -te instead of -ter.\n    if (checkBeginningsList(word, 3, morphologyData.stemming.beginningModification.rBeginning)) {\n      return word.replace(/^ter/i, 'r');\n    }\n    // Otherwise, remove -ter.\n    return word.substring(3, word.length);\n  }\n};\n/**\n * Checks whether a word has a first order prefix and whether it is on an exception list of words which require a stem mofification\n * after removing the prefix. Returns the stem if the prefix was found and the word was matched on an exception list.\n *\n *\n * @param {string}\tword\t\t\tThe word to check.\n * @param {Object}\tmorphologyData\tThe Indonesian morphology data file.\n *\n * @returns {string|null}\tThe stem or null if a prefix was not found, or was found but the word was not on the exception list.\n */\nconst checkFirstOrderPrefixExceptions = function(word, morphologyData) {\n  const beginningModification = morphologyData.stemming.beginningModification;\n\n  // If a word starts with \"men\" or \"pen\" and is present in the nBeginning exception list, the prefix should be replaced with \"n\".\n  if (/^[mp]en/i.test(word)) {\n    if (checkBeginningsList(word, 3, beginningModification.nBeginning)) {\n      return word.replace(/^[mp]en/i, 'n');\n    }\n  }\n  if (/^[mp]eng/i.test(word) && checkBeginningsList(word, 4, beginningModification.kBeginning)) {\n    return word.replace(/^[mp]eng/i, 'k');\n  }\n\n  if (/^[mp]em/i.test(word)) {\n    if (checkBeginningsList(word, 3, beginningModification.pBeginning)) {\n      return word.replace(/^(mem|pem)/i, 'p');\n    } else if (checkBeginningsList(word, 3, beginningModification.mBeginning)) {\n      return word.replace(/^(mem|pem)/i, 'm');\n    }\n  }\n  // Stem prefix ke- if found. Stem te(r)- unless the word was found on the exception list of words with stem beginning in -ter.\n  const wordAfterKeTerCheck = tryStemmingKeAndTer(morphologyData, word);\n  if (wordAfterKeTerCheck) {\n    return wordAfterKeTerCheck;\n  }\n};\n\n/**\n * Stems the first-order prefix of a word based on regexRules. If the word is found in an exception list, implements a stem modification.\n *\n * @param {string} word           The word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string} The stemmed word.\n */\nconst removeFirstOrderPrefix = function(word, morphologyData) {\n  // Checks whether the word has a first order prefix and requires a stem modification.\n  const firstOrderPrefixException = checkFirstOrderPrefixExceptions(word, morphologyData);\n\n  if (firstOrderPrefixException) {\n    return firstOrderPrefixException;\n  }\n  const regex = createRulesFromArrays(morphologyData.stemming.regexRules.removeFirstOrderPrefixes);\n  const withRemovedFirstOrderPrefix = buildFormRule(word, regex);\n\n  return withRemovedFirstOrderPrefix || word;\n};\n\n/**\n * Stems the second-order prefix of a word based on regexRules. If the word is found in an exception list, implements a stem modification.\n *\n * @param {string} word           The word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string} The stemmed word.\n */\nconst removeSecondOrderPrefix = function(word, morphologyData) {\n  // If a word starts with \"ber\" or \"per\" and is present in the rBeginning exception list, the prefix should be replaced with \"r\".\n  if (\n    (word.startsWith('ber') || word.startsWith('per')) &&\n    checkBeginningsList(word, 3, morphologyData.stemming.beginningModification.rBeginning)\n  ) {\n    return word.replace(/^(ber|per)/i, 'r');\n  }\n  // If a word starts with a first order prefix followed by peng- and is in the kBeginning exception list, then peng- should be replaced with k.\n  if (\n    /^peng/i.test(word) &&\n    checkBeginningsList(word, 4, morphologyData.stemming.beginningModification.kBeginning)\n  ) {\n    return word.replace(/^peng/i, 'k');\n  }\n  const regex = createRulesFromArrays(morphologyData.stemming.regexRules.removeSecondOrderPrefixes);\n  const withRemovedSecondOrderPrefix = buildFormRule(word, regex);\n\n  return withRemovedSecondOrderPrefix || word;\n};\n\n/**\n * Stems derivational affixes of Indonesian words.\n *\n * @param {string} word           The word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string} The stemmed word.\n */\nconst stemDerivational = function(word, morphologyData) {\n  let wordLength = word.length;\n  const removeSuffixRules = morphologyData.stemming.regexRules.removeSuffixes;\n  const removeSuffixExceptions = morphologyData.stemming.doNotStemWords.doNotStemSuffix;\n  const doNotStemFirstOrderPrefix = flattenSortLength(\n    morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemFirstOrderPrefix\n  );\n  const doNotStemSecondOrderPrefix = flattenSortLength(\n    morphologyData.stemming.doNotStemWords.doNotStemPrefix.doNotStemSecondOrderPrefix\n  );\n\n  // If a word is in the list of words with a beginning that looks like a valid suffix, do not stem the suffix\n  if (\n    !doNotStemFirstOrderPrefix.some(wordWithPrefixLookAlike =>\n      word.startsWith(wordWithPrefixLookAlike)\n    )\n  ) {\n    /*\n     * If the word has more than 2 syllables and starts with one of first order prefixes (i.e. meng-, meny-, men-, mem-, me-,\n     * peng-, peny-, pen-, pem-, di-, ter-, ke- ), the prefix will be stemmed here. e.g. penyebaran -> sebaran, diperlebarkan -> perlebarkan\n     */\n    word = removeFirstOrderPrefix(word, morphologyData);\n  }\n\n  if (wordLength === word.length) {\n    if (\n      !doNotStemSecondOrderPrefix.some(wordWithPrefixLookAlike =>\n        word.startsWith(wordWithPrefixLookAlike)\n      )\n    ) {\n      /*\n       * If the word does not start with one of the first order prefixes but starts with one of the second order prefixes,\n       * the prefix will be stemmed here, e.g., peranakan -> anakan\n       */\n      word = removeSecondOrderPrefix(word, morphologyData);\n    }\n    // If the word has more than 2 syllables and ends in either -kan, -an, or -i suffixes, the suffix will be deleted here, e.g., anakan -> anak\n    if (calculateTotalNumberOfSyllables(word) > 2) {\n      word = removeEnding(word, removeSuffixRules, removeSuffixExceptions, morphologyData);\n    }\n  } else {\n    // If the word previously had a first order prefix, assign wordLength to the length of the word after prefix deletion.\n    wordLength = word.length;\n    /*\n     * If the word after first order prefix deletion is bigger than 2 and ends in either -kan, -an, or -i suffixes,\n     * the suffix will be stemmed here. e.g. penyebaran - sebar.\n     */\n    if (calculateTotalNumberOfSyllables(word) > 2) {\n      word = removeEnding(word, removeSuffixRules, removeSuffixExceptions, morphologyData);\n    }\n    /*\n     * If the word previously had a suffix, we check further if the word after first order prefix and suffix deletion has more than 2 syllables.\n     * If it does have more than 2 syllables and starts with one of the second order prefixes (i.e. ber-, be-, per-, pe-), the prefix will\n     * be stemmed here unless the word is in the exception list of words with a beginning that looks like a second order prefix.\n     */\n    if (wordLength !== word.length && !doNotStemSecondOrderPrefix.includes(word)) {\n      if (calculateTotalNumberOfSyllables(word) > 2) {\n        word = removeSecondOrderPrefix(word, morphologyData);\n      }\n    }\n  }\n  return word;\n};\n\n/**\n * Stems Indonesian singular words.\n *\n * @param {string} word           The singular word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string} The stem of an Indonesian singular word.\n */\nconst stemSingular = function(word, morphologyData) {\n  const singleSyllableWords = stemSingleSyllableWords(word, morphologyData);\n  // Stem the single syllable words\n  word = singleSyllableWords;\n\n  const doNotStemParticle = morphologyData.stemming.doNotStemWords.doNotStemParticle;\n  const doNotStemPronoun = morphologyData.stemming.doNotStemWords.doNotStemPronounSuffix;\n\n  if (calculateTotalNumberOfSyllables(word) <= 2) {\n    return word;\n  }\n\n  // Check if a word after its derivational affixes stemmed exists in the exception list.\n  const firstDerivationalStem = stemDerivational(word, morphologyData);\n  if (\n    doNotStemParticle.includes(firstDerivationalStem) ||\n    doNotStemPronoun.includes(firstDerivationalStem)\n  ) {\n    // If it does exist in the exception list, the ending that looks like a particle or a pronoun suffix should not be stemmed.\n    return firstDerivationalStem;\n  }\n\n  /*\n   * If the word has more than 2 syllables and ends in of the particle endings (i.e. -kah, -lah, -pun), stem the particle here.\n   * e.g. bajumulah -> bajumu, bawalah -> bawa\n   */\n  word = removeEnding(\n    word,\n    morphologyData.stemming.regexRules.removeParticle,\n    doNotStemParticle,\n    morphologyData\n  );\n\n  // If the word (still) has more than 2 syllables and ends in of the possessive pronoun endings (i.e. -ku, -mu, -nya), stem the ending here.\n  if (calculateTotalNumberOfSyllables(word) > 2) {\n    // E.g. bajumu -> baju\n    word = removeEnding(\n      word,\n      morphologyData.stemming.regexRules.removePronoun,\n      doNotStemPronoun,\n      morphologyData\n    );\n  }\n\n  // If the word (still) has more than 2 syllables and has derivational affixes, the affix(es) will be stemmed here.\n  if (calculateTotalNumberOfSyllables(word) > 2) {\n    word = stemDerivational(word, morphologyData);\n  }\n  return word;\n};\n\n/**\n * Stems Indonesian plural words.\n *\n * @param {string} word           The plural word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string|null} The stem of an Indonesian plural word or null if no plural was detected.\n */\nconst stemPlural = function(word, morphologyData) {\n  const hyphenIndex = word.indexOf('-');\n\n  // If there is no hyphen in the word, it can't be a reduplicated plural.\n  if (hyphenIndex === -1) {\n    return null;\n  }\n\n  const splitWord = word.split('-');\n\n  if (splitWord.length === 2) {\n    let firstPart = splitWord[0];\n    let secondPart = splitWord[1];\n\n    firstPart = stemSingular(firstPart, morphologyData);\n    secondPart = stemSingular(secondPart, morphologyData);\n\n    /*\n     * To compare the first and second part and see whether it's actually a reduplication:\n     * Trim the beginning of the word since it might be variable due to stem changes caused by prefixes.\n     * For example, in \"meniru-nirukan\" the singular stemmer will correctly stem the first \"niru\" to \"tiru\" because\n     * of the prefix \"me\". Since the second part of the word is stemmed individually, there is no \"me\" and hence\n     * \"niru\" remains \"niru\". To still be able to link these two forms to each other,\n     * we compare the two parts of the word after stripping the variable first or first and second letter.\n     *\n     */\n    const firstPartBeginningTrimmed = firstPart.substring(1);\n    const secondPartBeginningTrimmed =\n      secondPart.startsWith('ng') || secondPart.startsWith('ny')\n        ? secondPart.substring(2)\n        : secondPart.substring(1);\n\n    if (firstPartBeginningTrimmed === secondPartBeginningTrimmed) {\n      const nonPlurals = morphologyData.stemming.nonPluralReduplications;\n\n      // Check non-plural reduplication.\n      if (nonPlurals.includes(firstPart) && nonPlurals.includes(secondPart)) {\n        /*\n         * In words such as \"mengira-ngira\" prefix \"me\" causes a modification on both words (k->ng). This will\n         * be correctly stemmed for the first word, but not the second. Therefore, the correct base form\n         * \"kira-kira\" is created based on a reduplication of the correctly stemmed first part, \"kira\".\n         */\n        return firstPart + '-' + firstPart;\n      }\n\n      // Return the stemmed singular form of a reduplicated plural.\n      return firstPart;\n    }\n  }\n\n  return null;\n};\n\n/**\n * Stems Indonesian words\n *\n * @param {string} word           The word to stem.\n * @param {Object} morphologyData The object that contains regex-based rules and exception lists for Indonesian stemming.\n *\n * @returns {string} The stem of an Indonesian word.\n */\nexport default function stem(word, morphologyData) {\n  // Check words that shouldn't receive any stemming.\n  if (morphologyData.stemming.shouldNotBeStemmed.includes(word)) {\n    return word;\n  }\n\n  const stemmedPlural = stemPlural(word, morphologyData);\n\n  if (stemmedPlural) {\n    return stemmedPlural;\n  }\n\n  word = stemSingular(word, morphologyData);\n\n  return word;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/languages/id/helpers/internal/stemHelpers.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateTotalNumberOfSyllables = calculateTotalNumberOfSyllables;
+exports.checkBeginningsList = checkBeginningsList;
+exports.removeEnding = removeEnding;
+var _index = require("../../../../../index.js");
+const {
+  buildFormRule,
+  createRulesFromArrays
+} = _index.languageProcessing;
+const vowelCharacters = ['a', 'e', 'i', 'o', 'u'];
+
+/**
+ * Determines if an input character is a vowel.
+ *
+ * @param {string} character    The character to check.
+ *
+ * @returns {boolean} Whether the input character is an Indonesian vowel.
+ */
+function isVowel(character) {
+  return vowelCharacters.includes(character);
+}
+
+/**
+ * Calculates the total number of syllables in the input word.
+ *
+ * @param {string} word     The word to calculate the number of syllables in.
+ *
+ * @returns {int} The total number of syllables in the word.
+ */
+function calculateTotalNumberOfSyllables(word) {
+  let result = 0;
+  for (let i = 0; i < word.length; i++) {
+    if (isVowel(word[i])) {
+      result++;
+    }
+  }
+  return result;
+}
+
+/**
+ * Stems the ending of a word based on some regexRules after checking if the word is in the exception list.
+ *
+ * @param {string} word             The word to stem.
+ * @param {Array} regexRules        The list of regex-based rules to apply to the word in order to stem it.
+ * @param {string[]} exceptions     The list of words that should not get the ending removed.
+ * @param {Object} morphologyData   The Indonesian morphology data file
+ *
+ * @returns {string} The stemmed word.
+ */
+function removeEnding(word, regexRules, exceptions, morphologyData) {
+  if (exceptions.includes(word)) {
+    return word;
+  }
+
+  // Check words ending in -kan whether they are words whose stem ending in -k that get suffix -an or not.
+  const wordsWithKEnding = morphologyData.stemming.doNotStemWords.doNotStemK;
+  if (word.endsWith('kan')) {
+    const wordWithoutSuffixAn = word.substring(0, word.length - 2);
+    // If a word has stem ending -k and gets suffix -an, then only stem -an here.
+    if (wordsWithKEnding.includes(wordWithoutSuffixAn)) {
+      word = wordWithoutSuffixAn;
+    }
+  }
+  const removePartRegex = createRulesFromArrays(regexRules);
+  const withRemovedPart = buildFormRule(word, removePartRegex);
+  return withRemovedPart || word;
+}
+
+/**
+ * Checks if the beginning of the word is present in an exception list.
+ *
+ * @param {string}   word         The word to stem.
+ * @param {int}      prefixLength The length of the prefix to be trimmed before checking in the list.
+ * @param {string[]} beginnings   The list of word beginnings that should be checked.
+ *
+ * @returns {boolean} Whether the word is found in the list with beginnings.
+ */
+function checkBeginningsList(word, prefixLength, beginnings) {
+  const wordWithoutPrefix = word.slice(prefixLength);
+  return beginnings.some(beginning => wordWithoutPrefix.startsWith(beginning));
+}
+//# sourceMappingURL=stemHelpers.js.map

package/build/languageProcessing/languages/id/helpers/internal/stemHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stemHelpers.js","names":["_index","require","buildFormRule","createRulesFromArrays","languageProcessing","vowelCharacters","isVowel","character","includes","calculateTotalNumberOfSyllables","word","result","i","length","removeEnding","regexRules","exceptions","morphologyData","wordsWithKEnding","stemming","doNotStemWords","doNotStemK","endsWith","wordWithoutSuffixAn","substring","removePartRegex","withRemovedPart","checkBeginningsList","prefixLength","beginnings","wordWithoutPrefix","slice","some","beginning","startsWith"],"sources":["../../../../../../src/languageProcessing/languages/id/helpers/internal/stemHelpers.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {buildFormRule, createRulesFromArrays} = languageProcessing;\n\nconst vowelCharacters = ['a', 'e', 'i', 'o', 'u'];\n\n/**\n * Determines if an input character is a vowel.\n *\n * @param {string} character    The character to check.\n *\n * @returns {boolean} Whether the input character is an Indonesian vowel.\n */\nfunction isVowel(character) {\n  return vowelCharacters.includes(character);\n}\n\n/**\n * Calculates the total number of syllables in the input word.\n *\n * @param {string} word     The word to calculate the number of syllables in.\n *\n * @returns {int} The total number of syllables in the word.\n */\nexport function calculateTotalNumberOfSyllables(word) {\n  let result = 0;\n\n  for (let i = 0; i < word.length; i++) {\n    if (isVowel(word[i])) {\n      result++;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Stems the ending of a word based on some regexRules after checking if the word is in the exception list.\n *\n * @param {string} word             The word to stem.\n * @param {Array} regexRules        The list of regex-based rules to apply to the word in order to stem it.\n * @param {string[]} exceptions     The list of words that should not get the ending removed.\n * @param {Object} morphologyData   The Indonesian morphology data file\n *\n * @returns {string} The stemmed word.\n */\nexport function removeEnding(word, regexRules, exceptions, morphologyData) {\n  if (exceptions.includes(word)) {\n    return word;\n  }\n\n  // Check words ending in -kan whether they are words whose stem ending in -k that get suffix -an or not.\n  const wordsWithKEnding = morphologyData.stemming.doNotStemWords.doNotStemK;\n  if (word.endsWith('kan')) {\n    const wordWithoutSuffixAn = word.substring(0, word.length - 2);\n    // If a word has stem ending -k and gets suffix -an, then only stem -an here.\n    if (wordsWithKEnding.includes(wordWithoutSuffixAn)) {\n      word = wordWithoutSuffixAn;\n    }\n  }\n\n  const removePartRegex = createRulesFromArrays(regexRules);\n  const withRemovedPart = buildFormRule(word, removePartRegex);\n  return withRemovedPart || word;\n}\n\n/**\n * Checks if the beginning of the word is present in an exception list.\n *\n * @param {string}   word         The word to stem.\n * @param {int}      prefixLength The length of the prefix to be trimmed before checking in the list.\n * @param {string[]} beginnings   The list of word beginnings that should be checked.\n *\n * @returns {boolean} Whether the word is found in the list with beginnings.\n */\nexport function checkBeginningsList(word, prefixLength, beginnings) {\n  const wordWithoutPrefix = word.slice(prefixLength);\n  return beginnings.some(beginning => wordWithoutPrefix.startsWith(beginning));\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,MAAM;EAACC,aAAa;EAAEC;AAAqB,CAAC,GAAGC,yBAAkB;AAEjE,MAAMC,eAAe,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;;AAEjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,OAAOA,CAACC,SAAS,EAAE;EAC1B,OAAOF,eAAe,CAACG,QAAQ,CAACD,SAAS,CAAC;AAC5C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,+BAA+BA,CAACC,IAAI,EAAE;EACpD,IAAIC,MAAM,GAAG,CAAC;EAEd,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,MAAM,EAAED,CAAC,EAAE,EAAE;IACpC,IAAIN,OAAO,CAACI,IAAI,CAACE,CAAC,CAAC,CAAC,EAAE;MACpBD,MAAM,EAAE;IACV;EACF;EAEA,OAAOA,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,YAAYA,CAACJ,IAAI,EAAEK,UAAU,EAAEC,UAAU,EAAEC,cAAc,EAAE;EACzE,IAAID,UAAU,CAACR,QAAQ,CAACE,IAAI,CAAC,EAAE;IAC7B,OAAOA,IAAI;EACb;;EAEA;EACA,MAAMQ,gBAAgB,GAAGD,cAAc,CAACE,QAAQ,CAACC,cAAc,CAACC,UAAU;EAC1E,IAAIX,IAAI,CAACY,QAAQ,CAAC,KAAK,CAAC,EAAE;IACxB,MAAMC,mBAAmB,GAAGb,IAAI,CAACc,SAAS,CAAC,CAAC,EAAEd,IAAI,CAACG,MAAM,GAAG,CAAC,CAAC;IAC9D;IACA,IAAIK,gBAAgB,CAACV,QAAQ,CAACe,mBAAmB,CAAC,EAAE;MAClDb,IAAI,GAAGa,mBAAmB;IAC5B;EACF;EAEA,MAAME,eAAe,GAAGtB,qBAAqB,CAACY,UAAU,CAAC;EACzD,MAAMW,eAAe,GAAGxB,aAAa,CAACQ,IAAI,EAAEe,eAAe,CAAC;EAC5D,OAAOC,eAAe,IAAIhB,IAAI;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASiB,mBAAmBA,CAACjB,IAAI,EAAEkB,YAAY,EAAEC,UAAU,EAAE;EAClE,MAAMC,iBAAiB,GAAGpB,IAAI,CAACqB,KAAK,CAACH,YAAY,CAAC;EAClD,OAAOC,UAAU,CAACG,IAAI,CAACC,SAAS,IAAIH,iBAAiB,CAACI,UAAU,CAACD,SAAS,CAAC,CAAC;AAC9E","ignoreList":[]}

package/build/languageProcessing/languages/id/helpers/isPassiveSentence.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isPassiveSentence;
+var _index = require("../../../../index.js");
+var _nonPassiveVerbsStartingDi = _interopRequireDefault(require("../config/internal/nonPassiveVerbsStartingDi"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  getWords
+} = _index.languageProcessing;
+const passivePrefix = 'di';
+
+/**
+ * Checks the passed sentence to see if it contains Indonesian passive verb-forms.
+ *
+ * @param {string} sentence     The sentence to match against.
+ *
+ * @returns {Boolean} Whether the sentence contains Indonesian passive voice.
+ */
+function isPassiveSentence(sentence) {
+  const words = getWords(sentence.toLowerCase());
+  let matchedPassives = words.filter(word => word.length > 4);
+  matchedPassives = matchedPassives.filter(word => word.startsWith(passivePrefix));
+  if (matchedPassives.length === 0) {
+    return false;
+  }
+
+  // Check exception list.
+  for (const nonPassive of _nonPassiveVerbsStartingDi.default) {
+    matchedPassives = matchedPassives.filter(word => !word.startsWith(nonPassive));
+  }
+
+  // Check direct precedence exceptions.
+  matchedPassives = matchedPassives.filter(function (matchedPassive) {
+    let matchedPassivesShouldStay = true;
+    const passiveIndex = words.indexOf(matchedPassive);
+    const wordPrecedingPassive = words[passiveIndex - 1];
+    if (wordPrecedingPassive === 'untuk') {
+      matchedPassivesShouldStay = false;
+    }
+    return matchedPassivesShouldStay;
+  });
+  return matchedPassives.length !== 0;
+}
+//# sourceMappingURL=isPassiveSentence.js.map

package/build/languageProcessing/languages/id/helpers/isPassiveSentence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPassiveSentence.js","names":["_index","require","_nonPassiveVerbsStartingDi","_interopRequireDefault","e","__esModule","default","getWords","languageProcessing","passivePrefix","isPassiveSentence","sentence","words","toLowerCase","matchedPassives","filter","word","length","startsWith","nonPassive","nonPassives","matchedPassive","matchedPassivesShouldStay","passiveIndex","indexOf","wordPrecedingPassive"],"sources":["../../../../../src/languageProcessing/languages/id/helpers/isPassiveSentence.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {getWords} = languageProcessing;\n\nimport nonPassives from '../config/internal/nonPassiveVerbsStartingDi';\nconst passivePrefix = 'di';\n\n/**\n * Checks the passed sentence to see if it contains Indonesian passive verb-forms.\n *\n * @param {string} sentence     The sentence to match against.\n *\n * @returns {Boolean} Whether the sentence contains Indonesian passive voice.\n */\nexport default function isPassiveSentence(sentence) {\n  const words = getWords(sentence.toLowerCase());\n  let matchedPassives = words.filter(word => word.length > 4);\n  matchedPassives = matchedPassives.filter(word => word.startsWith(passivePrefix));\n  if (matchedPassives.length === 0) {\n    return false;\n  }\n\n  // Check exception list.\n  for (const nonPassive of nonPassives) {\n    matchedPassives = matchedPassives.filter(word => !word.startsWith(nonPassive));\n  }\n\n  // Check direct precedence exceptions.\n  matchedPassives = matchedPassives.filter(function(matchedPassive) {\n    let matchedPassivesShouldStay = true;\n    const passiveIndex = words.indexOf(matchedPassive);\n    const wordPrecedingPassive = words[passiveIndex - 1];\n    if (wordPrecedingPassive === 'untuk') {\n      matchedPassivesShouldStay = false;\n    }\n    return matchedPassivesShouldStay;\n  });\n\n  return matchedPassives.length !== 0;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,0BAAA,GAAAC,sBAAA,CAAAF,OAAA;AAAuE,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAFvE,MAAM;EAACG;AAAQ,CAAC,GAAGC,yBAAkB;AAGrC,MAAMC,aAAa,GAAG,IAAI;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,iBAAiBA,CAACC,QAAQ,EAAE;EAClD,MAAMC,KAAK,GAAGL,QAAQ,CAACI,QAAQ,CAACE,WAAW,CAAC,CAAC,CAAC;EAC9C,IAAIC,eAAe,GAAGF,KAAK,CAACG,MAAM,CAACC,IAAI,IAAIA,IAAI,CAACC,MAAM,GAAG,CAAC,CAAC;EAC3DH,eAAe,GAAGA,eAAe,CAACC,MAAM,CAACC,IAAI,IAAIA,IAAI,CAACE,UAAU,CAACT,aAAa,CAAC,CAAC;EAChF,IAAIK,eAAe,CAACG,MAAM,KAAK,CAAC,EAAE;IAChC,OAAO,KAAK;EACd;;EAEA;EACA,KAAK,MAAME,UAAU,IAAIC,kCAAW,EAAE;IACpCN,eAAe,GAAGA,eAAe,CAACC,MAAM,CAACC,IAAI,IAAI,CAACA,IAAI,CAACE,UAAU,CAACC,UAAU,CAAC,CAAC;EAChF;;EAEA;EACAL,eAAe,GAAGA,eAAe,CAACC,MAAM,CAAC,UAASM,cAAc,EAAE;IAChE,IAAIC,yBAAyB,GAAG,IAAI;IACpC,MAAMC,YAAY,GAAGX,KAAK,CAACY,OAAO,CAACH,cAAc,CAAC;IAClD,MAAMI,oBAAoB,GAAGb,KAAK,CAACW,YAAY,GAAG,CAAC,CAAC;IACpD,IAAIE,oBAAoB,KAAK,OAAO,EAAE;MACpCH,yBAAyB,GAAG,KAAK;IACnC;IACA,OAAOA,yBAAyB;EAClC,CAAC,CAAC;EAEF,OAAOR,eAAe,CAACG,MAAM,KAAK,CAAC;AACrC","ignoreList":[]}