axyseo 2.1.12 → 2.1.13

package/build/languageProcessing/helpers/match/matchWordFormsWithSentence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchWordFormsWithSentence.js","names":["matchTextWithTransliteration","splitIntoTokens","tokenizeKeyphraseFormsForExactMatching","wordForms","customSplitIntoTokensHelper","wordFormText","findExactMatchKeyphraseInSentence","sentence","locale","result","count","matches","keyphraseTokens","sentenceTokens","tokens","indexOfWordInKeyphrase","indexOfWordInSentence","currentMatch","length","sentenceTokenText","text","keyphraseTokenText","foundMatches","toLowerCase","push","matchWordFormInTokens","wordForm","forEach","token","occurrence","concat","matchWordFormsInSentence","matchWordCustomHelper","occurrences","slice","matchWordFormsWithSentence","useExactMatching"],"sources":["../../../../src/languageProcessing/helpers/match/matchWordFormsWithSentence.js"],"sourcesContent":["import matchTextWithTransliteration from './matchTextWithTransliteration';\nimport splitIntoTokens from '../word/splitIntoTokens';\n\n/**\n * Tokenizes the word form of the keyphrase for exact matching. This function gets the word form and tokenizes it.\n * This function assumes that if a keyphrase needs to be matched exactly, there will be only one word form.\n * This is the result of how the focus keyphrase is processed in buildTopicStems.js in the buildStems function.\n *\n * @param {(string[])}  wordForms \t\t\t\t\tThe word forms to tokenize.\n * @param {function}\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {string[]} The tokenized word forms.\n */\nexport const tokenizeKeyphraseFormsForExactMatching = (wordForms, customSplitIntoTokensHelper) => {\n  // Tokenize word form of the keyphrase.\n  const wordFormText = wordForms[0];\n\n  return customSplitIntoTokensHelper\n    ? customSplitIntoTokensHelper(wordFormText)\n    : splitIntoTokens(wordFormText);\n};\n\n/**\n * Gets the exact matches of the keyphrase.\n * Exact matching happens when the user puts the keyphrase in double quotes.\n *\n * @param {Sentence}\tsentence\t\t\t\t\tThe sentence to match the word forms with.\n * @param {string[]}\twordForms\t\t\t\t\tThe word forms to match.\n * @param {string}\t\tlocale\t\t\t\t\t\tThe locale used in the analysis.\n * @param {function}\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {{count: number, matches: Token[]}} Object containing the number of the exact matches and the matched tokens.\n */\nconst findExactMatchKeyphraseInSentence = (\n  sentence,\n  wordForms,\n  locale,\n  customSplitIntoTokensHelper\n) => {\n  const result = {\n    count: 0,\n    matches: []\n  };\n  // Tokenize word forms of the keyphrase.\n  const keyphraseTokens = tokenizeKeyphraseFormsForExactMatching(\n    wordForms,\n    customSplitIntoTokensHelper\n  );\n  const sentenceTokens = sentence.tokens;\n\n  // Initialize the index of the word token of the keyphrase.\n  let indexOfWordInKeyphrase = 0;\n  // Initialize the index of the word token of the sentence.\n  let indexOfWordInSentence = 0;\n  let currentMatch = [];\n  // Check if the tokenized word forms occur in the same order in the sentence tokens.\n  while (indexOfWordInSentence < sentenceTokens.length) {\n    // If the current sentence token matches the current word token of the keyphrase, add it to the current match.\n    const sentenceTokenText = sentenceTokens[indexOfWordInSentence].text;\n    const keyphraseTokenText = keyphraseTokens[indexOfWordInKeyphrase];\n\n    const foundMatches = matchTextWithTransliteration(\n      sentenceTokenText.toLowerCase(),\n      keyphraseTokenText.toLowerCase(),\n      locale\n    );\n\n    if (foundMatches.length > 0) {\n      currentMatch.push(sentenceTokens[indexOfWordInSentence]);\n      indexOfWordInKeyphrase++;\n    } else {\n      indexOfWordInKeyphrase = 0;\n      currentMatch = [];\n    }\n\n    /*\n     * If the current match has the same length as the keyphrase tokens, the keyphrase forms have been matched.\n     * Add the current match to the matches array and reset the index of the word in keyphrase and the current match.\n     */\n    if (currentMatch.length === keyphraseTokens.length) {\n      result.matches.push(...currentMatch);\n      result.count++;\n      indexOfWordInKeyphrase = 0;\n      currentMatch = [];\n    }\n\n    indexOfWordInSentence++;\n  }\n  return result;\n};\n\n/**\n * Matches a word form of the keyphrase with the tokens from the sentence.\n *\n * With this approach, we transliterate the word form of the keyphrase before matching it with the sentence tokens.\n * However, we don't do the transliteration step for the sentence tokens.\n * As a result, for example, the word form \"acción\" from the keyphrase will match the word \"accion\" in the sentence.\n * But, the word form \"accion\" from the keyphrase will NOT match the word \"acción\" in the sentence.\n *\n * @param {Token[]}\ttokens\t\tThe array of tokens to check.\n * @param {string}\twordForm\tThe word form of the keyphrase.\n * @param {string}\tlocale\t\tThe locale used in the analysis.\n *\n * @returns {Token[]}\tThe array of the matched tokens.\n */\nconst matchWordFormInTokens = (tokens, wordForm, locale) => {\n  let matches = [];\n\n  tokens.forEach(token => {\n    const occurrence = matchTextWithTransliteration(token.text.toLowerCase(), wordForm, locale);\n    if (occurrence.length > 0) {\n      matches = matches.concat(token);\n    }\n  });\n\n  return matches;\n};\n\n/**\n * Finds keyphrase forms in a sentence.\n *\n * @param {Sentence|string}\tsentence\t\t\t\tThe sentence to check.\n * @param {string[]}\t\twordForms\t\t\t\tThe word forms of the keyphrase to check.\n * @param {string}\t\t\tlocale\t\t\t\t\tThe locale used in the analysis.\n * @param {function}\t\tmatchWordCustomHelper\tCustom function to match a word form with sentence.\n *\n * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.\n */\nconst matchWordFormsInSentence = (sentence, wordForms, locale, matchWordCustomHelper) => {\n  const result = {\n    count: 0,\n    matches: []\n  };\n\n  wordForms.forEach(wordForm => {\n    let occurrences = [];\n    if (matchWordCustomHelper) {\n      occurrences = matchWordCustomHelper(sentence, wordForm);\n    } else {\n      const tokens = sentence.tokens.slice();\n      occurrences = matchWordFormInTokens(tokens, wordForm, locale);\n    }\n    result.count += occurrences.length;\n    result.matches = result.matches.concat(occurrences);\n  });\n\n  return result;\n};\n\n/**\n * Matches the word forms of a keyphrase with a sentence object from the html parser.\n *\n * @param {Sentence|string}\tsentence\t\t\t\t\tThe sentence to match against the word forms of a keyphrase.\n * @param {string[]}\t\twordForms\t\t\t\t\tThe array of word forms of the keyphrase.\n * E.g. If the keyphrase is \"key word\", then (if Premium is activated) this will be [ \"key\", \"keys\" ] OR [ \"word\", \"words\" ]\n * The forms are retrieved higher up (among others in keywordCount.js) with researcher.getResearch( \"morphology\" ).\n * @param {string}\t\t\tlocale\t\t\t\t\t\tThe locale used for transliteration.\n * @param {function}\t\tmatchWordCustomHelper\t\tCustom function to match a word form with sentence.\n * @param {boolean}\t\t\tuseExactMatching\t\t\tWhether to match the keyphrase forms exactly or not.\n * \t\t\t\t\t\t\t\t\t\t\t\t\t\tExact match is used when the keyphrase is enclosed in double quotes.\n * @param {function}\t\tcustomSplitIntoTokensHelper\tA custom helper to split sentences into tokens.\n *\n * @returns {{count: number, matches: (Token|string)[]}} Object containing the number of the matches and the matched tokens.\n */\nconst matchWordFormsWithSentence = (\n  sentence,\n  wordForms,\n  locale,\n  matchWordCustomHelper,\n  useExactMatching = false,\n  customSplitIntoTokensHelper\n) => {\n  /*\n   * Only use `findExactMatchKeyphraseInSentence` when the custom helper is not available.\n   * When the custom helper is available, the step for the exact matching happens in the helper.\n   */\n  if (useExactMatching && !matchWordCustomHelper) {\n    return findExactMatchKeyphraseInSentence(\n      sentence,\n      wordForms,\n      locale,\n      customSplitIntoTokensHelper\n    );\n  }\n  return matchWordFormsInSentence(sentence, wordForms, locale, matchWordCustomHelper);\n};\n\nexport default matchWordFormsWithSentence;\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/match/processExactMatchRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"processExactMatchRequest.js","names":["isDoubleQuoted","processExactMatchRequest","keyphrase","exactMatchRequest","exactMatchRequested","substring","length"],"sources":["../../../../src/languageProcessing/helpers/match/processExactMatchRequest.js"],"sourcesContent":["import isDoubleQuoted from \"./isDoubleQuoted\";\n\n/**\n * Checks if exact match functionality is requested by enclosing the keyphrase in double quotation marks.\n *\n * @param {string}  keyphrase       The keyphrase to check. This must be the keyphrase accessed directly from the Paper.\n *\n * @returns {Object} Whether the exact match functionality is requested and the keyword stripped from double quotes.\n */\nexport default function processExactMatchRequest( keyphrase ) {\n\tconst exactMatchRequest = { exactMatchRequested: false, keyphrase: keyphrase };\n\n\t// Check if only exact match processing is requested by the user. If so, strip the quotation marks from the keyphrase.\n\tif ( isDoubleQuoted( keyphrase ) ) {\n\t\texactMatchRequest.keyphrase = keyphrase.substring( 1, keyphrase.length - 1 );\n\t\texactMatchRequest.exactMatchRequested = true;\n\t}\n\n\treturn exactMatchRequest;\n}\n"],"mappings":"AAAA,OAAOA,cAAc;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,wBAAwBA,CAAEC,SAAS,EAAG;EAC7D,MAAMC,iBAAiB,GAAG;IAAEC,mBAAmB,EAAE,KAAK;IAAEF,SAAS,EAAEA;EAAU,CAAC;;EAE9E;EACA,IAAKF,cAAc,CAAEE,SAAU,CAAC,EAAG;IAClCC,iBAAiB,CAACD,SAAS,GAAGA,SAAS,CAACG,SAAS,CAAE,CAAC,EAAEH,SAAS,CAACI,MAAM,GAAG,CAAE,CAAC;IAC5EH,iBAAiB,CAACC,mBAAmB,GAAG,IAAI;EAC7C;EAEA,OAAOD,iBAAiB;AACzB","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/baseStemmer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"baseStemmer.js","names":["baseStemmer","word"],"sources":["../../../../src/languageProcessing/helpers/morphology/baseStemmer.js"],"sourcesContent":["/**\n * Base stemmer that does not stem.\n * This is exported to allow for comparing if a stemmer is the base stemmer.\n *\n * @param {string} word The word to stem.\n *\n * @returns {string} The stemmed word.\n */\nexport default function baseStemmer( word ) {\n\treturn word;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,WAAWA,CAAEC,IAAI,EAAG;EAC3C,OAAOA,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/buildFormRule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildFormRule.js","names":["buildFormRule","word","regexes","includes","i","length","reg","test","replace","repl"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildFormRule.js"],"sourcesContent":["/**\n * Checks if the input word qualifies for the input regex and if so builds a required form.\n * This function is used for other more specific functions.\n *\n * @param {string} word The word to build forms for.\n * @param {Array} regexes The regex-based array of rules to compare the word against.\n *\n * @returns {string} The newly built form of the word.\n */\nexport default function buildFormRule( word, regexes ) {\n\tif ( regexes.includes( null ) ) {\n\t\treturn word;\n\t}\n\tfor ( let i = 0; i < regexes.length; i++ ) {\n\t\tif ( regexes[ i ].reg.test( word ) === true ) {\n\t\t\treturn word.replace( regexes[ i ].reg, regexes[ i ].repl );\n\t\t}\n\t}\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,aAAaA,CAAEC,IAAI,EAAEC,OAAO,EAAG;EACtD,IAAKA,OAAO,CAACC,QAAQ,CAAE,IAAK,CAAC,EAAG;IAC/B,OAAOF,IAAI;EACZ;EACA,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,CAACG,MAAM,EAAED,CAAC,EAAE,EAAG;IAC1C,IAAKF,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,CAACC,IAAI,CAAEN,IAAK,CAAC,KAAK,IAAI,EAAG;MAC7C,OAAOA,IAAI,CAACO,OAAO,CAAEN,OAAO,CAAEE,CAAC,CAAE,CAACE,GAAG,EAAEJ,OAAO,CAAEE,CAAC,CAAE,CAACK,IAAK,CAAC;IAC3D;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/buildTopicStems.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildTopicStems.js","names":["getWords","normalizeSingle","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","isUndefined","escapeRegExp","memoize","isDoubleQuoted","TopicPhrase","constructor","stemOriginalPairs","exactMatch","getStems","map","stemOriginalPair","stem","StemOriginalPair","original","buildStems","keyphrase","stemmer","functionWords","areHyphensWordBoundaries","substring","length","keyphraseWords","wordsWithoutFunctionWords","filter","word","includes","collectKeyphraseAndSynonymsStems","synonyms","keyphraseStems","synonymsStems","synonym","primeLanguageSpecificData","join","collectStems","collectStemsWithLanguageSpecificData"],"sources":["../../../../src/languageProcessing/helpers/morphology/buildTopicStems.js"],"sourcesContent":["import getWords from \"../word/getWords.js\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"@axyseo/config/wordBoundariesWithoutPunctuation\";\n\nimport { isUndefined, escapeRegExp, memoize } from \"lodash\";\nimport isDoubleQuoted from \"../match/isDoubleQuoted\";\n\n/**\n * A TopicPhrase (i.e., a keyphrase or synonym) with stem-original pairs for the words in the topic phrase.\n */\nclass TopicPhrase {\n\t/**\n\t * Constructs a new TopicPhrase.\n\t *\n\t * @param {StemOriginalPair[]} stemOriginalPairs The stem-original pairs for the words in the topic phrase.\n\t * @param {boolean}            exactMatch        Whether the topic phrase is an exact match.\n\t *\n\t * @constructor\n\t */\n\tconstructor( stemOriginalPairs = [], exactMatch = false ) {\n\t\tthis.stemOriginalPairs = stemOriginalPairs;\n\t\tthis.exactMatch = exactMatch;\n\t}\n\n\t/**\n\t * Returns all stems in the topic phrase.\n\t *\n\t * @returns {string[]|[]} The stems in the topic phrase or empty array if the topic phrase is exact match.\n\t */\n\tgetStems() {\n\t\t// An exact match keyphrase doesn't have stems.\n\t\tif ( this.exactMatch ) {\n\t\t\treturn [];\n\t\t}\n\n\t\treturn this.stemOriginalPairs.map( stemOriginalPair => stemOriginalPair.stem );\n\t}\n}\n\n/**\n * A stem-original pair ƒor a word in a topic phrase.\n *\n * @param {string} stem     The stem of the topic phrase word.\n * @param {string} original The original word form the topic phrase (unsanitized)\n *\n * @constructor\n */\nfunction StemOriginalPair( stem, original ) {\n\tthis.stem = stem;\n\tthis.original = original;\n}\n\n/**\n * Analyzes the focus keyword string or one synonym phrase.\n * Checks if morphology is requested or if the user wants to match the exact string.\n * If morphology is required, the module finds a stem for all words (if no function words list is available), or\n * for all content words (i.e., excluding prepositions, articles, conjunctions, if the function words list is available).\n *\n * @param {string}   keyphrase     \t\t\t\tThe keyphrase of the paper (or a synonym phrase) to get stem for.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer.\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {TopicPhrase} Object with an array of StemOriginalPairs of all (content) words in the keyphrase or synonym\n * phrase and information about whether the keyphrase/synonym should be matched exactly.\n */\nconst buildStems = function( keyphrase, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tif ( isUndefined( keyphrase ) || keyphrase === \"\" ) {\n\t\treturn new TopicPhrase();\n\t}\n\n\t// If the keyphrase is embedded in double quotation marks, return the keyphrase itself, without the outermost quotation marks.\n\tif ( isDoubleQuoted( keyphrase ) ) {\n\t\tkeyphrase = keyphrase.substring( 1, keyphrase.length - 1 );\n\t\treturn new TopicPhrase(\n\t\t\t[ new StemOriginalPair( escapeRegExp( keyphrase ), keyphrase ) ],\n\t\t\ttrue\n\t\t);\n\t}\n\n\t/*\n\t * \tIf hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n\t *  hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n\t */\n\tlet keyphraseWords = areHyphensWordBoundaries ? getWords( keyphrase, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( keyphrase, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\t// Filter function words from the keyphrase. Don't filter if the keyphrase only consists of function words.\n\tconst wordsWithoutFunctionWords = keyphraseWords.filter( ( word ) => ! functionWords.includes( word ) );\n\tif ( wordsWithoutFunctionWords.length > 0 ) {\n\t\tkeyphraseWords = wordsWithoutFunctionWords;\n\t}\n\n\t// Return a stem-original pair with a stem.\n\tconst stemOriginalPairs = keyphraseWords.map( word => {\n\t\treturn new StemOriginalPair( stemmer( normalizeSingle( escapeRegExp( word ) ) ), word );\n\t} );\n\n\treturn new TopicPhrase( stemOriginalPairs );\n};\n\n/**\n * Builds stems of words of the keyphrase and of each synonym phrase.\n *\n * @param {string}   keyphrase     \t\t\t\tThe paper's keyphrase.\n * @param {string[]} synonyms     \t\t\t\tThe paper's synonyms.\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nconst collectKeyphraseAndSynonymsStems = function( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst keyphraseStems = buildStems( keyphrase, stemmer, functionWords, areHyphensWordBoundaries );\n\tconst synonymsStems = synonyms.map( synonym => buildStems( synonym, stemmer, functionWords, areHyphensWordBoundaries ) );\n\n\treturn {\n\t\tkeyphraseStems,\n\t\tsynonymsStems,\n\t};\n};\n\n/**\n * Caches stems depending on the currently available stemmer and functionWords and (separately) keyphrase and synonyms.\n * In this way, if the stemmer and functionWords remain the same in multiple calls of this function, the function\n * that collects actual stems only needs to check if the keyphrase and synonyms also remain the\n * same to return the cached result. The joining of keyphrase and synonyms for this function is needed,\n * because by default memoize caches by the first key only, which in the current case would mean that the function would\n * return the cached forms if the keyphrase has not changed (without checking if synonyms were changed).\n *\n * @param {function} stemmer       \t\t\t\tThe language-specific stemmer (if available).\n * @param {string[]} functionWords \t\t\t\tThe language-specific function words.\n * @param {boolean}\t areHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {function} The function that collects the stems for a given set of keyphrase, synonyms, stemmer and functionWords.\n */\nconst primeLanguageSpecificData = memoize( ( stemmer, functionWords, areHyphensWordBoundaries ) => {\n\treturn memoize( ( keyphrase, synonyms ) => {\n\t\treturn collectKeyphraseAndSynonymsStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries );\n\t}, ( keyphrase, synonyms ) => {\n\t\treturn keyphrase + \",\" + synonyms.join( \",\" );\n\t} );\n} );\n\n/**\n * Retrieves stems of words of the keyphrase and of each synonym phrase using the function that caches\n * the results of previous calls of this function.\n *\n * @param {string}      keyphrase       \t\t\tThe paper's keyphrase.\n * @param {string[]}    synonyms        \t\t\tThe paper's synonyms.\n * @param {function}    stemmer         \t\t\tThe language-specific stemmer (if available).\n * @param {string[]}    functionWords   \t\t\tThe language-specific function words.\n * @param {boolean}\t\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {Object} Object with an array of stems of words in the keyphrase and an array of arrays of stems of words in the synonyms.\n */\nfunction collectStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries ) {\n\tconst collectStemsWithLanguageSpecificData = primeLanguageSpecificData( stemmer, functionWords, areHyphensWordBoundaries );\n\n\treturn collectStemsWithLanguageSpecificData( keyphrase, synonyms );\n}\n\nexport {\n\tbuildStems,\n\tcollectStems,\n\tTopicPhrase,\n\tStemOriginalPair,\n\tprimeLanguageSpecificData,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/createRulesFromArrays.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRulesFromArrays.js","names":["createSingleRuleFromArray","rule","flags","length","reg","RegExp","repl","repl1","repl2","createRulesFromArrays","rules","map"],"sources":["../../../../src/languageProcessing/helpers/morphology/createRulesFromArrays.js"],"sourcesContent":["/**\n * Creates an object with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rule        A pair or triplet of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string}  [flags=i]   The regex flags to use.\n *\n * @returns {{ reg: RegExp, repl: string }|{ reg: RegExp, repl1: string, repl2: string }|null} Object to be used in the regex-based rules.\n */\nconst createSingleRuleFromArray = function( rule, flags = \"i\" ) {\n\tif ( rule.length === 2 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl: rule[ 1 ],\n\t\t};\n\t}\n\tif ( rule.length === 3 ) {\n\t\treturn {\n\t\t\treg: new RegExp( rule[ 0 ], flags ),\n\t\t\trepl1: rule[ 1 ],\n\t\t\trepl2: rule[ 2 ],\n\t\t};\n\t}\n\treturn null;\n};\n\n/**\n * Creates an array of objects with a regex and a replacement pair to be processed.\n *\n * @param {Array}   rules       An array with pairs or triplets of strings of which the first one is the regex to match\n *                              and the second (and the third) is the replacement.\n * @param {string} [flags=i]    The regex flags to use.\n *\n * @returns {Array} Array of objects to be used in the regex-based rules.\n */\nconst createRulesFromArrays = function( rules, flags = \"i\" ) {\n\treturn rules.map( rule => createSingleRuleFromArray( rule, flags ) );\n};\n\nexport {\n\tcreateSingleRuleFromArray,\n\tcreateRulesFromArrays,\n};\n\nexport default createRulesFromArrays;\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,yBAAyB,GAAG,SAAAA,CAAUC,IAAI,EAAEC,KAAK,GAAG,GAAG,EAAG;EAC/D,IAAKD,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCI,IAAI,EAAEL,IAAI,CAAE,CAAC;IACd,CAAC;EACF;EACA,IAAKA,IAAI,CAACE,MAAM,KAAK,CAAC,EAAG;IACxB,OAAO;MACNC,GAAG,EAAE,IAAIC,MAAM,CAAEJ,IAAI,CAAE,CAAC,CAAE,EAAEC,KAAM,CAAC;MACnCK,KAAK,EAAEN,IAAI,CAAE,CAAC,CAAE;MAChBO,KAAK,EAAEP,IAAI,CAAE,CAAC;IACf,CAAC;EACF;EACA,OAAO,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMQ,qBAAqB,GAAG,SAAAA,CAAUC,KAAK,EAAER,KAAK,GAAG,GAAG,EAAG;EAC5D,OAAOQ,KAAK,CAACC,GAAG,CAAEV,IAAI,IAAID,yBAAyB,CAAEC,IAAI,EAAEC,KAAM,CAAE,CAAC;AACrE,CAAC;AAED,SACCF,yBAAyB,EACzBS,qBAAqB;AAGtB,eAAeA,qBAAqB","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/exceptionListHelpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exceptionListHelpers.js","names":["flattenSortLength","checkIfWordEndingIsOnExceptionList","word","exceptionList","i","length","endsWith","checkIfWordIsOnListThatCanHavePrefix","prefixesObject","prefixes","foundPrefix","find","prefix","startsWith","stemmedWordWithoutPrefix","slice","includes","checkExceptionListWithTwoStems","exceptionListWithTwoStems","stemSet","foundStem","stemWord","precedingLexicalMaterial"],"sources":["../../../../src/languageProcessing/helpers/morphology/exceptionListHelpers.js"],"sourcesContent":["import flattenSortLength from \"./flattenSortLength\";\n\n/**\n * Checks whether the word ends in one of the words in an exception list that is a simple array.\n *\n * @param {string}\t    word            The word to check.\n * @param {string[]}\texceptionList\tThe list of exceptions.\n *\n * @returns {boolean}\tWhether the checked word ends in one of the words in the exception list.\n */\nexport function checkIfWordEndingIsOnExceptionList( word, exceptionList ) {\n\tfor ( let i = 0; i < exceptionList.length; i++ ) {\n\t\tif ( word.endsWith( exceptionList[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/**\n * Checks whether a word is on the list of words that can have a prefix or not. Before checking the list, checks whether the word has a prefix\n * and if it does, removes it.\n *\n * @param {string}\t \tword\t\t\t\t\tThe word to check.\n * @param {string[]}\texceptionList\t\t\tThe list of exceptions.\n * @param {Object}\t\tprefixesObject\t        An Object that contains the arrays of prefixes.\n *\n * @returns {boolean}\tWhether the word was found on the exception list or not.\n */\nexport function checkIfWordIsOnListThatCanHavePrefix( word, exceptionList, prefixesObject ) {\n\tconst prefixes = flattenSortLength( prefixesObject );\n\n\t// Check whether the inputted word starts with one of the prefixes\n\tconst foundPrefix = prefixes.find( prefix => word.startsWith( prefix ) );\n\tlet stemmedWordWithoutPrefix = \"\";\n\n\tif ( typeof( foundPrefix ) === \"string\" ) {\n\t\tstemmedWordWithoutPrefix = word.slice( foundPrefix.length );\n\t\t// At least 3 characters left after prefix deletion so that e.g. \"be\" is not treated as a prefix if found in the word \"berg\".\n\t\tif ( stemmedWordWithoutPrefix.length > 2 ) {\n\t\t\tword = stemmedWordWithoutPrefix;\n\t\t}\n\t}\n\n\treturn exceptionList.includes( word );\n}\n\n/**\n * Checks whether the word ends in one of the words in an exception list with two stems.\n *\n * @param {Array} exceptionListWithTwoStems The exception list with two stems.\n * @param {string} word\tThe word to check.\n *\n * @returns {string} The stem.\n */\nexport function checkExceptionListWithTwoStems( exceptionListWithTwoStems, word ) {\n\tfor ( const stemSet of exceptionListWithTwoStems ) {\n\t\tconst foundStem =  stemSet.find( stemWord => word.endsWith( stemWord ) );\n\t\tif ( foundStem ) {\n\t\t\tconst precedingLexicalMaterial = word.slice( 0, word.length - foundStem.length );\n\n\t\t\treturn precedingLexicalMaterial + stemSet[ 0 ];\n\t\t}\n\t}\n}\n"],"mappings":"AAAA,OAAOA,iBAAiB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kCAAkCA,CAAEC,IAAI,EAAEC,aAAa,EAAG;EACzE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IAChD,IAAKF,IAAI,CAACI,QAAQ,CAAEH,aAAa,CAAEC,CAAC,CAAG,CAAC,EAAG;MAC1C,OAAO,IAAI;IACZ;EACD;EACA,OAAO,KAAK;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,oCAAoCA,CAAEL,IAAI,EAAEC,aAAa,EAAEK,cAAc,EAAG;EAC3F,MAAMC,QAAQ,GAAGT,iBAAiB,CAAEQ,cAAe,CAAC;;EAEpD;EACA,MAAME,WAAW,GAAGD,QAAQ,CAACE,IAAI,CAAEC,MAAM,IAAIV,IAAI,CAACW,UAAU,CAAED,MAAO,CAAE,CAAC;EACxE,IAAIE,wBAAwB,GAAG,EAAE;EAEjC,IAAK,OAAQJ,WAAa,KAAK,QAAQ,EAAG;IACzCI,wBAAwB,GAAGZ,IAAI,CAACa,KAAK,CAAEL,WAAW,CAACL,MAAO,CAAC;IAC3D;IACA,IAAKS,wBAAwB,CAACT,MAAM,GAAG,CAAC,EAAG;MAC1CH,IAAI,GAAGY,wBAAwB;IAChC;EACD;EAEA,OAAOX,aAAa,CAACa,QAAQ,CAAEd,IAAK,CAAC;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASe,8BAA8BA,CAAEC,yBAAyB,EAAEhB,IAAI,EAAG;EACjF,KAAM,MAAMiB,OAAO,IAAID,yBAAyB,EAAG;IAClD,MAAME,SAAS,GAAID,OAAO,CAACR,IAAI,CAAEU,QAAQ,IAAInB,IAAI,CAACI,QAAQ,CAAEe,QAAS,CAAE,CAAC;IACxE,IAAKD,SAAS,EAAG;MAChB,MAAME,wBAAwB,GAAGpB,IAAI,CAACa,KAAK,CAAE,CAAC,EAAEb,IAAI,CAACG,MAAM,GAAGe,SAAS,CAACf,MAAO,CAAC;MAEhF,OAAOiB,wBAAwB,GAAGH,OAAO,CAAE,CAAC,CAAE;IAC/C;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/findMatchingEndingInArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"findMatchingEndingInArray.js","names":["findMatchingEndingInArray","string","endings","matches","i","endsWith","push","longest","sort","a","b","length"],"sources":["../../../../src/languageProcessing/helpers/morphology/findMatchingEndingInArray.js"],"sourcesContent":["/**\n * Loops through an array of word endings and returns the longest ending that was matched at the end of the string.\n *\n * @param {string}      string       The string to check.\n * @param {string[]}    endings    The word endings to check.\n * @returns {string}    The longest matched ending.\n */\nexport default function findMatchingEndingInArray( string, endings ) {\n\tconst matches = [];\n\tfor ( const i in endings ) {\n\t\tif ( string.endsWith( endings[ i ] ) ) {\n\t\t\tmatches.push( endings[ i ] );\n\t\t}\n\t}\n\n\tconst longest = matches.sort( function( a, b ) {\n\t\treturn b.length - a.length;\n\t} )[ 0 ];\n\n\tif ( longest ) {\n\t\treturn longest;\n\t}\n\treturn \"\";\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,yBAAyBA,CAAEC,MAAM,EAAEC,OAAO,EAAG;EACpE,MAAMC,OAAO,GAAG,EAAE;EAClB,KAAM,MAAMC,CAAC,IAAIF,OAAO,EAAG;IAC1B,IAAKD,MAAM,CAACI,QAAQ,CAAEH,OAAO,CAAEE,CAAC,CAAG,CAAC,EAAG;MACtCD,OAAO,CAACG,IAAI,CAAEJ,OAAO,CAAEE,CAAC,CAAG,CAAC;IAC7B;EACD;EAEA,MAAMG,OAAO,GAAGJ,OAAO,CAACK,IAAI,CAAE,UAAUC,CAAC,EAAEC,CAAC,EAAG;IAC9C,OAAOA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM;EAC3B,CAAE,CAAC,CAAE,CAAC,CAAE;EAER,IAAKJ,OAAO,EAAG;IACd,OAAOA,OAAO;EACf;EACA,OAAO,EAAE;AACV","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/flattenSortLength.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flattenSortLength.js","names":["flatten","flattenSortLength","dataWords","allWords","Object","values","sort","a","b","length","localeCompare"],"sources":["../../../../src/languageProcessing/helpers/morphology/flattenSortLength.js"],"sourcesContent":["import { flatten } from \"lodash\";\n\n/**\n * Returns combined list of strings/words, sorted by length (descending).\n *\n * @param {Object} dataWords The words data that is going to be sorted.\n *\n * @returns {Array<string>} All words, sorted by length (descending).\n */\nexport default function flattenSortLength( dataWords ) {\n\tconst allWords = flatten( Object.values( dataWords ) );\n\n\treturn allWords.sort( ( a, b ) => b.length - a.length || a.localeCompare( b ) );\n}\n"],"mappings":"AAAA,SAASA,OAAO,QAAQ,QAAQ;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,iBAAiBA,CAAEC,SAAS,EAAG;EACtD,MAAMC,QAAQ,GAAGH,OAAO,CAAEI,MAAM,CAACC,MAAM,CAAEH,SAAU,CAAE,CAAC;EAEtD,OAAOC,QAAQ,CAACG,IAAI,CAAE,CAAEC,CAAC,EAAEC,CAAC,KAAMA,CAAC,CAACC,MAAM,GAAGF,CAAC,CAACE,MAAM,IAAIF,CAAC,CAACG,aAAa,CAAEF,CAAE,CAAE,CAAC;AAChF","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/getAllWordsFromPaper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAllWordsFromPaper.js","names":["escapeRegExp","getAltAttribute","normalizeSingle","parseSlug","getWords","getImagesInTree","WORD_BOUNDARY_WITH_HYPHEN","WORD_BOUNDARY_WITHOUT_HYPHEN","paper","areHyphensWordBoundaries","paperText","getText","altTagsInText","map","image","paperContent","getTitle","getSlug","getDescription","join","words","word"],"sources":["../../../../src/languageProcessing/helpers/morphology/getAllWordsFromPaper.js"],"sourcesContent":["import { escapeRegExp } from \"lodash\";\nimport getAltAttribute from \"../image/getAltAttribute\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport parseSlug from \"../url/parseSlug\";\nimport getWords from \"../word/getWords\";\nimport getImagesInTree from \"../image/getImagesInTree\";\nimport { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from \"@axyseo/config/wordBoundariesWithoutPunctuation\";\n\n/**\n * Gets all words found in the text, title, slug and meta description of a given paper.\n *\n * @param {Paper} \tpaper     \t\t\t\t\tThe paper for which to get the words.\n * @param {boolean}\tareHyphensWordBoundaries\tWhether hyphens should be treated as word boundaries.\n *\n * @returns {string[]} All words found.\n */\nexport default function( paper, areHyphensWordBoundaries ) {\n\tconst paperText = paper.getText();\n\tconst altTagsInText = getImagesInTree( paper ).map( image => getAltAttribute( image ) );\n\n\tconst paperContent = [\n\t\tpaperText,\n\t\tpaper.getTitle(),\n\t\tpaper.getSlug(),\n\t\tparseSlug( paper.getSlug() ),\n\t\tpaper.getDescription(),\n\t\taltTagsInText.join( \" \" ),\n\t].join( \" \" );\n\n\t/*\n     * If hyphens should be treated as word boundaries, pass a custom word boundary regex string that includes whitespaces,\n     * hyphens (u002d), and en-dashes (u2013). Otherwise, pass a regex that includes only whitespaces and en-dashes.\n \t */\n\tconst words = areHyphensWordBoundaries ? getWords( paperContent, WORD_BOUNDARY_WITH_HYPHEN )\n\t\t: getWords( paperContent, WORD_BOUNDARY_WITHOUT_HYPHEN );\n\n\treturn words.map(\n\t\tword => normalizeSingle( escapeRegExp( word ) ) );\n}\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,QAAQ;AACrC,OAAOC,eAAe;AACtB,SAASC,eAAe;AACxB,OAAOC,SAAS;AAChB,OAAOC,QAAQ;AACf,OAAOC,eAAe;AACtB,SAASC,yBAAyB,EAAEC,4BAA4B;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,KAAK,EAAEC,wBAAwB,EAAG;EAC1D,MAAMC,SAAS,GAAGF,KAAK,CAACG,OAAO,CAAC,CAAC;EACjC,MAAMC,aAAa,GAAGP,eAAe,CAAEG,KAAM,CAAC,CAACK,GAAG,CAAEC,KAAK,IAAIb,eAAe,CAAEa,KAAM,CAAE,CAAC;EAEvF,MAAMC,YAAY,GAAG,CACpBL,SAAS,EACTF,KAAK,CAACQ,QAAQ,CAAC,CAAC,EAChBR,KAAK,CAACS,OAAO,CAAC,CAAC,EACfd,SAAS,CAAEK,KAAK,CAACS,OAAO,CAAC,CAAE,CAAC,EAC5BT,KAAK,CAACU,cAAc,CAAC,CAAC,EACtBN,aAAa,CAACO,IAAI,CAAE,GAAI,CAAC,CACzB,CAACA,IAAI,CAAE,GAAI,CAAC;;EAEb;AACD;AACA;AACA;EACC,MAAMC,KAAK,GAAGX,wBAAwB,GAAGL,QAAQ,CAAEW,YAAY,EAAET,yBAA0B,CAAC,GACzFF,QAAQ,CAAEW,YAAY,EAAER,4BAA6B,CAAC;EAEzD,OAAOa,KAAK,CAACP,GAAG,CACfQ,IAAI,IAAInB,eAAe,CAAEF,YAAY,CAAEqB,IAAK,CAAE,CAAE,CAAC;AACnD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/regexHelpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regexHelpers.js","names":["doesWordMatchRegex","word","regex","regexObject","RegExp","test","searchAndReplaceWithRegex","groupOfRegexAndReplacements","regexAndReplacement","search","replace","applyAllReplacements","listOfRegexAndReplacement","forEach","setOfRegexAndReplacement"],"sources":["../../../../src/languageProcessing/helpers/morphology/regexHelpers.js"],"sourcesContent":["/**\n * Checks whether a word is matched with a regex.\n *\n * @param {string} word\t\tThe word to check.\n * @param {string} regex\tThe regex.\n *\n * @returns {boolean}\t\tWhether or not there was a match.\n */\nexport function doesWordMatchRegex( word, regex ) {\n\tconst regexObject = RegExp( regex );\n\treturn regexObject.test( word );\n}\n\n/**\n * Loops through a nested array with pairs of regexes and replacements, and performs the needed replacement if a match is found.\n *\n * @param {string} word \t\t\t\t\t\tThe word that may need to be modified.\n * @param {[][]} groupOfRegexAndReplacements \tThe array with the regexes and the required replacements.\n *\n * @returns {?string} The modified stem or null if no match was found.\n */\nexport function searchAndReplaceWithRegex( word, groupOfRegexAndReplacements ) {\n\tfor ( const regexAndReplacement of groupOfRegexAndReplacements ) {\n\t\tif ( word.search( new RegExp( regexAndReplacement[ 0 ] ) ) !== -1 ) {\n\t\t\tword = word.replace( new RegExp( regexAndReplacement[ 0 ] ), regexAndReplacement[ 1 ] );\n\t\t\treturn word;\n\t\t}\n\t}\n}\n\n/**\n * Loops through a nested array of regexes and replacement pairs, and applies all replacements for which a match is found.\n *\n * @param {string}  word                        The word that may need to be modified.\n * @param {[][]}    listOfRegexAndReplacement   The array with the regexes and the replacements.\n *\n * @returns {string} The modified word.\n */\nexport function applyAllReplacements( word, listOfRegexAndReplacement ) {\n\tlistOfRegexAndReplacement.forEach( function( setOfRegexAndReplacement ) {\n\t\tword = word.replace( new RegExp( setOfRegexAndReplacement[ 0 ] ), setOfRegexAndReplacement[ 1 ] );\n\t} );\n\treturn word;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,kBAAkBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACjD,MAAMC,WAAW,GAAGC,MAAM,CAAEF,KAAM,CAAC;EACnC,OAAOC,WAAW,CAACE,IAAI,CAAEJ,IAAK,CAAC;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASK,yBAAyBA,CAAEL,IAAI,EAAEM,2BAA2B,EAAG;EAC9E,KAAM,MAAMC,mBAAmB,IAAID,2BAA2B,EAAG;IAChE,IAAKN,IAAI,CAACQ,MAAM,CAAE,IAAIL,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAE,CAAC,KAAK,CAAC,CAAC,EAAG;MACnEP,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEI,mBAAmB,CAAE,CAAC,CAAG,CAAC,EAAEA,mBAAmB,CAAE,CAAC,CAAG,CAAC;MACvF,OAAOP,IAAI;IACZ;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASU,oBAAoBA,CAAEV,IAAI,EAAEW,yBAAyB,EAAG;EACvEA,yBAAyB,CAACC,OAAO,CAAE,UAAUC,wBAAwB,EAAG;IACvEb,IAAI,GAAGA,IAAI,CAACS,OAAO,CAAE,IAAIN,MAAM,CAAEU,wBAAwB,CAAE,CAAC,CAAG,CAAC,EAAEA,wBAAwB,CAAE,CAAC,CAAG,CAAC;EAClG,CAAE,CAAC;EACH,OAAOb,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/stemHelpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stemHelpers.js","names":["removeSuffixesFromFullForm","list","suffixes","word","i","length","startsWith","suffixRetrieved","substring","j","slice","removeSuffixFromFullForm","exceptions","suffix","endsWith"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemHelpers.js"],"sourcesContent":["/**\n * Checks whether the word starts with one of the words in a given list and ends in one of the suffixes\n * in a given suffixes list. If so, deletes the suffix.\n *\n * @param {string[]}    list  The list of words to check against.\n * @param {string[]}    suffixes    The suffixes that needs to be deleted.\n * @param {string}      word        The word to check.\n * @returns {string}\tThe stemmed word.\n */\nexport function removeSuffixesFromFullForm( list, suffixes, word ) {\n\tfor ( let i = 0; i < list.length; i++ ) {\n\t\tif ( word.startsWith( list[ i ] ) ) {\n\t\t\tconst suffixRetrieved = word.substring( list[ i ].length );\n\t\t\tfor ( let j = 0; j < suffixes.length; j++ ) {\n\t\t\t\tif ( suffixes[ j ] === suffixRetrieved ) {\n\t\t\t\t\treturn word.slice( 0, -suffixRetrieved.length );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Checks whether the word is in a given list of exceptions and if so, deletes a given suffix.\n *\n * @param {string[]}    exceptions  The exception list.\n * @param {string}      suffix      The suffix that needs to be deleted.\n * @param {string}      word        The word to check.\n *\n * @returns {string} The stemmed word.\n */\nexport function removeSuffixFromFullForm( exceptions, suffix, word ) {\n\tfor ( let i = 0; i < exceptions.length; i++ ) {\n\t\tif ( word.endsWith( exceptions[ i ] ) ) {\n\t\t\treturn word.slice( 0, -suffix.length );\n\t\t}\n\t}\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,0BAA0BA,CAAEC,IAAI,EAAEC,QAAQ,EAAEC,IAAI,EAAG;EAClE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,IAAI,CAACI,MAAM,EAAED,CAAC,EAAE,EAAG;IACvC,IAAKD,IAAI,CAACG,UAAU,CAAEL,IAAI,CAAEG,CAAC,CAAG,CAAC,EAAG;MACnC,MAAMG,eAAe,GAAGJ,IAAI,CAACK,SAAS,CAAEP,IAAI,CAAEG,CAAC,CAAE,CAACC,MAAO,CAAC;MAC1D,KAAM,IAAII,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGP,QAAQ,CAACG,MAAM,EAAEI,CAAC,EAAE,EAAG;QAC3C,IAAKP,QAAQ,CAAEO,CAAC,CAAE,KAAKF,eAAe,EAAG;UACxC,OAAOJ,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACH,eAAe,CAACF,MAAO,CAAC;QAChD;MACD;IACD;EACD;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,wBAAwBA,CAAEC,UAAU,EAAEC,MAAM,EAAEV,IAAI,EAAG;EACpE,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGQ,UAAU,CAACP,MAAM,EAAED,CAAC,EAAE,EAAG;IAC7C,IAAKD,IAAI,CAACW,QAAQ,CAAEF,UAAU,CAAER,CAAC,CAAG,CAAC,EAAG;MACvC,OAAOD,IAAI,CAACO,KAAK,CAAE,CAAC,EAAE,CAACG,MAAM,CAACR,MAAO,CAAC;IACvC;EACD;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stemPrefixedFunctionWords.js","names":["stemPrefixedFunctionWords","word","regex","stemmedWord","prefix","isPrefixed","match","slice","length","stem"],"sources":["../../../../src/languageProcessing/helpers/morphology/stemPrefixedFunctionWords.js"],"sourcesContent":["/**\n * An object containing the stem and the prefix.\n *\n * @typedef {Object} \tStemAndPrefixPair\n * @property {string}\tstem The word without the basic prefixes.\n * @property {string}\tprefix The prefix that was matched.\n */\n\n/**\n * Strips function word prefixes from the word.\n *\n * @param {string} word The word to strip the basic prefixes from.\n * @param {RegExp} regex The regular expression to match the function word prefixes.\n * @returns {StemAndPrefixPair} The word without the function word prefixes that was stripped,\n * or the original word if the word is not prefixed.\n */\nexport function stemPrefixedFunctionWords( word, regex ) {\n\t/*\n \t * If a word starts with one of the prefixes, we strip it.\n\t */\n\tlet stemmedWord = word;\n\tlet prefix = \"\";\n\tconst isPrefixed = word.match( regex );\n\n\tif ( isPrefixed ) {\n\t\tprefix = isPrefixed[ 0 ];\n\t\tstemmedWord = word.slice( prefix.length );\n\t}\n\n\treturn { stem: stemmedWord, prefix: prefix };\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,yBAAyBA,CAAEC,IAAI,EAAEC,KAAK,EAAG;EACxD;AACD;AACA;EACC,IAAIC,WAAW,GAAGF,IAAI;EACtB,IAAIG,MAAM,GAAG,EAAE;EACf,MAAMC,UAAU,GAAGJ,IAAI,CAACK,KAAK,CAAEJ,KAAM,CAAC;EAEtC,IAAKG,UAAU,EAAG;IACjBD,MAAM,GAAGC,UAAU,CAAE,CAAC,CAAE;IACxBF,WAAW,GAAGF,IAAI,CAACM,KAAK,CAAEH,MAAM,CAACI,MAAO,CAAC;EAC1C;EAEA,OAAO;IAAEC,IAAI,EAAEN,WAAW;IAAEC,MAAM,EAAEA;EAAO,CAAC;AAC7C","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/directPrecedenceException.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"directPrecedenceException.js","names":["includes","getWords","clause","participle","cannotDirectlyPrecedePassiveParticipleList","wordsInClause","map","word","toLowerCase","participleIndex","indexOf","wordPrecedingParticiple"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/directPrecedenceException.js"],"sourcesContent":["import { includes } from \"lodash\";\nimport getWords from \"../../word/getWords\";\n\n/**\n * Checks whether the participle is directly preceded by a word from the direct precedence exception list.\n * If this is the case, the clause is not passive.\n *\n * @param {string} clause \t\tThe clause that contains the participle.\n * @param {string} participle   The participle.\n * @param {Array} cannotDirectlyPrecedePassiveParticipleList List of words which cannot directly precede a passive participle.\n *\n * @returns {boolean} Returns true if a word from the direct precedence exception list is directly preceding\n *                    the participle, otherwise returns false.\n */\nexport default function( clause, participle, cannotDirectlyPrecedePassiveParticipleList = [] ) {\n\t// Break the sentence part up into words and convert to lower case.\n\tconst wordsInClause = getWords( clause ).map( word => word.toLowerCase() );\n\n\t// Search the participle in the word list.\n\tconst participleIndex = wordsInClause.indexOf( participle.toLowerCase() );\n\n\t/*\n\t * There can be no exception in the following situations:\n\t *\n\t * -1 The participle is not found.\n\t *  0 There is no word before the participle.\n\t */\n\tif ( participleIndex < 1 ) {\n\t\treturn false;\n\t}\n\n\tconst wordPrecedingParticiple = wordsInClause[ participleIndex - 1 ];\n\n\t// Check if the word preceding the participle is in the exceptions list.\n\treturn includes( cannotDirectlyPrecedePassiveParticipleList, wordPrecedingParticiple );\n}\n"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,QAAQ;AACjC,OAAOC,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,UAAU,EAAEC,0CAA0C,GAAG,EAAE,EAAG;EAC9F;EACA,MAAMC,aAAa,GAAGJ,QAAQ,CAAEC,MAAO,CAAC,CAACI,GAAG,CAAEC,IAAI,IAAIA,IAAI,CAACC,WAAW,CAAC,CAAE,CAAC;;EAE1E;EACA,MAAMC,eAAe,GAAGJ,aAAa,CAACK,OAAO,CAAEP,UAAU,CAACK,WAAW,CAAC,CAAE,CAAC;;EAEzE;AACD;AACA;AACA;AACA;AACA;EACC,IAAKC,eAAe,GAAG,CAAC,EAAG;IAC1B,OAAO,KAAK;EACb;EAEA,MAAME,uBAAuB,GAAGN,aAAa,CAAEI,eAAe,GAAG,CAAC,CAAE;;EAEpE;EACA,OAAOT,QAAQ,CAAEI,0CAA0C,EAAEO,uBAAwB,CAAC;AACvF","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getClausesSplitOnStopWords.js","names":["forEach","isEmpty","map","stripSpaces","sanitizeMatches","matches","match","splitOnStopWords","sentence","stopwords","clauses","stopword","clause","split","push","startIndex","indexOf","endIndex","length","substring","splitOnStopCharacter","stopCharacter","i","createClauseObjects","options","clauseObjects","foundAuxiliaries","regexes","auxiliaryRegex","Clause","getClausesSplitOnStopWords","stopwordRegex","stopCharacterRegex"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords.js"],"sourcesContent":["import { forEach, isEmpty, map } from \"lodash\";\n\nimport stripSpaces from \"../../../sanitize/stripSpaces.js\";\n\n/**\n * Strips spaces from the auxiliary matches.\n *\n * @param {Array} matches A list with matches of auxiliaries.\n * @returns {Array} A list with matches with spaces removed.\n */\nfunction sanitizeMatches( matches ) {\n\treturn map( matches, function( match ) {\n\t\treturn stripSpaces( match );\n\t} );\n}\n\n/**\n * Splits sentences into clauses based on stopwords.\n *\n * @param {string} sentence The sentence to split.\n * @param {Array} stopwords The array with matched stopwords.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopWords( sentence, stopwords ) {\n\tconst clauses = [];\n\n\t// Split the sentence on each found stopword and push this part in an array.\n\tforEach( stopwords, function( stopword ) {\n\t\tconst clause = sentence.split( stopword );\n\t\tif ( ! isEmpty( clause[ 0 ] ) ) {\n\t\t\tclauses.push( clause[ 0 ] );\n\t\t}\n\t\tconst startIndex = sentence.indexOf( stopword );\n\t\tconst endIndex = sentence.length;\n\t\tsentence = stripSpaces( sentence.substring( startIndex, endIndex ) );\n\t} );\n\n\t// Push the remainder of the sentence in the clauses array.\n\tclauses.push( sentence );\n\treturn clauses;\n}\n\n/**\n *\n * Splits sentences into clauses based on stopCharacter.\n *\n * @param {string}  sentence        The sentence to split.\n * @param {regex}   stopCharacter   The stop characters regex.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopCharacter( sentence, stopCharacter ) {\n\tconst clauses = sentence.split( stopCharacter );\n\n\t// Strip space in the beginning of the clause, if any.\n\tfor ( let i = 0; i < clauses.length; i++ ) {\n\t\tif ( clauses[ i ][ 0 ] === \" \" ) {\n\t\t\tclauses[ i ] = clauses[ i ].substring( 1, clauses[ i ].length );\n\t\t}\n\t}\n\treturn clauses;\n}\n\n/**\n * Creates clauses based on split sentences.\n\n * @param {Array}   clauses   The array with clauses.\n * @param {Object}  options    The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with sentence parts.\n */\nfunction createClauseObjects( clauses, options ) {\n\tconst clauseObjects = [];\n\tforEach( clauses, function( clause ) {\n\t\tconst foundAuxiliaries = sanitizeMatches( clause.match( options.regexes.auxiliaryRegex || [] ) );\n\t\t// If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.\n\t\tif ( foundAuxiliaries.length !== 0 ) {\n\t\t\tclauseObjects.push( new options.Clause( clause, foundAuxiliaries ) );\n\t\t}\n\t} );\n\treturn clauseObjects;\n}\n\n/**\n * Splits the sentence into clauses based on stopwords.\n *\n * @param {string} sentence The text to split into clauses.\n * @param {Object} options The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with clauses.\n */\nfunction getClausesSplitOnStopWords( sentence, options ) {\n\tconst auxiliaryRegex = options.regexes.auxiliaryRegex;\n\t// First check if there is an auxiliary in the sentence.\n\tif ( sentence.match( auxiliaryRegex ) === null ) {\n\t\treturn [];\n\t}\n\n\tlet clauses;\n\tconst stopwords = sentence.match( options.regexes.stopwordRegex ) || [];\n\t// Split sentences based on stop words\n\tclauses = splitOnStopWords( sentence, stopwords );\n\n\t// \tSplit sentences based on stop characters, only if the regex is available and if the sentence is not yet split from the previous check\n\tif ( typeof( options.regexes.stopCharacterRegex ) !== \"undefined\" && clauses.length === 1 ) {\n\t\tclauses = splitOnStopCharacter( sentence, options.regexes.stopCharacterRegex );\n\t}\n\n\treturn createClauseObjects( clauses, options );\n}\n\nexport default getClausesSplitOnStopWords;\n"],"mappings":"AAAA,SAASA,OAAO,EAAEC,OAAO,EAAEC,GAAG,QAAQ,QAAQ;AAE9C,OAAOC,WAAW;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,eAAeA,CAAEC,OAAO,EAAG;EACnC,OAAOH,GAAG,CAAEG,OAAO,EAAE,UAAUC,KAAK,EAAG;IACtC,OAAOH,WAAW,CAAEG,KAAM,CAAC;EAC5B,CAAE,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,gBAAgBA,CAAEC,QAAQ,EAAEC,SAAS,EAAG;EAChD,MAAMC,OAAO,GAAG,EAAE;;EAElB;EACAV,OAAO,CAAES,SAAS,EAAE,UAAUE,QAAQ,EAAG;IACxC,MAAMC,MAAM,GAAGJ,QAAQ,CAACK,KAAK,CAAEF,QAAS,CAAC;IACzC,IAAK,CAAEV,OAAO,CAAEW,MAAM,CAAE,CAAC,CAAG,CAAC,EAAG;MAC/BF,OAAO,CAACI,IAAI,CAAEF,MAAM,CAAE,CAAC,CAAG,CAAC;IAC5B;IACA,MAAMG,UAAU,GAAGP,QAAQ,CAACQ,OAAO,CAAEL,QAAS,CAAC;IAC/C,MAAMM,QAAQ,GAAGT,QAAQ,CAACU,MAAM;IAChCV,QAAQ,GAAGL,WAAW,CAAEK,QAAQ,CAACW,SAAS,CAAEJ,UAAU,EAAEE,QAAS,CAAE,CAAC;EACrE,CAAE,CAAC;;EAEH;EACAP,OAAO,CAACI,IAAI,CAAEN,QAAS,CAAC;EACxB,OAAOE,OAAO;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASU,oBAAoBA,CAAEZ,QAAQ,EAAEa,aAAa,EAAG;EACxD,MAAMX,OAAO,GAAGF,QAAQ,CAACK,KAAK,CAAEQ,aAAc,CAAC;;EAE/C;EACA,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGZ,OAAO,CAACQ,MAAM,EAAEI,CAAC,EAAE,EAAG;IAC1C,IAAKZ,OAAO,CAAEY,CAAC,CAAE,CAAE,CAAC,CAAE,KAAK,GAAG,EAAG;MAChCZ,OAAO,CAAEY,CAAC,CAAE,GAAGZ,OAAO,CAAEY,CAAC,CAAE,CAACH,SAAS,CAAE,CAAC,EAAET,OAAO,CAAEY,CAAC,CAAE,CAACJ,MAAO,CAAC;IAChE;EACD;EACA,OAAOR,OAAO;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASa,mBAAmBA,CAAEb,OAAO,EAAEc,OAAO,EAAG;EAChD,MAAMC,aAAa,GAAG,EAAE;EACxBzB,OAAO,CAAEU,OAAO,EAAE,UAAUE,MAAM,EAAG;IACpC,MAAMc,gBAAgB,GAAGtB,eAAe,CAAEQ,MAAM,CAACN,KAAK,CAAEkB,OAAO,CAACG,OAAO,CAACC,cAAc,IAAI,EAAG,CAAE,CAAC;IAChG;IACA,IAAKF,gBAAgB,CAACR,MAAM,KAAK,CAAC,EAAG;MACpCO,aAAa,CAACX,IAAI,CAAE,IAAIU,OAAO,CAACK,MAAM,CAAEjB,MAAM,EAAEc,gBAAiB,CAAE,CAAC;IACrE;EACD,CAAE,CAAC;EACH,OAAOD,aAAa;AACrB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASK,0BAA0BA,CAAEtB,QAAQ,EAAEgB,OAAO,EAAG;EACxD,MAAMI,cAAc,GAAGJ,OAAO,CAACG,OAAO,CAACC,cAAc;EACrD;EACA,IAAKpB,QAAQ,CAACF,KAAK,CAAEsB,cAAe,CAAC,KAAK,IAAI,EAAG;IAChD,OAAO,EAAE;EACV;EAEA,IAAIlB,OAAO;EACX,MAAMD,SAAS,GAAGD,QAAQ,CAACF,KAAK,CAAEkB,OAAO,CAACG,OAAO,CAACI,aAAc,CAAC,IAAI,EAAE;EACvE;EACArB,OAAO,GAAGH,gBAAgB,CAAEC,QAAQ,EAAEC,SAAU,CAAC;;EAEjD;EACA,IAAK,OAAQe,OAAO,CAACG,OAAO,CAACK,kBAAoB,KAAK,WAAW,IAAItB,OAAO,CAACQ,MAAM,KAAK,CAAC,EAAG;IAC3FR,OAAO,GAAGU,oBAAoB,CAAEZ,QAAQ,EAAEgB,OAAO,CAACG,OAAO,CAACK,kBAAmB,CAAC;EAC/E;EAEA,OAAOT,mBAAmB,CAAEb,OAAO,EAAEc,OAAQ,CAAC;AAC/C;AAEA,eAAeM,0BAA0B","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nonDirectParticiplePrecedenceException.js","names":["uniq","arrayToRegex","getWordIndices","getIndicesByWordListSorted","clause","participle","auxiliaries","cannotBeBetweenPassiveAuxiliaryAndParticiple","auxiliariesUnique","auxiliaryIndices","participleIndex","indexOf","nonDirectParticiplePrecendenceExceptionRegex","matches","filter","auxiliaryIndex","index","length","participleAuxiliary","precedenceExceptionIndices","remainingPrecedenceExceptionIndices","precedenceExceptionIndex"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException.js"],"sourcesContent":["import { uniq } from \"lodash\";\n\nimport arrayToRegex from \"../../../regex/createRegexFromArray.js\";\nimport getWordIndices from \"../getIndicesWithRegex.js\";\n\nimport { getIndicesByWordListSorted } from \"../../../word/indices.js\";\n\n/**\n * Checks whether there are any exception words in between the auxiliary and participle. If there are, it doesn't return a passive.\n *\n * @param {string} clause \t\t\t\t\t\t\t\t\t\t\tThe clause that contains the participle.\n * @param {string} participle \t\t\t\t\t\t\t\t\t\tThe participle in the clause.\n * @param {string[]} auxiliaries \t\t\t\t\t\t\t\t\tOne or more auxiliaries in the clause.\n * @param {string[]} cannotBeBetweenPassiveAuxiliaryAndParticiple \tThe list of words that cannot be between the auxiliary and participle.\n *\n * @returns {boolean} Returns true if a word from the 'cannot be between passive auxiliary and participle' exception list\n * appears anywhere in between the last (closest to participle) auxiliary and the participle.\n */\nexport default function( clause, participle, auxiliaries, cannotBeBetweenPassiveAuxiliaryAndParticiple ) {\n\tconst auxiliariesUnique = uniq( auxiliaries );\n\n\tconst auxiliaryIndices = getIndicesByWordListSorted( auxiliariesUnique, clause );\n\n\tconst participleIndex = clause.indexOf( participle );\n\tconst nonDirectParticiplePrecendenceExceptionRegex = arrayToRegex( cannotBeBetweenPassiveAuxiliaryAndParticiple );\n\n\t// This exception is only applicable for passive constructions in which the auxiliary precedes the participle.\n\tconst matches = auxiliaryIndices.filter( auxiliaryIndex => auxiliaryIndex.index < participleIndex );\n\n\t// If there are no auxiliaries before the participle, this exception is not applicable.\n\tif ( matches.length === 0 ) {\n\t\treturn false;\n\t}\n\n\t// We pick the auxiliary closest to the participle, since that is most likely the one belonging to the participle.\n\tconst participleAuxiliary = matches[ matches.length - 1 ];\n\n\tconst precedenceExceptionIndices = getWordIndices( clause, nonDirectParticiplePrecendenceExceptionRegex );\n\n\t// Check whether there are any precendence words between the auxiliary and the participle.\n\tconst remainingPrecedenceExceptionIndices = precedenceExceptionIndices.filter( precedenceExceptionIndex =>\n\t\t( precedenceExceptionIndex.index > participleAuxiliary.index && precedenceExceptionIndex.index < participleIndex ) );\n\n\treturn remainingPrecedenceExceptionIndices.length > 0;\n}\n"],"mappings":"AAAA,SAASA,IAAI,QAAQ,QAAQ;AAE7B,OAAOC,YAAY;AACnB,OAAOC,cAAc;AAErB,SAASC,0BAA0B;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,UAAU,EAAEC,WAAW,EAAEC,4CAA4C,EAAG;EACxG,MAAMC,iBAAiB,GAAGR,IAAI,CAAEM,WAAY,CAAC;EAE7C,MAAMG,gBAAgB,GAAGN,0BAA0B,CAAEK,iBAAiB,EAAEJ,MAAO,CAAC;EAEhF,MAAMM,eAAe,GAAGN,MAAM,CAACO,OAAO,CAAEN,UAAW,CAAC;EACpD,MAAMO,4CAA4C,GAAGX,YAAY,CAAEM,4CAA6C,CAAC;;EAEjH;EACA,MAAMM,OAAO,GAAGJ,gBAAgB,CAACK,MAAM,CAAEC,cAAc,IAAIA,cAAc,CAACC,KAAK,GAAGN,eAAgB,CAAC;;EAEnG;EACA,IAAKG,OAAO,CAACI,MAAM,KAAK,CAAC,EAAG;IAC3B,OAAO,KAAK;EACb;;EAEA;EACA,MAAMC,mBAAmB,GAAGL,OAAO,CAAEA,OAAO,CAACI,MAAM,GAAG,CAAC,CAAE;EAEzD,MAAME,0BAA0B,GAAGjB,cAAc,CAAEE,MAAM,EAAEQ,4CAA6C,CAAC;;EAEzG;EACA,MAAMQ,mCAAmC,GAAGD,0BAA0B,CAACL,MAAM,CAAEO,wBAAwB,IACpGA,wBAAwB,CAACL,KAAK,GAAGE,mBAAmB,CAACF,KAAK,IAAIK,wBAAwB,CAACL,KAAK,GAAGN,eAAkB,CAAC;EAErH,OAAOU,mCAAmC,CAACH,MAAM,GAAG,CAAC;AACtD","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/getClauses.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getClauses.js","names":["getIndicesByWordList","getIndicesOfList","filterIndices","sortIndices","stripSpaces","normalizeSingle","normalizeSingleQuotes","getWordIndices","includesIndex","followsIndex","forEach","isUndefined","map","getStopCharacters","sentence","stopCharacterRegex","match","matches","lastIndex","exec","push","index","auxiliaryPrecedenceExceptionFilter","text","auxiliaryMatches","directPrecedenceExceptionRegex","directPrecedenceExceptionMatches","auxiliaryMatch","filter","auxiliaryObject","followingAuxiliaryExceptionFilter","followingAuxiliaryExceptionRegex","followingAuxiliaryExceptionMatches","elisionAuxiliaryExceptionFilter","elisionAuxiliaryExceptionRegex","elisionAuxiliaryExceptionMatches","getSentenceBreakers","options","toLocaleLowerCase","regexes","auxiliaryIndices","auxiliaries","stopCharacterIndices","stopwordIndices","stopwords","otherStopWordIndices","length","concat","totalIndices","getAuxiliaryMatches","sentencePart","auxiliaryRegex","auxiliaryMatchIndices","auxiliaryMatchIndex","getClauses","clauses","indices","i","endIndex","clause","substring","foundClause","Clause"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/getClauses.js"],"sourcesContent":["import { getIndicesByWordList as getIndicesOfList, filterIndices, sortIndices } from \"../../word/indices\";\nimport stripSpaces from \"../../sanitize/stripSpaces.js\";\nimport { normalizeSingle as normalizeSingleQuotes } from \"../../sanitize/quotes.js\";\nimport getWordIndices from \"./getIndicesWithRegex.js\";\nimport includesIndex from \"../../word/includesIndex\";\nimport followsIndex from \"../../word/followsIndex\";\n\nimport { forEach, isUndefined, map } from \"lodash\";\n\n/**\n * Gets stop characters to determine sentence breakers.\n *\n * @param {string} sentence The sentence to get the stop characters from.\n * @param {RegExp} stopCharacterRegex Regex to match the stop characters.\n *\n * @returns {Array} The array with stop characters.\n */\nconst getStopCharacters = function( sentence, stopCharacterRegex ) {\n\tlet match;\n\tconst matches = [];\n\n\tstopCharacterRegex.lastIndex = 0;\n\n\twhile ( ( match = stopCharacterRegex.exec( sentence ) ) !== null ) {\n\t\tmatches.push(\n\t\t\t{\n\t\t\t\tindex: match.index,\n\t\t\t\tmatch: match[ 0 ],\n\t\t\t}\n\t\t);\n\t}\n\treturn matches;\n};\n\n/**\n * Filters auxiliaries preceded by a reflexive pronoun.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} directPrecedenceExceptionRegex The regex needed to find the right auxiliaries.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst auxiliaryPrecedenceExceptionFilter = function( text, auxiliaryMatches, directPrecedenceExceptionRegex ) {\n\tconst directPrecedenceExceptionMatches = getWordIndices( text, directPrecedenceExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( includesIndex( directPrecedenceExceptionMatches, auxiliaryMatch.index ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Filters auxiliaries followed by a word on the followingAuxiliaryExceptionWords list.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} followingAuxiliaryExceptionRegex The regex needed to find the right auxiliaries.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst followingAuxiliaryExceptionFilter = function( text, auxiliaryMatches, followingAuxiliaryExceptionRegex ) {\n\tconst followingAuxiliaryExceptionMatches = getWordIndices( text, followingAuxiliaryExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( followsIndex( followingAuxiliaryExceptionMatches, auxiliaryMatch ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Filters auxiliaries preceded by an elided word (e.g., s') on the elisionAuxiliaryExceptionWords list.\n *\n * @param {string} text The text part in which to check.\n * @param {Array} auxiliaryMatches The auxiliary matches for which to check.\n * @param {RegExp} elisionAuxiliaryExceptionRegex Regex to match the elisionAuxiliary exception.\n *\n * @returns {Array} The filtered list of auxiliary indices.\n */\nconst elisionAuxiliaryExceptionFilter = function( text, auxiliaryMatches, elisionAuxiliaryExceptionRegex ) {\n\tconst elisionAuxiliaryExceptionMatches = getWordIndices( text, elisionAuxiliaryExceptionRegex );\n\n\tforEach( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\tif ( includesIndex( elisionAuxiliaryExceptionMatches, auxiliaryMatch.index, false ) ) {\n\t\t\tauxiliaryMatches = auxiliaryMatches.filter( function( auxiliaryObject ) {\n\t\t\t\treturn auxiliaryObject.index !== auxiliaryMatch.index;\n\t\t\t} );\n\t\t}\n\t} );\n\n\treturn auxiliaryMatches;\n};\n\n/**\n * Gets the indices of sentence breakers (auxiliaries, stopwords and stop characters;\n * in English also active verbs) to determine clauses.\n * Indices are filtered because there could be duplicate matches, like \"even though\" and \"though\".\n * In addition, 'having' will be matched both as a -ing verb as well as an auxiliary.\n *\n * @param {string} sentence The sentence to check for indices of sentence breakers.\n * @param {Object} options The language options for which to match the sentence breakers.\n *\n * @returns {Array} The array with valid indices to use for determining clauses.\n */\nconst getSentenceBreakers = function( sentence, options ) {\n\tsentence = sentence.toLocaleLowerCase();\n\tconst { regexes } = options;\n\tlet auxiliaryIndices = getIndicesOfList( options.auxiliaries, sentence );\n\tconst stopCharacterIndices = getStopCharacters( sentence, regexes.stopCharacterRegex );\n\tlet stopwordIndices = getIndicesOfList( options.stopwords, sentence );\n\n\t// Check in options if there are other stopword indices created based on language-specific rules.\n\tif ( options.otherStopWordIndices && options.otherStopWordIndices.length > 0 ) {\n\t\tstopwordIndices = stopwordIndices.concat( options.otherStopWordIndices );\n\t}\n\n\tif ( typeof regexes.directPrecedenceExceptionRegex !== \"undefined\" ) {\n\t\t// Filters auxiliaries matched in the sentence based on a precedence exception filter.\n\t\tauxiliaryIndices = auxiliaryPrecedenceExceptionFilter( sentence, auxiliaryIndices, regexes.directPrecedenceExceptionRegex );\n\t}\n\n\tif ( typeof regexes.elisionAuxiliaryExceptionRegex !== \"undefined\" ) {\n\t\t// Filters auxiliaries matched in the sentence based on a elision exception filter.\n\t\tauxiliaryIndices = elisionAuxiliaryExceptionFilter( sentence, auxiliaryIndices, regexes.elisionAuxiliaryExceptionRegex );\n\t}\n\n\tlet totalIndices = auxiliaryIndices.concat( stopwordIndices, stopCharacterIndices );\n\n\ttotalIndices = filterIndices( totalIndices );\n\n\treturn sortIndices( totalIndices );\n};\n\n/**\n * Gets the auxiliaries from a sentence.\n *\n * @param {string} sentencePart The part of the sentence to match for auxiliaries.\n * @param {object} regexes The regexes needed to find the auxiliaries.\n *\n * @returns {Array} All formatted matches from the sentence part.\n */\nconst getAuxiliaryMatches = function( sentencePart, regexes ) {\n\tconst { auxiliaryRegex, directPrecedenceExceptionRegex, followingAuxiliaryExceptionRegex } = regexes;\n\tlet auxiliaryMatches = sentencePart.match( auxiliaryRegex ) || [];\n\n\tif ( typeof directPrecedenceExceptionRegex !== \"undefined\" || typeof followingAuxiliaryExceptionRegex !== \"undefined\" ) {\n\t\t// An array with the matched auxiliaries and their indices.\n\t\tlet auxiliaryMatchIndices = getIndicesOfList( auxiliaryMatches, sentencePart );\n\n\t\tif ( typeof directPrecedenceExceptionRegex !== \"undefined\" ) {\n\t\t\t// Filters auxiliaries matched in the sentence part based on a precedence exception filter.\n\t\t\tauxiliaryMatchIndices = auxiliaryPrecedenceExceptionFilter( sentencePart, auxiliaryMatchIndices, directPrecedenceExceptionRegex );\n\t\t}\n\t\t// Filters auxiliaries matched in the sentence part based on a exception filter for words following the auxiliary.\n\t\tauxiliaryMatchIndices = followingAuxiliaryExceptionFilter( sentencePart, auxiliaryMatchIndices, followingAuxiliaryExceptionRegex );\n\n\t\t// An array with the matched auxiliary verbs (without indices).\n\t\tauxiliaryMatches = [];\n\n\t\tforEach( auxiliaryMatchIndices, function( auxiliaryMatchIndex ) {\n\t\t\tauxiliaryMatches.push( auxiliaryMatchIndex.match );\n\t\t} );\n\t}\n\n\treturn map( auxiliaryMatches, function( auxiliaryMatch ) {\n\t\treturn stripSpaces( auxiliaryMatch );\n\t} );\n};\n\n/**\n * Gets the clauses from a sentence by determining sentence breakers.\n *\n * @param {string} sentence The sentence to split up into clauses.\n * @param {object} options The language options for which to get the clauses.\n *\n * @returns {Array} The array with all clauses that have an auxiliary.\n */\nconst getClauses = function( sentence, options ) {\n\tconst clauses = [];\n\tconst auxiliaryRegex = options.regexes.auxiliaryRegex;\n\n\tsentence = normalizeSingleQuotes( sentence );\n\n\t// First check if there is an auxiliary in the sentence.\n\tif ( sentence.match( auxiliaryRegex ) === null ) {\n\t\treturn clauses;\n\t}\n\n\tconst indices = getSentenceBreakers( sentence, options );\n\t// Get the words after the found auxiliary.\n\tfor ( let i = 0; i < indices.length; i++ ) {\n\t\tlet endIndex = sentence.length;\n\t\tif ( ! isUndefined( indices[ i + 1 ] ) ) {\n\t\t\tendIndex = indices[ i + 1 ].index;\n\t\t}\n\n\t\t// Cut the sentence from the current index to the endIndex (start of next breaker, of end of sentence).\n\t\tconst clause = stripSpaces( sentence.substring( indices[ i ].index, endIndex ) );\n\n\t\tconst auxiliaryMatches = getAuxiliaryMatches( clause, options.regexes );\n\t\t// If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.\n\t\tif ( auxiliaryMatches.length !== 0 ) {\n\t\t\tconst foundClause = new options.Clause( clause, auxiliaryMatches );\n\t\t\tclauses.push( foundClause );\n\t\t}\n\t}\n\n\treturn clauses;\n};\n\n/**\n * Split the sentence into clauses based on auxiliaries.\n *\n * @param {string} sentence The sentence to split in parts.\n * @param {Object} options The language options for which to get the clauses.\n *\n * @returns {Array} A list with clauses.\n */\nexport default function( sentence, options ) {\n\treturn getClauses( sentence, options );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/getIndicesWithRegex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getIndicesWithRegex.js","names":["sentencePart","regex","results","match","exec","push","index"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/getIndicesWithRegex.js"],"sourcesContent":["/**\n * Matches words from a list in sentence parts and returns them and their indices.\n *\n * @param {string} sentencePart The sentence part to match the words in.\n * @param {RegExp} regex The regex used for matching.\n * @returns {Array} The list of result objects.\n */\nexport default function( sentencePart, regex ) {\n\tconst results = [];\n\t/* Decided to use a for loop here so that we could retrieve all matches while keeping result objects intact.\n\tFor every match there is in the sentence part, an object with the match and its index will be pushed into\n\tthe results array. */\n\tfor ( let match = regex.exec( sentencePart ); match !== null; match = regex.exec( sentencePart ) ) {\n\t\tresults.push( {\n\t\t\tmatch: match[ 0 ],\n\t\t\tindex: match.index,\n\t\t} );\n\t}\n\treturn results;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,YAAY,EAAEC,KAAK,EAAG;EAC9C,MAAMC,OAAO,GAAG,EAAE;EAClB;AACD;AACA;EACC,KAAM,IAAIC,KAAK,GAAGF,KAAK,CAACG,IAAI,CAAEJ,YAAa,CAAC,EAAEG,KAAK,KAAK,IAAI,EAAEA,KAAK,GAAGF,KAAK,CAACG,IAAI,CAAEJ,YAAa,CAAC,EAAG;IAClGE,OAAO,CAACG,IAAI,CAAE;MACbF,KAAK,EAAEA,KAAK,CAAE,CAAC,CAAE;MACjBG,KAAK,EAAEH,KAAK,CAACG;IACd,CAAE,CAAC;EACJ;EACA,OAAOJ,OAAO;AACf","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/matchRegularParticiples.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchRegularParticiples.js","names":["flattenDeep","regularParticiples","word","regexes","matches","forEach","regex","match","push"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/matchRegularParticiples.js"],"sourcesContent":["import { flattenDeep } from \"lodash\";\n\n/**\n * Returns words that have been determined to be a regular participle.\n *\n * @param {string} word         The word to check.\n * @param {RegExp[]} regexes    The regular participle regexes to match.\n *\n * @returns {Array} A list with the matches.\n */\nexport default function regularParticiples( word, regexes ) {\n\t// Matches word with language-specific participle regexes.\n\tlet matches = [];\n\n\tregexes.forEach( function( regex ) {\n\t\tconst match = word.match( regex );\n\t\tif ( match !== null ) {\n\t\t\tmatches.push( match );\n\t\t}\n\t} );\n\tmatches = flattenDeep( matches );\n\treturn matches;\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,QAAQ;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,kBAAkBA,CAAEC,IAAI,EAAEC,OAAO,EAAG;EAC3D;EACA,IAAIC,OAAO,GAAG,EAAE;EAEhBD,OAAO,CAACE,OAAO,CAAE,UAAUC,KAAK,EAAG;IAClC,MAAMC,KAAK,GAAGL,IAAI,CAACK,KAAK,CAAED,KAAM,CAAC;IACjC,IAAKC,KAAK,KAAK,IAAI,EAAG;MACrBH,OAAO,CAACI,IAAI,CAAED,KAAM,CAAC;IACtB;EACD,CAAE,CAAC;EACHH,OAAO,GAAGJ,WAAW,CAAEI,OAAQ,CAAC;EAChC,OAAOA,OAAO;AACf","ignoreList":[]}

package/build/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"precedenceException.js","names":["includes","getWords","clause","participle","cannotBeBetweenPassiveAuxiliaryAndParticipleList","wordsInClause","map","word","toLowerCase","participleIndex","indexOf","i"],"sources":["../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/precedenceException.js"],"sourcesContent":["import { includes } from \"lodash\";\nimport getWords from \"../../word/getWords\";\n\n/**\n * Checks whether a word from the precedence exception list occurs anywhere in the clause before the participle.\n * If this is the case, the sentence part is not passive.\n *\n * @param {string} clause \t\tThe clause that contains the participle.\n * @param {string} participle   The participle.\n * @param {Array} cannotBeBetweenPassiveAuxiliaryAndParticipleList  List of words which cannot be between auxiliary and participle.\n *\n * @returns {boolean} Returns true if a word from the precedence exception list occurs anywhere in the\n *                    sentence part before the participle, otherwise returns false.\n */\nexport default function( clause, participle, cannotBeBetweenPassiveAuxiliaryAndParticipleList = [] ) {\n\t// Break the sentence part up into words and convert to lower case.\n\tconst wordsInClause = getWords( clause ).map( word => word.toLowerCase() );\n\n\t// Search the participle in the word list.\n\tconst participleIndex = wordsInClause.indexOf( participle.toLowerCase() );\n\n\t/*\n\t * There can be no exception in the following situations:\n\t *\n\t * -1 The participle is not found.\n\t *  0 There is no word before the participle.\n\t */\n\tif ( participleIndex < 1 ) {\n\t\treturn false;\n\t}\n\n\t// Check if the words preceding the participle are in the exceptions list.\n\tfor ( let i = 0; i < participleIndex; i++ ) {\n\t\tif ( includes( cannotBeBetweenPassiveAuxiliaryAndParticipleList, wordsInClause[ i ] ) ) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,QAAQ;AACjC,OAAOC,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,UAAU,EAAEC,gDAAgD,GAAG,EAAE,EAAG;EACpG;EACA,MAAMC,aAAa,GAAGJ,QAAQ,CAAEC,MAAO,CAAC,CAACI,GAAG,CAAEC,IAAI,IAAIA,IAAI,CAACC,WAAW,CAAC,CAAE,CAAC;;EAE1E;EACA,MAAMC,eAAe,GAAGJ,aAAa,CAACK,OAAO,CAAEP,UAAU,CAACK,WAAW,CAAC,CAAE,CAAC;;EAEzE;AACD;AACA;AACA;AACA;AACA;EACC,IAAKC,eAAe,GAAG,CAAC,EAAG;IAC1B,OAAO,KAAK;EACb;;EAEA;EACA,KAAM,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,eAAe,EAAEE,CAAC,EAAE,EAAG;IAC3C,IAAKX,QAAQ,CAAEI,gDAAgD,EAAEC,aAAa,CAAEM,CAAC,CAAG,CAAC,EAAG;MACvF,OAAO,IAAI;IACZ;EACD;EAEA,OAAO,KAAK;AACb","ignoreList":[]}

package/build/languageProcessing/helpers/prominentWords/determineProminentWords.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"determineProminentWords.js","names":["memoize","uniq","getWords","normalizeSingle","ProminentWord","specialCharacters","filterProminentWords","prominentWords","minimalNumberOfOccurrences","filter","word","getOccurrences","getWord","replace","sortProminentWords","sort","wordA","wordB","difference","getStem","localeCompare","collapseProminentWordsOnStem","length","collapsedProminentWords","previousWord","i","currentWord","setOccurrences","toLocaleLowerCase","setWord","push","retrieveAbbreviations","text","words","abbreviations","forEach","toLocaleUpperCase","computeProminentWords","stemmer","functionWords","uniqueContentWords","includes","trim","element","computeProminentWordsMemoized","join","getProminentWords","getWordsCustomHelper","getProminentWordsFromPaperAttributes","attributes","wordsFromAttributes"],"sources":["../../../../src/languageProcessing/helpers/prominentWords/determineProminentWords.js"],"sourcesContent":["import { memoize, uniq } from \"lodash\";\n\nimport getWords from \"../word/getWords\";\nimport { normalizeSingle } from \"../sanitize/quotes\";\nimport ProminentWord from \"../../values/ProminentWord\";\n\nconst specialCharacters = /[1234567890‘’“”\"'.…?!:;,¿¡«»&*@#±^%$|~=+§`[\\](){}⟨⟩<>/\\\\–\\-\\u2014\\u00d7\\s]/g;\n\n/**\n * Returns only those prominent words that occur more than a certain number of times and do not consist of special characters.\n *\n * @param {ProminentWord[]} prominentWords A list of prominent words.\n * @param {int} [minimalNumberOfOccurrences] A minimal number of occurrences that is needed for a relevant prominentWord, default 2.\n *\n * @returns {ProminentWord[]} Only relevant words.\n */\nfunction filterProminentWords( prominentWords, minimalNumberOfOccurrences = 2 ) {\n\tprominentWords = prominentWords.filter( function( word ) {\n\t\treturn (\n\t\t\tword.getOccurrences() >= minimalNumberOfOccurrences &&\n\t\t\tword.getWord().replace( specialCharacters, \"\" ) !== \"\"\n\t\t);\n\t} );\n\treturn prominentWords;\n}\n\n/**\n * Sorts prominent words based on their number of occurrences and length.\n *\n * @param {ProminentWord[]} prominentWords The prominent words to sort.\n *\n * @returns {void}\n */\nfunction sortProminentWords( prominentWords ) {\n\tprominentWords.sort( function( wordA, wordB ) {\n\t\tconst difference = wordB.getOccurrences() - wordA.getOccurrences();\n\t\t// The word with the highest number of occurrences comes first.\n\t\tif ( difference !== 0 ) {\n\t\t\treturn difference;\n\t\t}\n\n\t\t// In case of a tie on occurrence number, the alphabetically first word comes first.\n\t\treturn wordA.getStem().localeCompare( wordB.getStem() );\n\t} );\n}\n\n/**\n * Collapses prominent words that have the same stem.\n *\n * @param {ProminentWord[]} prominentWords All prominentWords.\n *\n * @returns {ProminentWord[]} The original array with collapsed duplicates.\n */\nfunction collapseProminentWordsOnStem( prominentWords ) {\n\tif ( prominentWords.length === 0 ) {\n\t\treturn [];\n\t}\n\n\t// Sort the input array by stem\n\tprominentWords.sort( function( wordA, wordB ) {\n\t\treturn wordA.getStem().localeCompare( wordB.getStem() );\n\t} );\n\n\tconst collapsedProminentWords = [];\n\tlet previousWord = new ProminentWord(\n\t\tprominentWords[ 0 ].getWord(),\n\t\tprominentWords[ 0 ].getStem(),\n\t\tprominentWords[ 0 ].getOccurrences()\n\t);\n\n\tfor ( let i = 1; i < prominentWords.length; i++ ) {\n\t\tconst currentWord = new ProminentWord(\n\t\t\tprominentWords[ i ].getWord(),\n\t\t\tprominentWords[ i ].getStem(),\n\t\t\tprominentWords[ i ].getOccurrences()\n\t\t);\n\n\t\t/*\n\t\t * Compare the stem of the current word in the loop with the previously available stem.\n\t\t * If they are equal, the word should be collapsed.\n\t\t * When collapsing, the numbers of occurrences get summed.\n\t\t * If the stem happens to equal the real word that occurred in the text, we can be sure it's ok to display it\n\t\t * to the customer. So, the stem reassigns the word.\n\t\t */\n\t\tif ( currentWord.getStem() ===  previousWord.getStem() ) {\n\t\t\tpreviousWord.setOccurrences( previousWord.getOccurrences() + currentWord.getOccurrences() );\n\n\t\t\tif ( currentWord.getWord() === previousWord.getStem() || currentWord.getWord().toLocaleLowerCase() === previousWord.getStem() ) {\n\t\t\t\tpreviousWord.setWord( currentWord.getWord() );\n\t\t\t}\n\t\t} else {\n\t\t\tcollapsedProminentWords.push( previousWord );\n\t\t\tpreviousWord = currentWord;\n\t\t}\n\t}\n\n\tcollapsedProminentWords.push( previousWord );\n\n\treturn collapsedProminentWords;\n}\n\n/**\n * Retrieves a list of all abbreviations from the text. Returns an empty array if the input text is empty.\n *\n * @param {string} text A text.\n *\n * @returns {string[]} A list of abbreviations from the list.\n */\nfunction retrieveAbbreviations( text ) {\n\tconst words = getWords( normalizeSingle( text ) );\n\tconst abbreviations = [];\n\n\twords.forEach( function( word ) {\n\t\tif ( word.length > 1 && word.length < 5 && word === word.toLocaleUpperCase() ) {\n\t\t\tabbreviations.push( word.toLocaleLowerCase() );\n\t\t}\n\t} );\n\n\treturn uniq( abbreviations );\n}\n\n/**\n * Computes prominent words from an array of words. In order to do so, checks whether the word is included in the list of\n * function words and determines the number of occurrences for every word. Then checks if any two words have the same stem\n * and if so collapses over them.\n *\n * @param {string[]} words          The words to determine relevance for.\n * @param {string[]} abbreviations  Abbreviations that should not be stemmed.\n * @param {Function} stemmer        The available stemmer.\n * @param {Array} functionWords     The available function words list.\n *\n * @returns {ProminentWord[]} All prominent words sorted and filtered for this text.\n */\nfunction computeProminentWords( words, abbreviations, stemmer, functionWords ) {\n\tif ( words.length === 0 ) {\n\t\treturn [];\n\t}\n\n\tconst uniqueContentWords = uniq( words.filter( word => ! functionWords.includes( word.trim() ) ) );\n\tconst prominentWords = [];\n\n\tuniqueContentWords.forEach( function( word ) {\n\t\tif ( abbreviations.includes( word ) ) {\n\t\t\tprominentWords.push( new ProminentWord(\n\t\t\t\tword.toLocaleUpperCase(),\n\t\t\t\tword,\n\t\t\t\twords.filter( element => element === word ).length\n\t\t\t) );\n\t\t} else {\n\t\t\tprominentWords.push( new ProminentWord(\n\t\t\t\tword,\n\t\t\t\tstemmer( word ),\n\t\t\t\twords.filter( element => element === word ).length\n\t\t\t) );\n\t\t}\n\t} );\n\n\treturn collapseProminentWordsOnStem( prominentWords );\n}\n\n/**\n * Caches prominent words depending on text words.\n * Only the words and abbreviations are used as the cache key as the stemmer and function words\n * are config and shouldn't change in the scope of one request.\n *\n * @param {string[]} words          The words to determine relevance for.\n * @param {string[]} abbreviations  Abbreviations that should not be stemmed.\n * @param {Function} stemmer        The available stemmer.\n * @param {Array} functionWords     The available function words list.\n *\n * @returns {function} The function that collects prominent words for a given set of text words, language and morphologyData.\n */\nconst computeProminentWordsMemoized = memoize( ( words, abbreviations, stemmer, functionWords ) => {\n\treturn computeProminentWords( words, abbreviations, stemmer, functionWords );\n}, ( words, abbreviations ) => {\n\treturn words.join( \",\" ) + \",\" + abbreviations.join( \",\" );\n} );\n\n\n/**\n * Gets prominent words from the paper text.\n *\n * @param {string} text             The text to retrieve the prominent words from.\n * @param {string[]} abbreviations  The abbreviations that occur in the text and attributes of the paper.\n * @param {Function} stemmer        The available stemmer.\n * @param {Array} functionWords     The available function words list.\n * @param {function} getWordsCustomHelper   The custom helper to get words.\n *\n * @returns {ProminentWord[]} All prominent words sorted and filtered for this text.\n */\nfunction getProminentWords( text, abbreviations, stemmer, functionWords, getWordsCustomHelper ) {\n\tif ( text === \"\" ) {\n\t\treturn [];\n\t}\n\n\tconst words = getWordsCustomHelper\n\t\t? getWordsCustomHelper( normalizeSingle( text ).toLocaleLowerCase() )\n\t\t: getWords( normalizeSingle( text ).toLocaleLowerCase() );\n\n\treturn computeProminentWordsMemoized( words, abbreviations, stemmer, functionWords );\n}\n\n/**\n * Gets prominent words from keyphrase and synonyms, metadescription, title, and subheadings.\n *\n * @param {string[]} attributes     The array with attributes to process.\n * @param {string[]} abbreviations  The abbreviations that occur in the text and attributes of the paper.\n * @param {Function} stemmer        The available stemmer.\n * @param {Array} functionWords     The available function words list.\n * @param {function} getWordsCustomHelper   The custom helper to get words.\n *\n * @returns {ProminentWord[]} Prominent words from the paper attributes.\n */\nfunction getProminentWordsFromPaperAttributes( attributes, abbreviations, stemmer, functionWords, getWordsCustomHelper ) {\n\tconst wordsFromAttributes = getWordsCustomHelper\n\t\t? getWordsCustomHelper( attributes.join( \" \" ).toLocaleLowerCase() )\n\t\t: getWords( attributes.join( \" \" ).toLocaleLowerCase() );\n\n\treturn computeProminentWords( wordsFromAttributes, abbreviations, stemmer, functionWords );\n}\n\nexport {\n\tgetProminentWords,\n\tgetProminentWordsFromPaperAttributes,\n\tfilterProminentWords,\n\tsortProminentWords,\n\tcollapseProminentWordsOnStem,\n\tretrieveAbbreviations,\n};\n\nexport default {\n\tgetProminentWords,\n\tgetProminentWordsFromPaperAttributes,\n\tfilterProminentWords,\n\tsortProminentWords,\n\tcollapseProminentWordsOnStem,\n\tretrieveAbbreviations,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/regex/createRegexFromArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRegexFromArray.js","names":["map","addWordBoundary","replaceDiacritics","sanitizeString","array","disableWordBoundary","extraBoundary","doReplaceDiacritics","string","regexString","join","RegExp"],"sources":["../../../../src/languageProcessing/helpers/regex/createRegexFromArray.js"],"sourcesContent":["/** @module stringProcessing/createRegexFromArray */\n\nimport { map } from \"lodash\";\nimport addWordBoundary from \"../word/addWordboundary.js\";\nimport replaceDiacritics from \"../transliterate/replaceDiacritics\";\nimport sanitizeString from \"../sanitize/sanitizeString\";\n\n/**\n * Creates a regex of combined strings from the input array.\n *\n * @param {string[]} array                      The array with strings\n * @param {boolean} [disableWordBoundary=false] Boolean indicating whether or not to disable word boundaries.\n * @param {string} [extraBoundary=\"\"]           A string that is used as extra boundary for the regex.\n * @param {boolean} [doReplaceDiacritics=false] If set to true, it replaces diacritics. Defaults to false.\n *\n * @returns {RegExp} regex                              The regex created from the array.\n */\nexport default function( array, disableWordBoundary = false, extraBoundary = \"\", doReplaceDiacritics = false ) {\n\tarray = map( array, function( string ) {\n\t\tif ( doReplaceDiacritics ) {\n\t\t\tstring = replaceDiacritics( string );\n\t\t}\n\n\t\tstring = sanitizeString( string );\n\n\t\tif ( disableWordBoundary ) {\n\t\t\treturn string;\n\t\t}\n\t\treturn addWordBoundary( string, true, extraBoundary );\n\t} );\n\n\tconst regexString = \"(\" + array.join( \")|(\" ) + \")\";\n\n\treturn new RegExp( regexString, \"ig\" );\n}\n"],"mappings":"AAAA;;AAEA,SAASA,GAAG,QAAQ,QAAQ;AAC5B,OAAOC,eAAe;AACtB,OAAOC,iBAAiB;AACxB,OAAOC,cAAc;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,KAAK,EAAEC,mBAAmB,GAAG,KAAK,EAAEC,aAAa,GAAG,EAAE,EAAEC,mBAAmB,GAAG,KAAK,EAAG;EAC9GH,KAAK,GAAGJ,GAAG,CAAEI,KAAK,EAAE,UAAUI,MAAM,EAAG;IACtC,IAAKD,mBAAmB,EAAG;MAC1BC,MAAM,GAAGN,iBAAiB,CAAEM,MAAO,CAAC;IACrC;IAEAA,MAAM,GAAGL,cAAc,CAAEK,MAAO,CAAC;IAEjC,IAAKH,mBAAmB,EAAG;MAC1B,OAAOG,MAAM;IACd;IACA,OAAOP,eAAe,CAAEO,MAAM,EAAE,IAAI,EAAEF,aAAc,CAAC;EACtD,CAAE,CAAC;EAEH,MAAMG,WAAW,GAAG,GAAG,GAAGL,KAAK,CAACM,IAAI,CAAE,KAAM,CAAC,GAAG,GAAG;EAEnD,OAAO,IAAIC,MAAM,CAAEF,WAAW,EAAE,IAAK,CAAC;AACvC","ignoreList":[]}

package/build/languageProcessing/helpers/regex/createRegexFromDoubleArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRegexFromDoubleArray.js","names":["addWordBoundary","wordCombinationToRegexString","array","map","word","join","wordCombination","regexString","RegExp"],"sources":["../../../../src/languageProcessing/helpers/regex/createRegexFromDoubleArray.js"],"sourcesContent":["/** @module stringProcessing/createRegexFromDoubleArray */\n\nimport addWordBoundary from \"../word/addWordboundary.js\";\n\n/**\n * Creates a regex string of combined strings from the input array.\n *\n * @param {array} array The array containing the various parts of a transition word combination.\n *\n * @returns {array} The array with replaced entries.\n */\nconst wordCombinationToRegexString = function( array ) {\n\tarray = array.map( function( word ) {\n\t\treturn addWordBoundary( word );\n\t} );\n\treturn array.join( \"(.*?)\" );\n};\n\n/**\n * Creates a regex of combined strings from the input array, containing arrays with two entries.\n *\n * @param {array} array The array containing arrays.\n *\n * @returns {RegExp} The regex created from the array.\n */\nexport default function( array ) {\n\tarray = array.map( function( wordCombination ) {\n\t\treturn wordCombinationToRegexString( wordCombination );\n\t} );\n\n\tconst regexString = \"(\" + array.join( \")|(\" ) + \")\";\n\n\treturn new RegExp( regexString, \"ig\" );\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,eAAe;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,4BAA4B,GAAG,SAAAA,CAAUC,KAAK,EAAG;EACtDA,KAAK,GAAGA,KAAK,CAACC,GAAG,CAAE,UAAUC,IAAI,EAAG;IACnC,OAAOJ,eAAe,CAAEI,IAAK,CAAC;EAC/B,CAAE,CAAC;EACH,OAAOF,KAAK,CAACG,IAAI,CAAE,OAAQ,CAAC;AAC7B,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUH,KAAK,EAAG;EAChCA,KAAK,GAAGA,KAAK,CAACC,GAAG,CAAE,UAAUG,eAAe,EAAG;IAC9C,OAAOL,4BAA4B,CAAEK,eAAgB,CAAC;EACvD,CAAE,CAAC;EAEH,MAAMC,WAAW,GAAG,GAAG,GAAGL,KAAK,CAACG,IAAI,CAAE,KAAM,CAAC,GAAG,GAAG;EAEnD,OAAO,IAAIG,MAAM,CAAED,WAAW,EAAE,IAAK,CAAC;AACvC","ignoreList":[]}

package/build/languageProcessing/helpers/regex/createWordRegex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createWordRegex.js","names":["escapeRegExp","isUndefined","memoize","sanitizeString","replaceDiacritics","addWordBoundary","string","extraBoundary","doReplaceDiacritics","RegExp"],"sources":["../../../../src/languageProcessing/helpers/regex/createWordRegex.js"],"sourcesContent":["/** @module stringProcessing/stringToRegex */\nimport { escapeRegExp, isUndefined, memoize } from \"lodash\";\nimport sanitizeString from \"../sanitize/sanitizeString\";\nimport replaceDiacritics from \"../transliterate/replaceDiacritics.js\";\nimport addWordBoundary from \"../word/addWordboundary.js\";\n\n/**\n * Creates a regex from a string so it can be matched everywhere in the same way.\n *\n * @param {string}  string                     The string to make a regex from.\n * @param {string}  [extraBoundary=\"\"]         A string that is used as extra boundary for the regex.\n * @param {boolean} [doReplaceDiacritics=true] If set to false, it doesn't replace diacritics. Defaults to true.\n *\n * @returns {RegExp} regex The regex made from the keyword\n */\nexport default memoize( function( string, extraBoundary, doReplaceDiacritics ) {\n\tif ( isUndefined( extraBoundary ) ) {\n\t\textraBoundary = \"\";\n\t}\n\n\tif ( isUndefined( doReplaceDiacritics ) || doReplaceDiacritics === true ) {\n\t\tstring = replaceDiacritics( string );\n\t}\n\n\tstring = sanitizeString( string );\n\tstring = escapeRegExp( string );\n\tstring = addWordBoundary( string, false, extraBoundary );\n\n\treturn new RegExp( string, \"ig\" );\n} );\n"],"mappings":"AAAA;AACA,SAASA,YAAY,EAAEC,WAAW,EAAEC,OAAO,QAAQ,QAAQ;AAC3D,OAAOC,cAAc;AACrB,OAAOC,iBAAiB;AACxB,OAAOC,eAAe;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAeH,OAAO,CAAE,UAAUI,MAAM,EAAEC,aAAa,EAAEC,mBAAmB,EAAG;EAC9E,IAAKP,WAAW,CAAEM,aAAc,CAAC,EAAG;IACnCA,aAAa,GAAG,EAAE;EACnB;EAEA,IAAKN,WAAW,CAAEO,mBAAoB,CAAC,IAAIA,mBAAmB,KAAK,IAAI,EAAG;IACzEF,MAAM,GAAGF,iBAAiB,CAAEE,MAAO,CAAC;EACrC;EAEAA,MAAM,GAAGH,cAAc,CAAEG,MAAO,CAAC;EACjCA,MAAM,GAAGN,YAAY,CAAEM,MAAO,CAAC;EAC/BA,MAAM,GAAGD,eAAe,CAAEC,MAAM,EAAE,KAAK,EAAEC,aAAc,CAAC;EAExD,OAAO,IAAIE,MAAM,CAAEH,MAAM,EAAE,IAAK,CAAC;AAClC,CAAE,CAAC","ignoreList":[]}

package/build/languageProcessing/helpers/regex/matchStringWithRegex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchStringWithRegex.js","names":["text","regex","matches","match"],"sources":["../../../../src/languageProcessing/helpers/regex/matchStringWithRegex.js"],"sourcesContent":["/** @module stringProcessing/matchStringWithRegex */\n\n/**\n * Checks a string with a regex, return all matches found with that regex.\n *\n * @param {String} \t\ttext        The text to match.\n * @param {object} \t\tregex  \t\tA compiled regular expression.\n *\n * @returns {Array} Array with matches, empty array if no matches found.\n */\nexport default function( text, regex ) {\n\tlet matches = text.match( regex );\n\n\tif ( matches === null ) {\n\t\tmatches = [];\n\t}\n\n\treturn matches;\n}\n"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAEC,KAAK,EAAG;EACtC,IAAIC,OAAO,GAAGF,IAAI,CAACG,KAAK,CAAEF,KAAM,CAAC;EAEjC,IAAKC,OAAO,KAAK,IAAI,EAAG;IACvBA,OAAO,GAAG,EAAE;EACb;EAEA,OAAOA,OAAO;AACf","ignoreList":[]}

package/build/languageProcessing/helpers/regex/searchAndReplaceWithOneRegex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchAndReplaceWithOneRegex.js","names":["searchAndReplaceWithOneRegex","word","regexAndReplacement","search","RegExp","replace"],"sources":["../../../../src/languageProcessing/helpers/regex/searchAndReplaceWithOneRegex.js"],"sourcesContent":["/**\n * Checks whether a given regex matches a given word and if so, performs the replacement.\n *\n * @param {string}      word \t\t\t\t\tThe word that may need to be modified.\n * @param {string[]}    regexAndReplacement     A regex and the required replacement.\n *\n * @returns {?string} The modified stem or undefined if no match was found.\n */\nexport default function searchAndReplaceWithOneRegex( word, regexAndReplacement ) {\n\tif ( word.search( new RegExp( regexAndReplacement[ 0 ] ) ) !== -1 ) {\n\t\tword = word.replace( new RegExp( regexAndReplacement[ 0 ] ), regexAndReplacement[ 1 ] );\n\t\treturn word;\n\t}\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,4BAA4BA,CAAEC,IAAI,EAAEC,mBAAmB,EAAG;EACjF,IAAKD,IAAI,CAACE,MAAM,CAAE,IAAIC,MAAM,CAAEF,mBAAmB,CAAE,CAAC,CAAG,CAAE,CAAC,KAAK,CAAC,CAAC,EAAG;IACnED,IAAI,GAAGA,IAAI,CAACI,OAAO,CAAE,IAAID,MAAM,CAAEF,mBAAmB,CAAE,CAAC,CAAG,CAAC,EAAEA,mBAAmB,CAAE,CAAC,CAAG,CAAC;IACvF,OAAOD,IAAI;EACZ;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/doubleQuotes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"doubleQuotes.js","names":[],"sources":["../../../../src/languageProcessing/helpers/sanitize/doubleQuotes.js"],"sourcesContent":["/**\n * Returns an array with double quotes.\n *\n * Japanese-specific quotes:\n * U300c - left corner bracket.\n * U300d - right corner bracket.\n * U300e - left white corner bracket.\n * U300f - right white corner bracket.\n *\n * @returns {string[]} The array with double quotes..\n */\nexport default [ \"“\", \"”\", \"〝\", \"〞\", \"〟\", \"‟\", \"„\", \"\\\"\", \"\\u300c\", \"\\u300d\", \"\\u300e\", \"\\u300f\" ];\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,CAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAE","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/filterShortcodesFromTree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterShortcodesFromTree.js","names":["createShortcodeTagsRegex","shortcodeTags","shortcodeTagsRegexString","join","RegExp","filterShortcodesFromHTML","html","length","shortcodeTagsRegex","replace","tokenIsPartOfOpeningShortcode","tokens","index","text","tokenIsPartOfClosingShortcode","tokenIsShortcode","encounteredClosingBracket","includes","filterShortcodesFromSentence","sentence","i","splice","filterShortcodesFromSentences","tree","sentences","forEach","childNodes","childNode","filterShortcodesFromTree"],"sources":["../../../../src/languageProcessing/helpers/sanitize/filterShortcodesFromTree.js"],"sourcesContent":["\n/**\n * Creates a regex to filter shortcodes from HTML.\n * @param {string[]} shortcodeTags The tags of the shortcodes to filter.\n * @returns {RegExp} The regex to recognize the shortcodes.\n */\nexport const createShortcodeTagsRegex = shortcodeTags => {\n\tconst shortcodeTagsRegexString = `\\\\[\\\\/?(${ shortcodeTags.join( \"|\" ) })[^\\\\]]*\\\\]`;\n\treturn new RegExp( shortcodeTagsRegexString, \"g\" );\n};\n\n/**\n * Filters shortcodes from HTML string.\n * @param {string} html The HTML to filter.\n * @param {string[]} shortcodeTags The tags of the shortcodes to filter.\n * @returns {string} The filtered HTML.\n */\nexport const filterShortcodesFromHTML = ( html, shortcodeTags ) => {\n\tif ( ! shortcodeTags || shortcodeTags.length === 0 ) {\n\t\treturn html;\n\t}\n\tconst shortcodeTagsRegex = createShortcodeTagsRegex( shortcodeTags );\n\treturn html.replace( shortcodeTagsRegex, \"\" );\n};\n\n/**\n * Checks if a token is part of an opening shortcode.\n * @param {Token[]} tokens The tokens to check.\n * @param {number} index The index of the current token.\n * @returns {boolean} Whether the token is part of an opening shortcode.\n */\nconst tokenIsPartOfOpeningShortcode = ( tokens, index ) => {\n\treturn tokens[ index - 1 ] && tokens[ index - 1 ].text === \"[\";\n};\n\n/**\n * Checks if a token is part of a closing shortcode.\n * @param {Token[]} tokens The tokens to check.\n * @param {number} index The index of the current token.\n * @returns {boolean} Whether the token is part of a closing shortcode.\n */\nconst tokenIsPartOfClosingShortcode = ( tokens, index ) => {\n\treturn  tokens[ index - 1 ] && tokens[ index - 1 ].text === \"/\"  && tokens[ index - 2 ]  && tokens[ index - 2 ].text === \"[\";\n};\n\n/**\n * Checks if a token is part of a shortcode.\n * @param {Token[]} tokens The tokens to check.\n * @param {number} index The index of the current token.\n * @param {string[]} shortcodeTags An array of active shortcode tags.\n * @param {boolean} encounteredClosingBracket Whether a closing bracket has been encountered (while looping backwards through the tokens).\n * @returns {boolean} Whether the token is part of a shortcode.\n */\nconst tokenIsShortcode = ( tokens, index, shortcodeTags, encounteredClosingBracket ) => {\n\treturn encounteredClosingBracket && shortcodeTags.includes( tokens[ index ].text ) &&\n\t\t( tokenIsPartOfOpeningShortcode( tokens, index ) || tokenIsPartOfClosingShortcode( tokens, index )  );\n};\n\n/**\n * Filters shortcodes from a sentence.\n * @param {Sentence} sentence The sentence to filter.\n * @param {string[]} shortcodeTags The tags of the shortcodes to filter.\n * @param {RegExp} shortcodeTagsRegex The regex to filter the shortcodes.\n * @returns {void}\n *\n */\nconst filterShortcodesFromSentence = ( sentence, shortcodeTags, shortcodeTagsRegex ) => {\n\tconst tokens = sentence.tokens;\n\n\tlet encounteredClosingBracket = false;\n\t// traverse through tokens backwards\n\tfor ( let i = tokens.length - 1; i >= 0; i-- ) {\n\t\tif ( tokens[ i ].text === \"]\" ) {\n\t\t\tencounteredClosingBracket = true;\n\t\t}\n\n\t\tif ( tokenIsShortcode( tokens, i, shortcodeTags, encounteredClosingBracket ) ) {\n\t\t\twhile ( tokens[ i ].text !== \"]\" ) {\n\t\t\t\ttokens.splice( i, 1 );\n\t\t\t}\n\t\t\ttokens.splice( i, 1 );\n\t\t\tencounteredClosingBracket = false;\n\n\t\t\twhile ( tokens[ i - 1 ] && \"[/\".includes( tokens[ i - 1 ].text ) ) {\n\t\t\t\ttokens.splice( i - 1, 1 );\n\t\t\t\ti--;\n\t\t\t}\n\t\t}\n\t}\n\tsentence.tokens = tokens;\n\n\tsentence.text = sentence.text.replace( shortcodeTagsRegex, \"\" );\n};\n\n/**\n * A recursive function that filters shortcodes from sentences.\n * @param {Node} tree The tree to filter.\n * @param {string[]} shortcodeTags The tags of the shortcodes to filter.\n * @param {RegExp} shortcodeTagsRegex The regex to filter the shortcodes.\n * @returns {void}\n */\nconst filterShortcodesFromSentences = ( tree, shortcodeTags, shortcodeTagsRegex ) => {\n\tif ( tree.sentences ) {\n\t\ttree.sentences.forEach( sentence => {\n\t\t\tfilterShortcodesFromSentence( sentence, shortcodeTags, shortcodeTagsRegex );\n\t\t} );\n\t}\n\n\tif ( tree.childNodes ) {\n\t\ttree.childNodes.forEach( childNode => {\n\t\t\tfilterShortcodesFromSentences( childNode, shortcodeTags, shortcodeTagsRegex );\n\t\t} );\n\t}\n};\n\n/**\n * Filters shortcodes from the tree.\n * @param {Node} tree The tree to filter.\n * @param {string[]} shortcodeTags The tags of the shortcodes to filter.\n * @returns {void}\n */\nconst filterShortcodesFromTree = ( tree, shortcodeTags ) => {\n\tif ( ! shortcodeTags || shortcodeTags.length === 0 ) {\n\t\treturn;\n\t}\n\tconst shortcodeTagsRegex = createShortcodeTagsRegex( shortcodeTags );\n\n\tfilterShortcodesFromSentences( tree, shortcodeTags, shortcodeTagsRegex );\n};\n\nexport default filterShortcodesFromTree;\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/mergeListItems.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mergeListItems.js","names":["mergeListItems","text","listTags","listItemTags","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/mergeListItems.js"],"sourcesContent":["/**\n * Removes list-related html tags in a text to be used for the keyphrase distribution assessment.\n * That way, lists with single words don't result in a skewed keyphrase distribution result.\n *\n * @param {string}  text    The text in which to remove the list structures.\n *\n * @returns {string} The text with all list structures removed.\n */\nexport function mergeListItems( text ) {\n\tconst listTags = /<\\/?(o|ul)(?:[^>]+)?>/g;\n\tconst listItemTags = /\\s?<\\/?li(?:[^>]+)?>\\s?/g;\n\n\t/*\n\t * Steps:\n\t * 1) Remove all ul and ol tags.\n\t * 2) Replace all li tags with spaces to avoid list items being stuck together.\n\t * 3) Replace multiple instances of whitespace with a single instance.\n\t */\n\ttext = text.replace( listTags, \"\" );\n\ttext = text.replace( listItemTags, \" \" );\n\ttext = text.replace( /\\s+/g, \" \" );\n\n\treturn text;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,cAAcA,CAAEC,IAAI,EAAG;EACtC,MAAMC,QAAQ,GAAG,wBAAwB;EACzC,MAAMC,YAAY,GAAG,0BAA0B;;EAE/C;AACD;AACA;AACA;AACA;AACA;EACCF,IAAI,GAAGA,IAAI,CAACG,OAAO,CAAEF,QAAQ,EAAE,EAAG,CAAC;EACnCD,IAAI,GAAGA,IAAI,CAACG,OAAO,CAAED,YAAY,EAAE,GAAI,CAAC;EACxCF,IAAI,GAAGA,IAAI,CAACG,OAAO,CAAE,MAAM,EAAE,GAAI,CAAC;EAElC,OAAOH,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/parseSynonyms.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseSynonyms.js","names":["stripSpaces","removePunctuationExceptQuotes","synonyms","synonymsSplit","split","map","synonym","filter"],"sources":["../../../../src/languageProcessing/helpers/sanitize/parseSynonyms.js"],"sourcesContent":["/** @module stringProcessing/parseSynonyms */\n\nimport stripSpaces from \"./stripSpaces.js\";\nimport removePunctuationExceptQuotes from \"./removePunctuationExceptQuotes.js\";\n\n/**\n * Parses synonyms from a comma-separated string into an array.\n *\n * @param {String} synonyms The text to match\n *\n * @returns {Array} An array with all synonyms.\n */\nexport default function( synonyms ) {\n\tlet synonymsSplit = synonyms.split( \",\" );\n\n\tsynonymsSplit = synonymsSplit.map( synonym =>\n\t\tremovePunctuationExceptQuotes( stripSpaces( synonym ) ) ).filter( synonym => synonym );\n\n\treturn synonymsSplit;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,WAAW;AAClB,OAAOC,6BAA6B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,QAAQ,EAAG;EACnC,IAAIC,aAAa,GAAGD,QAAQ,CAACE,KAAK,CAAE,GAAI,CAAC;EAEzCD,aAAa,GAAGA,aAAa,CAACE,GAAG,CAAEC,OAAO,IACzCL,6BAA6B,CAAED,WAAW,CAAEM,OAAQ,CAAE,CAAE,CAAC,CAACC,MAAM,CAAED,OAAO,IAAIA,OAAQ,CAAC;EAEvF,OAAOH,aAAa;AACrB","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/quotes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"quotes.js","names":["SINGLE_QUOTES_ARRAY","SINGLE_QUOTES_REGEX","RegExp","join","normalizeSingleQuotes","text","replace","normalizeDoubleQuotes","normalizeQuotes","normalizeSingle","normalizeDouble","normalize"],"sources":["../../../../src/languageProcessing/helpers/sanitize/quotes.js"],"sourcesContent":["const SINGLE_QUOTES_ARRAY = [ \"'\", \"‘\", \"’\", \"‛\", \"`\", \"‹\", \"›\" ];\nconst SINGLE_QUOTES_REGEX = new RegExp( \"[\" + SINGLE_QUOTES_ARRAY.join( \"\" ) + \"]\", \"g\" );\n\n/**\n * Normalizes single quotes to 'regular' quotes.\n *\n * @param {string} text Text to normalize.\n * @returns {string} The normalized text.\n */\nfunction normalizeSingleQuotes( text ) {\n\treturn text.replace( SINGLE_QUOTES_REGEX, \"'\" );\n}\n\n/**\n * Normalizes double quotes to 'regular' quotes.\n *\n * @param {string} text Text to normalize.\n * @returns {string} The normalized text.\n */\nfunction normalizeDoubleQuotes( text ) {\n\treturn text.replace( /[“”〝〞〟‟„『』«»]/g, \"\\\"\" );\n}\n\n/**\n * Normalizes quotes to 'regular' quotes.\n *\n * @param {string} text Text to normalize.\n * @returns {string} The normalized text.\n */\nfunction normalizeQuotes( text ) {\n\treturn normalizeDoubleQuotes( normalizeSingleQuotes( text ) );\n}\n\nexport {\n\tnormalizeSingleQuotes as normalizeSingle,\n\tnormalizeDoubleQuotes as normalizeDouble,\n\tnormalizeQuotes as normalize,\n\tSINGLE_QUOTES_REGEX,\n\tSINGLE_QUOTES_ARRAY,\n};\n\nexport default {\n\tnormalizeSingle: normalizeSingleQuotes,\n\tnormalizeDouble: normalizeDoubleQuotes,\n\tnormalize: normalizeQuotes,\n};\n"],"mappings":"AAAA,MAAMA,mBAAmB,GAAG,CAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAE;AACjE,MAAMC,mBAAmB,GAAG,IAAIC,MAAM,CAAE,GAAG,GAAGF,mBAAmB,CAACG,IAAI,CAAE,EAAG,CAAC,GAAG,GAAG,EAAE,GAAI,CAAC;;AAEzF;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,qBAAqBA,CAAEC,IAAI,EAAG;EACtC,OAAOA,IAAI,CAACC,OAAO,CAAEL,mBAAmB,EAAE,GAAI,CAAC;AAChD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASM,qBAAqBA,CAAEF,IAAI,EAAG;EACtC,OAAOA,IAAI,CAACC,OAAO,CAAE,gBAAgB,EAAE,IAAK,CAAC;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASE,eAAeA,CAAEH,IAAI,EAAG;EAChC,OAAOE,qBAAqB,CAAEH,qBAAqB,CAAEC,IAAK,CAAE,CAAC;AAC9D;AAEA,SACCD,qBAAqB,IAAIK,eAAe,EACxCF,qBAAqB,IAAIG,eAAe,EACxCF,eAAe,IAAIG,SAAS,EAC5BV,mBAAmB,EACnBD,mBAAmB;AAGpB,eAAe;EACdS,eAAe,EAAEL,qBAAqB;EACtCM,eAAe,EAAEH,qBAAqB;EACtCI,SAAS,EAAEH;AACZ,CAAC","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/removeEmailAddresses.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeEmailAddresses.js","names":["emailRegex","RegExp","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/removeEmailAddresses.js"],"sourcesContent":["const emailRegex = new RegExp( \"[^\\\\s@]+@[^\\\\s@]+\\\\.[^\\\\s@]+\", \"igm\" );\n\n/**\n * Removes email addresses from a text.\n *\n * @param {string} text The text to remove emails from.\n *\n * @returns {string} The text without email addresses.\n */\nexport default function( text ) {\n\treturn text.replace( emailRegex, \"\" );\n}\n"],"mappings":"AAAA,MAAMA,UAAU,GAAG,IAAIC,MAAM,CAAE,8BAA8B,EAAE,KAAM,CAAC;;AAEtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAEH,UAAU,EAAE,EAAG,CAAC;AACtC","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/removePunctuation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removePunctuation.js","names":["unifyNonBreakingSpace","punctuationRegexString","punctuationList","split","punctuationRegexStart","RegExp","punctuationRegexEnd","text","replace","backslashRegex"],"sources":["../../../../src/languageProcessing/helpers/sanitize/removePunctuation.js"],"sourcesContent":["import { unifyNonBreakingSpace } from \"./unifyWhitespace\";\n\n/**\n * String containing all the characters that we consider punctuation.\n * Characters that can also be used as control characters in regular expressions (like `-` and `(`) are escaped.\n * @type {string}\n */\nexport const punctuationRegexString = \"\\\\–\\\\-\\\\(\\\\)_\\\\[\\\\]’‘“”〝〞〟‟„\\\"'.?!:;,¿¡«»‹›\\u2014\\u00d7\\u002b\\u0026\\u06d4\\u061f\\u060C\\u061B\\u3002\\uff61\" +\n\"\\uff01\\u203c\\uff1f\\u2047\\u2049\\u2048\\u2025\\u2026\\u30fb\\u30fc\\u3001\\u3003\\u3004\\u3006\\u3007\\u3008\\u3009\\u300a\\u300b\\u300c\\u300d\\u300e\" +\n\"\\u300f\\u3010\\u3011\\u3012\\u3013\\u3014\\u3015\\u3016\\u3017\\u3018\\u3019\\u301a\\u301b\\u301c\\u301d\\u301e\\u301f\\u3020\\u3036\\u303c\\u303d\\uff5b\" +\n\"\\uff5d\\uff5c\\uff5e\\uff5f\\uff60\\uff62\\uff63\\uff64\\uff3b\\uff3d\\uff65\\uffe5\\uff04\\uff05\\uff20\\uff06\\uff07\\uff08\\uff09\\uff0a\\uff0f\\uff1a\" +\n\"\\uff1b\\uff1c\\uff1e\\uff3c\\\\<>\";\n\n/**\n * Array containing all the characters that we consider punctuation.\n * Characters that can also be used as control characters in regular expressions (like `-` and `(`) are escaped.\n * @type {string[]}\n */\nexport const punctuationList = punctuationRegexString.split( \"\" );\n\nexport const punctuationRegexStart = new RegExp( \"^[\" + punctuationRegexString + \"]+\" );\nexport const punctuationRegexEnd = new RegExp( \"[\" + punctuationRegexString +  \"]+$\" );\n\n/*\n * \\u2014 - em-dash\n * \\u00d7 - multiplication sign\n * \\u002b - plus sign\n * \\u0026 - ampersand\n * \\u06d4 - Urdu full stop\n * \\u061f - Arabic question mark\n * \\u060C - Arabic comma\n * \\u061B - Arabic semicolon\n */\n\n/**\n * Replaces punctuation characters from the given text string.\n *\n * @param {String} text The text to remove the punctuation characters for.\n *\n * @returns {String} The sanitized text.\n */\nexport default function( text ) {\n\t// Unify whitespaces and non-breaking spaces.\n\ttext = unifyNonBreakingSpace( text );\n\n\t// Remove &amp from the string. In some editors (a.o. Block and Elementor) the ampersand (&) is transformed into &amp.\n\t// If it is not removed, then it is returned as \"amp\" and counted as a word in assessments downstream.\n\ttext = text.replace( \"\\u0026amp\", \"\" );\n\n\t/*\n\t * Remove backslash from the beginning and end of a word/text.\n\t * When a string such as `This is a \\\"calico\\\" cat` enters the Paper,\n\t * the Paper adds two extra backslash in front of the original backslash.\n\t * After the text is split into words, we also need to remove those backslashes from the word.\n\t * Otherwise, it will be problematic when word boundary regex is added to the word.\n\t */\n\tconst backslashRegex = new RegExp( \"(\\\\\\\\)\", \"g\" );\n\n\ttext = text.replace( backslashRegex, \"\" );\n\ttext = text.replace( punctuationRegexStart, \"\" );\n\ttext = text.replace( punctuationRegexEnd, \"\" );\n\n\treturn text;\n}\n"],"mappings":"AAAA,SAASA,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAG,yGAAyG,GAC/I,sIAAsI,GACtI,sIAAsI,GACtI,sIAAsI,GACtI,8BAA8B;;AAE9B;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,eAAe,GAAGD,sBAAsB,CAACE,KAAK,CAAE,EAAG,CAAC;AAEjE,OAAO,MAAMC,qBAAqB,GAAG,IAAIC,MAAM,CAAE,IAAI,GAAGJ,sBAAsB,GAAG,IAAK,CAAC;AACvF,OAAO,MAAMK,mBAAmB,GAAG,IAAID,MAAM,CAAE,GAAG,GAAGJ,sBAAsB,GAAI,KAAM,CAAC;;AAEtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUM,IAAI,EAAG;EAC/B;EACAA,IAAI,GAAGP,qBAAqB,CAAEO,IAAK,CAAC;;EAEpC;EACA;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,WAAW,EAAE,EAAG,CAAC;;EAEtC;AACD;AACA;AACA;AACA;AACA;AACA;EACC,MAAMC,cAAc,GAAG,IAAIJ,MAAM,CAAE,QAAQ,EAAE,GAAI,CAAC;EAElDE,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEC,cAAc,EAAE,EAAG,CAAC;EACzCF,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEJ,qBAAqB,EAAE,EAAG,CAAC;EAChDG,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEF,mBAAmB,EAAE,EAAG,CAAC;EAE9C,OAAOC,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/removePunctuationExceptQuotes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removePunctuationExceptQuotes.js","names":["punctuationRegexString","punctuationRegexStart","RegExp","punctuationRegexEnd","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/removePunctuationExceptQuotes.js"],"sourcesContent":["// Replace all other punctuation characters at the beginning or at the end of a word.\nconst punctuationRegexString = \"[\\\\–\\\\-\\\\(\\\\)_\\\\[\\\\]’'.?!:;,¿¡«»‹›\\u2014\\u00d7\\u002b\\u0026<>]+\";\nconst punctuationRegexStart = new RegExp( \"^\" + punctuationRegexString );\nconst punctuationRegexEnd = new RegExp( punctuationRegexString + \"$\" );\n\n/**\n * Replaces punctuation characters at the beginning and end of a given text string.\n *\n * @param {String} text The text to remove the punctuation characters for.\n *\n * @returns {String} The sanitized text.\n */\nexport default function( text ) {\n\ttext = text.replace( punctuationRegexStart, \"\" );\n\ttext = text.replace( punctuationRegexEnd, \"\" );\n\n\treturn text;\n}\n"],"mappings":"AAAA;AACA,MAAMA,sBAAsB,GAAG,gEAAgE;AAC/F,MAAMC,qBAAqB,GAAG,IAAIC,MAAM,CAAE,GAAG,GAAGF,sBAAuB,CAAC;AACxE,MAAMG,mBAAmB,GAAG,IAAID,MAAM,CAAEF,sBAAsB,GAAG,GAAI,CAAC;;AAEtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUI,IAAI,EAAG;EAC/BA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEJ,qBAAqB,EAAE,EAAG,CAAC;EAChDG,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEF,mBAAmB,EAAE,EAAG,CAAC;EAE9C,OAAOC,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/removeSentenceTerminators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeSentenceTerminators.js","names":["sentenceTerminators","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/removeSentenceTerminators.js"],"sourcesContent":["// These are sentence terminators, that never should be in the middle of a word.\nconst sentenceTerminators = /[.?!:;,]/g;\n\n/**\n * Replaces sentence terminators from the text.\n *\n * @param {String} text The text to remove the terminators from.\n *\n * @returns {String} The sanitized text.\n */\nexport default function( text ) {\n\treturn text.replace( sentenceTerminators, \"\" );\n}\n"],"mappings":"AAAA;AACA,MAAMA,mBAAmB,GAAG,WAAW;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAEF,mBAAmB,EAAE,EAAG,CAAC;AAC/C","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/removeURLs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeURLs.js","names":["urlRegex","RegExp","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/removeURLs.js"],"sourcesContent":["const urlRegex = new RegExp( \"(ftp|http(s)?:\\\\/\\\\/.)(www\\\\\\\\.)?[-a-zA-Z0-9@:%._\\\\/+~#=]{2,256}\\\\.[a-z]{2,6}\\\\b([-a-zA-Z0-9@:;%_\\\\/+.~#?&()=]*)\" +\n\t\"|www\\\\.[-a-zA-Z0-9@:%._\\\\/+~#=]{2,256}\\\\.[a-z]{2,6}\\\\b([-a-zA-Z0-9@:;%_\\\\/+.~#?&()=]*)\", \"igm\" );\n/**\n * This regex is used to match URLs, whether they are embedded in tags or not.\n * It doesn't match domain names (e.g. \"yoast.com\" in \"We got so much traffic on yoast.com after the latest release\").\n *\n * @param {string} text The text to remove URLs from.\n *\n * @returns {string} The text without URLs.\n */\nexport default function( text ) {\n\treturn text.replace( urlRegex, \"\" );\n}\n"],"mappings":"AAAA,MAAMA,QAAQ,GAAG,IAAIC,MAAM,CAAE,kHAAkH,GAC9I,wFAAwF,EAAE,KAAM,CAAC;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAEH,QAAQ,EAAE,EAAG,CAAC;AACpC","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/sanitizeLineBreakTag.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeLineBreakTag.js","names":["text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/sanitizeLineBreakTag.js"],"sourcesContent":["/**\n * Replaces line break tag that contains an attribute with paragraph tag.\n * Line break tags with attribute aren't properly sanitized using wordpress `autop` function.\n *\n * @param {string} text The text to sanitize.\n *\n * @returns {string} The sanitized text.\n */\nexport default function( text ) {\n\treturn text.replace( /<br.*?>\\s*<.*?br.*?>/gm, \"</p><p>\" );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAE,wBAAwB,EAAE,SAAU,CAAC;AAC3D","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/sanitizeString.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeString.js","names":["stripFullTags","stripTags","unifyAllSpaces","text"],"sources":["../../../../src/languageProcessing/helpers/sanitize/sanitizeString.js"],"sourcesContent":["import { stripFullTags as stripTags } from \"./stripHTMLTags.js\";\nimport { unifyAllSpaces } from \"./unifyWhitespace\";\n\n/**\n * Sanitizes the text before we use the text for the analysis.\n *\n * @param {String} text The text to be sanitized.\n *\n * @returns {String} The sanitized text.\n */\nexport default function( text ) {\n\t// Unify whitespaces and non-breaking spaces.\n\ttext = unifyAllSpaces( text );\n\t// Strip the tags and multiple spaces.\n\ttext = stripTags( text );\n\n\treturn text;\n}\n"],"mappings":"AAAA,SAASA,aAAa,IAAIC,SAAS;AACnC,SAASC,cAAc;;AAEvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B;EACAA,IAAI,GAAGD,cAAc,CAAEC,IAAK,CAAC;EAC7B;EACAA,IAAI,GAAGF,SAAS,CAAEE,IAAK,CAAC;EAExB,OAAOA,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/stripHTMLTags.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stripHTMLTags.js","names":["stripSpaces","blockElements","blockElementStartRegex","RegExp","join","blockElementEndRegex","stripIncompleteTags","text","replace","stripBlockTagsAtStartEnd","stripFullTags"],"sources":["../../../../src/languageProcessing/helpers/sanitize/stripHTMLTags.js"],"sourcesContent":["/** @module stringProcessing/stripHTMLTags */\n\nimport stripSpaces from \"./stripSpaces.js\";\n\nimport { blockElements } from \"../html/html.js\";\n\nconst blockElementStartRegex = new RegExp( \"^<(\" + blockElements.join( \"|\" ) + \")[^>]*?>\", \"i\" );\nconst blockElementEndRegex = new RegExp( \"</(\" + blockElements.join( \"|\" ) + \")[^>]*?>$\", \"i\" );\n\n/**\n * Strip incomplete tags within a text. Strips an end tag at the beginning of a string and the start tag at the end of a\n * start of a string.\n *\n * @param {String} text The text to strip the HTML-tags from at the begin and end.\n * @returns {String} The text without HTML-tags at the begin and end.\n */\nconst stripIncompleteTags = function( text ) {\n\ttext = text.replace( /^(<\\/([^>]+)>)+/i, \"\" );\n\ttext = text.replace( /(<([^/>]+)>)+$/i, \"\" );\n\treturn text;\n};\n\n/**\n * Removes the block element tags at the beginning and end of a string and returns this string.\n *\n * @param {string} text The unformatted string.\n * @returns {string} The text with removed HTML begin and end block elements\n */\nconst stripBlockTagsAtStartEnd = function( text ) {\n\ttext = text.replace( blockElementStartRegex, \"\" );\n\ttext = text.replace( blockElementEndRegex, \"\" );\n\treturn text;\n};\n\n/**\n * Strip HTML-tags from text\n *\n * @param {String} text The text to strip the HTML-tags from.\n * @returns {String} The text without HTML-tags.\n */\nconst stripFullTags = function( text ) {\n\ttext = text.replace( /(<([^>]+)>)/ig, \" \" );\n\ttext = stripSpaces( text );\n\treturn text;\n};\n\nexport {\n\tstripFullTags,\n\tstripIncompleteTags,\n\tstripBlockTagsAtStartEnd,\n};\n\nexport default {\n\tstripFullTags: stripFullTags,\n\tstripIncompleteTags: stripIncompleteTags,\n\tstripBlockTagsAtStartEnd: stripBlockTagsAtStartEnd,\n};\n"],"mappings":"AAAA;;AAEA,OAAOA,WAAW;AAElB,SAASC,aAAa;AAEtB,MAAMC,sBAAsB,GAAG,IAAIC,MAAM,CAAE,KAAK,GAAGF,aAAa,CAACG,IAAI,CAAE,GAAI,CAAC,GAAG,UAAU,EAAE,GAAI,CAAC;AAChG,MAAMC,oBAAoB,GAAG,IAAIF,MAAM,CAAE,KAAK,GAAGF,aAAa,CAACG,IAAI,CAAE,GAAI,CAAC,GAAG,WAAW,EAAE,GAAI,CAAC;;AAE/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,mBAAmB,GAAG,SAAAA,CAAUC,IAAI,EAAG;EAC5CA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,kBAAkB,EAAE,EAAG,CAAC;EAC7CD,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,iBAAiB,EAAE,EAAG,CAAC;EAC5C,OAAOD,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,wBAAwB,GAAG,SAAAA,CAAUF,IAAI,EAAG;EACjDA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEN,sBAAsB,EAAE,EAAG,CAAC;EACjDK,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEH,oBAAoB,EAAE,EAAG,CAAC;EAC/C,OAAOE,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,aAAa,GAAG,SAAAA,CAAUH,IAAI,EAAG;EACtCA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,eAAe,EAAE,GAAI,CAAC;EAC3CD,IAAI,GAAGP,WAAW,CAAEO,IAAK,CAAC;EAC1B,OAAOA,IAAI;AACZ,CAAC;AAED,SACCG,aAAa,EACbJ,mBAAmB,EACnBG,wBAAwB;AAGzB,eAAe;EACdC,aAAa,EAAEA,aAAa;EAC5BJ,mBAAmB,EAAEA,mBAAmB;EACxCG,wBAAwB,EAAEA;AAC3B,CAAC","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/stripNonTextTags.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stripNonTextTags.js","names":["stripSpaces","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/stripNonTextTags.js"],"sourcesContent":["/** @module stringProcessing/stripNonTextTags */\n\nimport stripSpaces from \"./stripSpaces.js\";\n\n/**\n * Strips all tags from the text, except li, p, dd and h1-h6 tags from the text that contain content to check.\n *\n * @param {string} text The text to strip tags from\n * @returns {string} The text stripped of tags, except for li, p, dd and h1-h6 tags.\n */\nexport default function( text ) {\n\ttext = text.replace( /<(?!li|\\/li|p|\\/p|h1|\\/h1|h2|\\/h2|h3|\\/h3|h4|\\/h4|h5|\\/h5|h6|\\/h6|dd).*?>/g, \"\" );\n\ttext = stripSpaces( text );\n\treturn text;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,WAAW;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/BA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,4EAA4E,EAAE,EAAG,CAAC;EACvGD,IAAI,GAAGD,WAAW,CAAEC,IAAK,CAAC;EAC1B,OAAOA,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/stripNumbers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stripNumbers.js","names":["stripSpaces","text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/stripNumbers.js"],"sourcesContent":["/** @module stringProcessing/stripNumbers */\n\nimport stripSpaces from \"./stripSpaces.js\";\n\n/**\n * Removes all words comprised only of numbers.\n *\n * @param {string} text to remove words\n * @returns {string} The text with 'numberonly' words removed.\n */\nexport default function( text ) {\n\t// Remove \"words\" comprised only of numbers\n\ttext = text.replace( /\\b[0-9]+\\b/g, \"\" );\n\n\ttext = stripSpaces( text );\n\n\tif ( text === \".\" ) {\n\t\ttext = \"\";\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,WAAW;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,aAAa,EAAE,EAAG,CAAC;EAExCD,IAAI,GAAGD,WAAW,CAAEC,IAAK,CAAC;EAE1B,IAAKA,IAAI,KAAK,GAAG,EAAG;IACnBA,IAAI,GAAG,EAAE;EACV;EACA,OAAOA,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/stripSpaces.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stripSpaces.js","names":["text","replace"],"sources":["../../../../src/languageProcessing/helpers/sanitize/stripSpaces.js"],"sourcesContent":["/** @module stringProcessing/stripSpaces */\n\n/**\n * Replaces multiple spaces with a single space.\n * Removes spaces followed by a period (if there's no text after the period) and spaces in the beginning or end of a string.\n *\n * @param {String} text The text to strip spaces from.\n * @returns {String} The text with stripped spaces.\n */\nexport default function( text ) {\n\t// Replaces multiple spaces with a single space.\n\ttext = text.replace( /\\s{2,}/g, \" \" );\n\t// Replaces space(s) followed by a period, if the period is the last character, with only the period.\n\ttext = text.replace( /\\s\\.$/, \".\" );\n\t// Removes first/last character if it's a space.\n\ttext = text.replace( /^\\s+|\\s+$/g, \"\" );\n\t// Replaces spaces followed by a Japanese period with only the period.\n\ttext = text.replace( /\\s。/g, \"。\" );\n\t// Replaces spaces after a Japanese period with only the period.\n\ttext = text.replace( /。\\s/g, \"。\" );\n\n\treturn text;\n}\n"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAG;EAC/B;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,SAAS,EAAE,GAAI,CAAC;EACrC;EACAD,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,OAAO,EAAE,GAAI,CAAC;EACnC;EACAD,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,YAAY,EAAE,EAAG,CAAC;EACvC;EACAD,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,MAAM,EAAE,GAAI,CAAC;EAClC;EACAD,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAE,MAAM,EAAE,GAAI,CAAC;EAElC,OAAOD,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/stripWordBoundaries.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stripWordBoundaries.js","names":["wordBoundary","wordBoundaryStart","RegExp","wordBoundaryEnd","stripWordBoundariesStart","text","replace","stripWordBoundariesEnd","stripWordBoundariesEverywhere"],"sources":["../../../../src/languageProcessing/helpers/sanitize/stripWordBoundaries.js"],"sourcesContent":["/*\n * \\u00a0 - No-break space\n * \\u06d4 - Urdu full stop\n * \\u061f - Arabic question mark\n * \\u060C - Arabic comma\n * \\u061B - Arabic semicolon\n */\nconst wordBoundary = \"[ \\\\u00a0\\\\u06d4\\\\u061f\\\\u060C\\\\u061B \\\\n\\\\r\\\\t.,'()\\\"+\\\\-;!?:/»«‹›<>]\";\nconst wordBoundaryStart = new RegExp( \"^(\" + wordBoundary + \"+)\", \"ig\" );\nconst wordBoundaryEnd = new RegExp( \"(\" + wordBoundary + \"+$)\", \"ig\" );\n\n/**\n * Strip word boundary markers from text in the beginning\n *\n * @param {String} text The text to strip word boundary markers from.\n *\n * @returns {String} The text without double word boundary markers.\n */\nconst stripWordBoundariesStart = function( text ) {\n\t// Remove first character if word boundary\n\ttext = text.replace( wordBoundaryStart, \"\" );\n\n\treturn text;\n};\n\n/**\n * Strip word boundary markers from text in the end\n *\n * @param {String} text The text to strip word boundary markers from.\n *\n * @returns {String} The text without double word boundary markers.\n */\nconst stripWordBoundariesEnd = function( text ) {\n\t// Remove last character if word boundary\n\ttext = text.replace( wordBoundaryEnd, \"\" );\n\n\treturn text;\n};\n\n/**\n * Strip word boundary markers from text in the beginning and in the end\n *\n * @param {String} text The text to strip word boundary markers from.\n *\n * @returns {String} The text without word boundary markers.\n */\nconst stripWordBoundariesEverywhere = function( text ) {\n\t// Remove first/last character if word boundary\n\ttext = text.replace( wordBoundaryStart, \"\" );\n\ttext = text.replace( wordBoundaryEnd, \"\" );\n\n\treturn text;\n};\n\nexport {\n\tstripWordBoundariesStart,\n\tstripWordBoundariesEnd,\n\tstripWordBoundariesEverywhere,\n};\n\nexport default {\n\tstripWordBoundariesStart: stripWordBoundariesStart,\n\tstripWordBoundariesEnd: stripWordBoundariesEnd,\n\tstripWordBoundariesEverywhere: stripWordBoundariesEverywhere,\n};\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,YAAY,GAAG,wEAAwE;AAC7F,MAAMC,iBAAiB,GAAG,IAAIC,MAAM,CAAE,IAAI,GAAGF,YAAY,GAAG,IAAI,EAAE,IAAK,CAAC;AACxE,MAAMG,eAAe,GAAG,IAAID,MAAM,CAAE,GAAG,GAAGF,YAAY,GAAG,KAAK,EAAE,IAAK,CAAC;;AAEtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,wBAAwB,GAAG,SAAAA,CAAUC,IAAI,EAAG;EACjD;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEL,iBAAiB,EAAE,EAAG,CAAC;EAE5C,OAAOI,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,sBAAsB,GAAG,SAAAA,CAAUF,IAAI,EAAG;EAC/C;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEH,eAAe,EAAE,EAAG,CAAC;EAE1C,OAAOE,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,6BAA6B,GAAG,SAAAA,CAAUH,IAAI,EAAG;EACtD;EACAA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEL,iBAAiB,EAAE,EAAG,CAAC;EAC5CI,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAEH,eAAe,EAAE,EAAG,CAAC;EAE1C,OAAOE,IAAI;AACZ,CAAC;AAED,SACCD,wBAAwB,EACxBG,sBAAsB,EACtBC,6BAA6B;AAG9B,eAAe;EACdJ,wBAAwB,EAAEA,wBAAwB;EAClDG,sBAAsB,EAAEA,sBAAsB;EAC9CC,6BAA6B,EAAEA;AAChC,CAAC","ignoreList":[]}

package/build/languageProcessing/helpers/sanitize/unifyWhitespace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unifyWhitespace.js","names":["unifyNonBreakingSpace","text","replace","unifyEmDash","unifyWhiteSpace","unifyAllSpaces"],"sources":["../../../../src/languageProcessing/helpers/sanitize/unifyWhitespace.js"],"sourcesContent":["/** @module stringProcessing/unifyWhitespace */\n\n/**\n * Replaces a non-breaking space with a normal space.\n *\n * @param {string} text The string to replace the non-breaking space in.\n *\n * @returns {string} The text with unified spaces.\n */\nconst unifyNonBreakingSpace = function( text ) {\n\treturn text.replace( / /g, \" \" );\n};\n\n/**\n * Replaces an em dash with a normal space.\n *\n * @param {string} text The string to replace the em dash in.\n *\n * @returns {string} The text with unified spaces.\n */\nconst unifyEmDash = function( text ) {\n\treturn text.replace( /\\u2014/g, \" \" );\n};\n\n/**\n * Replaces all whitespace characters with a normal space.\n *\n * @param {string} text The string to replace the whitespace characters in.\n *\n * @returns {string} The text with unified spaces.\n */\nconst unifyWhiteSpace = function( text ) {\n\treturn text.replace( /\\s/g, \" \" );\n};\n\n/**\n * Converts all whitespace to spaces.\n *\n * @param {string} text The text to replace spaces.\n *\n * @returns {string} The text with unified spaces.\n */\nconst unifyAllSpaces = function( text ) {\n\ttext = unifyNonBreakingSpace( text );\n\ttext = unifyEmDash( text );\n\treturn unifyWhiteSpace( text );\n};\n\nexport {\n\tunifyNonBreakingSpace,\n\tunifyEmDash,\n\tunifyWhiteSpace,\n\tunifyAllSpaces,\n};\n\nexport default {\n\tunifyNonBreakingSpace: unifyNonBreakingSpace,\n\tunifyEmDash: unifyEmDash,\n\tunifyWhiteSpace: unifyWhiteSpace,\n\tunifyAllSpaces: unifyAllSpaces,\n};\n"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,qBAAqB,GAAG,SAAAA,CAAUC,IAAI,EAAG;EAC9C,OAAOA,IAAI,CAACC,OAAO,CAAE,SAAS,EAAE,GAAI,CAAC;AACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,WAAW,GAAG,SAAAA,CAAUF,IAAI,EAAG;EACpC,OAAOA,IAAI,CAACC,OAAO,CAAE,SAAS,EAAE,GAAI,CAAC;AACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,eAAe,GAAG,SAAAA,CAAUH,IAAI,EAAG;EACxC,OAAOA,IAAI,CAACC,OAAO,CAAE,KAAK,EAAE,GAAI,CAAC;AAClC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,cAAc,GAAG,SAAAA,CAAUJ,IAAI,EAAG;EACvCA,IAAI,GAAGD,qBAAqB,CAAEC,IAAK,CAAC;EACpCA,IAAI,GAAGE,WAAW,CAAEF,IAAK,CAAC;EAC1B,OAAOG,eAAe,CAAEH,IAAK,CAAC;AAC/B,CAAC;AAED,SACCD,qBAAqB,EACrBG,WAAW,EACXC,eAAe,EACfC,cAAc;AAGf,eAAe;EACdL,qBAAqB,EAAEA,qBAAqB;EAC5CG,WAAW,EAAEA,WAAW;EACxBC,eAAe,EAAEA,eAAe;EAChCC,cAAc,EAAEA;AACjB,CAAC","ignoreList":[]}