axyseo 2.1.11 → 2.1.13

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":[]}

package/build/languageProcessing/helpers/sentence/SentenceTokenizer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SentenceTokenizer.js","names":["isNaN","isUndefined","map","core","normalize","normalizeQuotes","abbreviations","createRegexFromArray","wordBoundaries","fullStop","fullStopRegex","RegExp","smallerThanContentRegex","htmlStartRegex","htmlEndRegex","blockStartRegex","blockEndRegex","abbreviationsPreparedForRegex","abbreviation","replace","abbreviationsRegex","wordBoundariesForRegex","boundary","join","lastCharacterPartOfInitialsRegex","tagTypeRegex","semanticTags","SentenceTokenizer","constructor","sentenceDelimiters","getSentenceDelimiters","isNumber","character","parseInt","isBreakTag","htmlTag","test","isQuotation","endsWithOrdinalDot","isPunctuation","removeDuplicateWhitespace","text","isCapitalLetter","toLocaleLowerCase","isSmallerThanSign","getNextTwoCharacters","nextTokens","next","src","isLetterFromSpecificLanguage","letter","ltrLetterRanges","some","ltrLetterRange","isValidSentenceBeginning","sentenceBeginning","isSentenceStart","token","type","isSentenceEnding","isPartOfPersonInitial","previousToken","nextToken","secondToNextToken","trim","length","tokenizeSmallerThanContent","tokenSentences","currentSentence","localText","substring","tokenizerResult","createTokenizer","tokenize","tokenizer","localSentences","getSentencesFromTokens","tokens","push","shift","lastSentence","pop","forEach","sentence","sentenceEndRegex","match","sentenceDelimiterRegex","sentenceRegex","addRule","onText","end","e","console","error","tokenizer2","endsWithAbbreviation","matchedAbbreviations","lastAbbreviation","endsWith","isValidTagPair","firstToken","lastToken","firstTokenText","lastTokenText","firstTagType","lastTagType","includes","tokenArray","trimSentences","nextSentenceStart","sliced","slice","i","hasNextSentence","nextCharacters","tokenizeResults","isCharacterASpace","getValidSentence"],"sources":["../../../../src/languageProcessing/helpers/sentence/SentenceTokenizer.js"],"sourcesContent":["import { isNaN, isUndefined, map } from \"lodash\";\n\nimport core from \"tokenizer2/core\";\n\nimport { normalize as normalizeQuotes } from \"../sanitize/quotes.js\";\n\nimport abbreviations from \"../../languages/en/config/abbreviations\";\n\nimport createRegexFromArray from \"../regex/createRegexFromArray\";\nimport wordBoundaries from \"../../../config/wordBoundaries\";\n\n// All characters that indicate a sentence delimiter.\nconst fullStop = \".\";\n\nconst fullStopRegex = new RegExp( \"^[\" + fullStop + \"]$\" );\nconst smallerThanContentRegex = /^<[^><]*$/;\nconst htmlStartRegex = /^<([^>\\s/]+)[^>]*>$/mi;\nconst htmlEndRegex = /^<\\/([^>\\s]+)[^>]*>$/mi;\n\nconst blockStartRegex = /^\\s*[[({]\\s*$/;\nconst blockEndRegex = /^\\s*[\\])}]\\s*$/;\n\nconst abbreviationsPreparedForRegex = abbreviations.map( ( abbreviation ) => abbreviation.replace( \".\", \"\\\\.\" ) );\nconst abbreviationsRegex = createRegexFromArray( abbreviationsPreparedForRegex );\n\nconst wordBoundariesForRegex = \"(^|$|[\" + wordBoundaries().map( ( boundary ) => \"\\\\\" + boundary ).join( \"\" ) + \"])\";\nconst lastCharacterPartOfInitialsRegex = new RegExp( wordBoundariesForRegex + \"[A-Za-z]$\" );\n\n// Constants to be used in isValidTagPair.\n// A regex to get the tag type.\nconst tagTypeRegex = /<\\/?([^\\s]+?)(\\s|>)/;\n// Semantic tags (as opposed to style tags) are tags that are used to structure the text.\nconst semanticTags = [ \"p\", \"div\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"span\", \"li\", \"main\" ];\n\n/**\n * Class for tokenizing a (html) text into sentences.\n */\nexport default class SentenceTokenizer {\n\t/**\n\t * Constructor\n\t * @constructor\n\t */\n\tconstructor() {\n\t\t/*\n         * \\u2026 - ellipsis.\n         * \\u06D4 - Urdu full stop.\n         * \\u061f - Arabic question mark.\n        */\n\t\tthis.sentenceDelimiters = \"”〞〟„』›»’‛`\\\"?!\\u2026\\u06d4\\u061f\";\n\t}\n\n\t/**\n\t * Gets the sentence delimiters.\n\t *\n\t * @returns {string} The sentence delimiters.\n\t */\n\tgetSentenceDelimiters() {\n\t\treturn this.sentenceDelimiters;\n\t}\n\n\t/**\n\t * Returns whether or not a certain character is a number.\n\t *\n\t * @param {string} character The character to check.\n\t * @returns {boolean} Whether or not the character is a capital letter.\n\t */\n\tisNumber( character ) {\n\t\treturn ! isNaN( parseInt( character, 10 ) );\n\t}\n\n\t/**\n\t * Returns whether or not a given HTML tag is a break tag.\n\t *\n\t * @param {string} htmlTag The HTML tag to check.\n\t * @returns {boolean} Whether or not the given HTML tag is a break tag.\n\t */\n\tisBreakTag( htmlTag ) {\n\t\treturn /<\\/?br/.test( htmlTag );\n\t}\n\n\t/**\n\t * Returns whether or not a given character is quotation mark.\n\t *\n\t * @param {string} character The character to check.\n\t * @returns {boolean} Whether or not the given character is a quotation mark.\n\t */\n\tisQuotation( character ) {\n\t\tcharacter = normalizeQuotes( character );\n\n\t\treturn \"'\" === character ||\n\t\t\t\"\\\"\" === character;\n\t}\n\n\t/**\n\t * A mock definition of this function. This function is only used in extensions for languages that use an ordinal dot.\n\t *\n\t * @returns {boolean} Always returns false as it is a language specific implementation if a language has an ordinal dot.\n\t */\n\tendsWithOrdinalDot() {\n\t\treturn false;\n\t}\n\n\t/**\n\t * Returns whether or not a given character is a punctuation mark that can be at the beginning\n\t * of a sentence, like ¿ and ¡ used in Spanish.\n\t *\n\t * @param {string} character The character to check.\n\t * @returns {boolean} Whether or not the given character is a punctuation mark.\n\t */\n\tisPunctuation( character ) {\n\t\treturn \"¿\" === character ||\n\t\t\t\"¡\" === character;\n\t}\n\n\t/**\n\t * Removes duplicate whitespace from a given text.\n\t *\n\t * @param {string} text The text with duplicate whitespace.\n\t * @returns {string} The text without duplicate whitespace.\n\t */\n\tremoveDuplicateWhitespace( text ) {\n\t\treturn text.replace( /\\s+/, \" \" );\n\t}\n\n\t/**\n\t * Returns whether or not a certain character is a capital letter.\n\t *\n\t * @param {string} character The character to check.\n\t * @returns {boolean} Whether or not the character is a capital letter.\n\t */\n\tisCapitalLetter( character ) {\n\t\treturn character !== character.toLocaleLowerCase();\n\t}\n\n\t/**\n\t * Checks whether the given character is a smaller than sign.\n\t *\n\t * This function is used to make sure that tokenizing the content after\n\t * the smaller than sign works as expected.\n\t * E.g. 'A sentence. < Hello world!' = ['A sentence.', '< Hello world!'].\n\t *\n\t * @param {string} character The character to check.\n\t * @returns {boolean} Whether the character is a smaller than sign ('<') or not.\n\t */\n\tisSmallerThanSign( character ) {\n\t\treturn character === \"<\";\n\t}\n\n\t/**\n\t * Retrieves the next two characters from an array with the two next tokens.\n\t *\n\t * @param {Array} nextTokens The two next tokens. Might be undefined.\n\t * @returns {string} The next two characters.\n\t */\n\tgetNextTwoCharacters( nextTokens ) {\n\t\tlet next = \"\";\n\n\t\tif ( ! isUndefined( nextTokens[ 0 ] ) ) {\n\t\t\tnext += nextTokens[ 0 ].src;\n\t\t}\n\n\t\tif ( ! isUndefined( nextTokens[ 1 ] ) ) {\n\t\t\tnext += nextTokens[ 1 ].src;\n\t\t}\n\n\t\tnext = this.removeDuplicateWhitespace( next );\n\n\t\treturn next;\n\t}\n\n\t/**\n\t * Checks whether a character is from a language that's written from right to left.\n\t * These languages don't have capital letter forms. Therefore any letter from these languages is a\n\t * potential sentence beginning.\n\t *\n\t * @param {string} letter The letter to check.\n\t *\n\t * @returns {boolean} Whether the letter is from an LTR language.\n\t */\n\tisLetterFromSpecificLanguage( letter ) {\n\t\tconst ltrLetterRanges = [\n\t\t\t// Hebrew characters.\n\t\t\t/^[\\u0590-\\u05fe]+$/i,\n\t\t\t// Arabic characters (used for Arabic, Farsi, Urdu).\n\t\t\t/^[\\u0600-\\u06FF]+$/i,\n\t\t\t// Additional Farsi characters.\n\t\t\t/^[\\uFB8A\\u067E\\u0686\\u06AF]+$/i,\n\t\t];\n\n\t\treturn (\n\t\t\tltrLetterRanges.some( ltrLetterRange => ltrLetterRange.test( letter ) )\n\t\t);\n\t}\n\n\t/**\n\t * Checks if the sentenceBeginning beginning is a valid beginning.\n\t *\n\t * @param {string} sentenceBeginning The beginning of the sentence to validate.\n\t * @returns {boolean} Returns true if it is a valid beginning, false if it is not.\n\t */\n\tisValidSentenceBeginning( sentenceBeginning ) {\n\t\treturn ( this.isCapitalLetter( sentenceBeginning ) ||\n\t\t\t\tthis.isLetterFromSpecificLanguage( sentenceBeginning ) ||\n\t\t\t\tthis.isNumber( sentenceBeginning ) ||\n\t\t\t\tthis.isQuotation( sentenceBeginning ) ||\n\t\t\t\tthis.isPunctuation( sentenceBeginning ) ||\n\t\t\t\tthis.isSmallerThanSign( sentenceBeginning ) );\n\t}\n\n\t/**\n\t * Checks if the token is a valid sentence start.\n\t *\n\t * @param {Object} token The token to validate.\n\t * @returns {boolean} Returns true if the token is valid sentence start, false if it is not.\n\t */\n\tisSentenceStart( token ) {\n\t\treturn ( ! isUndefined( token ) && (\n\t\t\t\"html-start\" === token.type ||\n\t\t\t\"html-end\" === token.type ||\n\t\t\t\"block-start\" === token.type\n\t\t) );\n\t}\n\n\t/**\n\t * Checks if the token is a valid sentence ending. A valid sentence ending is either a full stop or another\n\t * delimiter such as \"?\", \"!\", etc.\n\t *\n\t * @param {Object} token The token to validate.\n\t * @returns {boolean} Returns true if the token is valid sentence ending, false if it is not.\n\t */\n\tisSentenceEnding( token ) {\n\t\treturn (\n\t\t\t! isUndefined( token ) &&\n\t\t\t( token.type === \"full-stop\" || token.type === \"sentence-delimiter\" )\n\t\t);\n\t}\n\n\t/**\n\t * Checks if a full stop is part of a person's initials.\n\t *\n\t * Tests if tokens exist. Then tests if the tokens are of the right type.\n\t * For previous token, it checks if the sentence ends with a single letter.\n\t * For nextToken it checks if it is a single letter.\n\t * Checks if next token is followed by a full stop.\n\t *\n\t * @param {object} token The current token (must be a full stop).\n\t * @param {object} previousToken The token before the full stop.\n\t * @param {object} nextToken The token following the full stop.\n\t * @param {object} secondToNextToken The second token after the full stop.\n\t * @returns {boolean} True if a full stop is part of a person's initials, False if the full stop is not part of a person's initials.\n\t */\n\tisPartOfPersonInitial( token, previousToken, nextToken, secondToNextToken ) {\n\t\treturn ( ! isUndefined( token ) &&\n\t\t\t! isUndefined( nextToken ) &&\n\t\t\t! isUndefined( secondToNextToken ) &&\n\t\t\t! isUndefined( previousToken ) &&\n\t\t\ttoken.type === \"full-stop\" &&\n\t\t\tpreviousToken.type === \"sentence\" &&\n\t\t\tlastCharacterPartOfInitialsRegex.test( previousToken.src ) &&\n\t\t\tnextToken.type === \"sentence\" &&\n\t\t\tnextToken.src.trim().length === 1 &&\n\t\t\tsecondToNextToken.type === \"full-stop\"\n\t\t);\n\t}\n\n\t/**\n\t * Tokens that represent a '<', followed by content until it enters another '<' or '>'\n\t * gets another pass by the tokenizer.\n\t *\n\t * @param {Object} token A token of type 'smaller-than-sign-content'.\n\t * @param {string[]} tokenSentences The current array of found sentences. Sentences may get added by this method.\n\t * @param {string} currentSentence The current sentence. Sentence parts may get appended by this method.\n\t * @returns {{tokenSentences, currentSentence}} The found sentences and the current sentence, appended when necessary.\n\t */\n\ttokenizeSmallerThanContent( token, tokenSentences, currentSentence ) {\n\t\t/*\n\t\t\tRemove the '<' from the text, to avoid matching this rule\n\t\t\trecursively again and again.\n\t\t\tWe add it again later on.\n\t\t*/\n\t\tconst localText = token.src.substring( 1 );\n\n\t\t// Tokenize the current smaller-than-content token without the first '<'.\n\t\tconst tokenizerResult = this.createTokenizer();\n\t\tthis.tokenize( tokenizerResult.tokenizer, localText );\n\t\tconst localSentences = this.getSentencesFromTokens( tokenizerResult.tokens, false );\n\n\t\tlocalSentences[ 0 ] = isUndefined( localSentences[ 0 ] ) ? \"<\" : \"<\" + localSentences[ 0 ];\n\n\t\t/*\n\t\t * When the first sentence has a valid sentence beginning.\n\t\t * Add the currently build sentence to the sentences.\n\t\t * Start building the next sentence.\n\t\t */\n\t\tif ( this.isValidSentenceBeginning( localSentences[ 0 ] ) ) {\n\t\t\ttokenSentences.push( currentSentence );\n\t\t\tcurrentSentence = \"\";\n\t\t}\n\t\tcurrentSentence += localSentences[ 0 ];\n\n\t\tif ( localSentences.length > 1 ) {\n\t\t\t/*\n\t\t\t\tThere is a new sentence after the first,\n\t\t\t\tadd and reset the current sentence.\n\t\t\t */\n\t\t\ttokenSentences.push( currentSentence );\n\t\t\tcurrentSentence = \"\";\n\n\t\t\t// Remove the first sentence (we do not need to add it again).\n\t\t\tlocalSentences.shift();\n\t\t\t// Last sentence gets special treatment.\n\t\t\tconst lastSentence = localSentences.pop();\n\n\t\t\t// Add the remaining found sentences.\n\t\t\tlocalSentences.forEach( sentence => {\n\t\t\t\ttokenSentences.push( sentence );\n\t\t\t} );\n\n\t\t\tconst sentenceEndRegex = new RegExp( \"[\" + fullStop + this.getSentenceDelimiters() + \"]$\" );\n\n\t\t\t// Check if the last sentence has a valid sentence ending.\n\t\t\tif ( lastSentence.match( sentenceEndRegex ) ) {\n\t\t\t\t// If so, add it as a sentence.\n\t\t\t\ttokenSentences.push( lastSentence );\n\t\t\t} else {\n\t\t\t\t// If not, start making a new one.\n\t\t\t\tcurrentSentence = lastSentence;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\ttokenSentences,\n\t\t\tcurrentSentence,\n\t\t};\n\t}\n\n\t/**\n\t * Creates a tokenizer.\n\t *\n\t * @returns {Object} The tokenizer and the tokens.\n\t */\n\tcreateTokenizer() {\n\t\tconst sentenceDelimiterRegex = new RegExp( \"^[\" + this.getSentenceDelimiters() + \"]$\" );\n\t\tconst sentenceRegex = new RegExp( \"^[^\" + fullStop + this.getSentenceDelimiters() + \"<\\\\(\\\\)\\\\[\\\\]]+$\" );\n\n\t\tconst tokens = [];\n\t\tconst tokenizer = core( function( token ) {\n\t\t\ttokens.push( token );\n\t\t} );\n\n\t\ttokenizer.addRule( fullStopRegex, \"full-stop\" );\n\t\ttokenizer.addRule( smallerThanContentRegex, \"smaller-than-sign-content\" );\n\t\ttokenizer.addRule( htmlStartRegex, \"html-start\" );\n\t\ttokenizer.addRule( htmlEndRegex, \"html-end\" );\n\t\ttokenizer.addRule( blockStartRegex, \"block-start\" );\n\t\ttokenizer.addRule( blockEndRegex, \"block-end\" );\n\t\ttokenizer.addRule( sentenceDelimiterRegex, \"sentence-delimiter\" );\n\t\ttokenizer.addRule( sentenceRegex, \"sentence\" );\n\n\t\treturn {\n\t\t\ttokenizer,\n\t\t\ttokens,\n\t\t};\n\t}\n\n\t/**\n\t * Tokenizes the given text using the given tokenizer.\n\t *\n\t * @param {Object} tokenizer The tokenizer to use.\n\t * @param {string} text The text to tokenize.\n\t * @returns {void}\n\t */\n\ttokenize( tokenizer, text ) {\n\t\ttokenizer.onText( text );\n\n\t\ttry {\n\t\t\ttokenizer.end();\n\t\t} catch ( e ) {\n\t\t\tconsole.error( \"Tokenizer end error:\", e, e.tokenizer2 );\n\t\t}\n\t}\n\n\t/**\n\t * Checks if a string ends with an abbreviation.\n\t * @param {string} currentSentence A (part of) a sentence.\n\t * @returns {boolean} True if the string ends with an abbreviation that is in abbreviations.js. Otherwise, False.\n\t */\n\tendsWithAbbreviation( currentSentence ) {\n\t\tconst matchedAbbreviations = currentSentence.match( abbreviationsRegex );\n\n\t\tif ( ! matchedAbbreviations ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst lastAbbreviation = matchedAbbreviations.pop();\n\t\treturn currentSentence.endsWith( lastAbbreviation );\n\t}\n\n\t/**\n\t * Checks whether the given tokens are a valid html tag pair.\n\t * Note that this method is not a full html tag validator. It should be replaced with a better solution once the html parser is implemented.\n\t *\n\t * @param {object} firstToken   The first token to check. It is asserted that this token contains/is an opening html tag.\n\t * @param {object} lastToken    The last token to check. It is asserted that this token contains/is a closing html tag.\n\t *\n\t * @returns {boolean} True if the tokens are a valid html tag pair. Otherwise, False.\n\t */\n\tisValidTagPair( firstToken, lastToken ) {\n\t\tconst firstTokenText = firstToken.src;\n\t\tconst lastTokenText = lastToken.src;\n\n\t\t// Get the tag types.\n\t\tconst firstTagType = firstTokenText.match( tagTypeRegex )[ 1 ];\n\t\tconst lastTagType  = lastTokenText.match( tagTypeRegex )[ 1 ];\n\n\n\t\t// Check if the tags are the same and if they are a semantic tag (p, div, h1, h2, h3, h4, h5, h6, span).\n\t\treturn firstTagType === lastTagType && semanticTags.includes( firstTagType );\n\t}\n\n\t/**\n\t * Returns an array of sentences for a given array of tokens, assumes that the text has already been split into blocks.\n\t *\n\t * @param {Object[]} tokenArray The tokens from the sentence tokenizer.\n\t * @param {boolean} [trimSentences=true] Whether to trim the sentences at the end or not.\n\t *\n\t * @returns {string[]} A list of sentences.\n\t */\n\tgetSentencesFromTokens( tokenArray, trimSentences = true ) {\n\t\tlet tokenSentences = [], currentSentence = \"\", nextSentenceStart, sliced;\n\n\t\t// Drop the first and last HTML tag if both are present.\n\t\tdo {\n\t\t\tsliced = false;\n\t\t\tconst firstToken = tokenArray[ 0 ];\n\t\t\tconst lastToken = tokenArray[ tokenArray.length - 1 ];\n\n\t\t\tif ( firstToken && lastToken && firstToken.type === \"html-start\" &&\n\t\t\t\tlastToken.type === \"html-end\" && this.isValidTagPair( firstToken, lastToken ) ) {\n\t\t\t\ttokenArray = tokenArray.slice( 1, tokenArray.length - 1 );\n\n\t\t\t\tsliced = true;\n\t\t\t}\n\t\t} while ( sliced && tokenArray.length > 1 );\n\n\t\ttokenArray.forEach( ( token, i ) => {\n\t\t\tlet hasNextSentence, nextCharacters, tokenizeResults;\n\t\t\tconst nextToken = tokenArray[ i + 1 ];\n\t\t\tconst previousToken = tokenArray[ i - 1 ];\n\t\t\tconst secondToNextToken = tokenArray[ i + 2 ];\n\t\t\tnextCharacters = this.getNextTwoCharacters( [ nextToken, secondToNextToken ] );\n\n\t\t\t// For a new sentence we need to check the next two characters.\n\t\t\thasNextSentence = nextCharacters.length >= 2;\n\t\t\tnextSentenceStart = hasNextSentence ? nextCharacters[ 1 ] : \"\";\n\n\t\t\tswitch ( token.type ) {\n\t\t\t\tcase \"html-start\":\n\t\t\t\tcase \"html-end\":\n\t\t\t\t\tif ( this.isBreakTag( token.src ) ) {\n\t\t\t\t\t\ttokenSentences.push( currentSentence );\n\t\t\t\t\t\tcurrentSentence = \"\";\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentSentence += token.src;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"smaller-than-sign-content\":\n\t\t\t\t\ttokenizeResults = this.tokenizeSmallerThanContent( token, tokenSentences, currentSentence );\n\t\t\t\t\ttokenSentences = tokenizeResults.tokenSentences;\n\t\t\t\t\tcurrentSentence = tokenizeResults.currentSentence;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"sentence\":\n\t\t\t\t\tcurrentSentence += token.src;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"sentence-delimiter\":\n\t\t\t\t\tcurrentSentence += token.src;\n\n\t\t\t\t\t/*\n\t\t\t\t     * Only split text into sentences if:\n\t\t\t\t     * the next token is defined, AND\n\t\t\t\t     * the next token type is neither \"block-end\" nor \"sentence-delimiter\", AND\n\t\t\t\t     * the next token first character is a white space\n\t\t\t\t    */\n\t\t\t\t\tif ( ! isUndefined( nextToken ) &&\n\t\t\t\t\t\t\"block-end\" !== nextToken.type &&\n\t\t\t\t\t\t\"sentence-delimiter\" !== nextToken.type &&\n\t\t\t\t\t\tthis.isCharacterASpace( nextToken.src[ 0 ] ) ) {\n\t\t\t\t\t\t// Don't split on quotation marks unless they're preceded by a full stop.\n\t\t\t\t\t\tif ( this.isQuotation( token.src ) && previousToken && previousToken.src !== \".\" ) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t/*\n\t\t\t\t         * Only split on ellipsis or quotation marks when:\n\t\t\t\t\t     * a) There is a next sentence, and the next character is a valid sentence beginning preceded by a white space, OR\n\t\t\t\t\t     * b) The next token is a sentence start\n\t\t\t\t\t    */\n\t\t\t\t\t\tif ( this.isQuotation( token.src ) || token.src === \"…\" ) {\n\t\t\t\t\t\t\tcurrentSentence = this.getValidSentence( hasNextSentence,\n\t\t\t\t\t\t\t\tnextSentenceStart,\n\t\t\t\t\t\t\t\tnextCharacters,\n\t\t\t\t\t\t\t\tnextToken,\n\t\t\t\t\t\t\t\ttokenSentences,\n\t\t\t\t\t\t\t\tcurrentSentence );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\ttokenSentences.push( currentSentence );\n\t\t\t\t\t\t\tcurrentSentence = \"\";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"full-stop\":\n\t\t\t\t\tcurrentSentence += token.src;\n\t\t\t\t\tnextCharacters = this.getNextTwoCharacters( [ nextToken, secondToNextToken ] );\n\n\t\t\t\t\t// For a new sentence we need to check the next two characters.\n\t\t\t\t\thasNextSentence = nextCharacters.length >= 2;\n\t\t\t\t\tnextSentenceStart = hasNextSentence ? nextCharacters[ 1 ] : \"\";\n\n\t\t\t\t\t// If the current sentence ends with an abbreviation, the full stop does not split the sentence.\n\t\t\t\t\tif ( this.endsWithAbbreviation( currentSentence ) ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t// It should not split the text if the first character of the potential next sentence is a number.\n\t\t\t\t\tif ( hasNextSentence && this.isNumber( nextCharacters[ 0 ] ) ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t// If the full stop is part of a person's initials, don't split sentence.\n\t\t\t\t\tif ( this.isPartOfPersonInitial( token, previousToken, nextToken, secondToNextToken ) ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t// If the full stop is an ordinal dot (in German), then don't break the sentence.\n\t\t\t\t\t// This check should be done after  hasNextSentence && this.isNumber( nextCharacters[ 0 ] ) (above).\n\t\t\t\t\t// Because otherwise it could break before that test.\n\t\t\t\t\tif ( this.endsWithOrdinalDot( currentSentence ) ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t/*\n\t\t\t\t\t * Only split on full stop when:\n\t\t\t\t\t * a) There is a next sentence, and the next character is a valid sentence beginning preceded by a white space, OR\n\t\t\t\t\t * b) The next token is a sentence start\n\t\t\t\t\t */\n\t\t\t\t\tcurrentSentence = this.getValidSentence( hasNextSentence,\n\t\t\t\t\t\tnextSentenceStart,\n\t\t\t\t\t\tnextCharacters,\n\t\t\t\t\t\tnextToken,\n\t\t\t\t\t\ttokenSentences,\n\t\t\t\t\t\tcurrentSentence );\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"block-start\":\n\t\t\t\t\tcurrentSentence += token.src;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"block-end\":\n\t\t\t\t\tcurrentSentence += token.src;\n\n\t\t\t\t\tnextCharacters = this.getNextTwoCharacters( [ nextToken, secondToNextToken ] );\n\n\t\t\t\t\t// For a new sentence we need to check the next two characters.\n\t\t\t\t\thasNextSentence = nextCharacters.length >= 2;\n\t\t\t\t\tnextSentenceStart = hasNextSentence ? nextCharacters[ 0 ] : \"\";\n\n\t\t\t\t\t/* Don't split if:\n\t\t\t\t\t * - The next character is a number. For example: IPv4-numbers.\n\t\t\t\t\t * - The block end is preceded by a valid sentence ending, but not followed by a valid sentence beginning.\n\t\t\t\t\t */\n\t\t\t\t\tif (\n\t\t\t\t\t\thasNextSentence && this.isNumber( nextCharacters[ 0 ] ) ||\n\t\t\t\t\t\t( this.isSentenceEnding( previousToken ) &&\n\t\t\t\t\t\t\t( ! ( this.isValidSentenceBeginning( nextSentenceStart ) || this.isSentenceStart( nextToken ) ) ) )\n\t\t\t\t\t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t/*\n\t\t\t\t\t * Split if:\n\t\t\t\t\t * - The block end is preceded by a sentence ending and followed by a valid sentence beginning.\n\t\t\t\t\t */\n\t\t\t\t\tif (\n\t\t\t\t\t\tthis.isSentenceEnding( previousToken ) &&\n\t\t\t\t\t\t( this.isSentenceStart( nextToken ) || this.isValidSentenceBeginning( nextSentenceStart ) )\n\t\t\t\t\t) {\n\t\t\t\t\t\ttokenSentences.push( currentSentence );\n\t\t\t\t\t\tcurrentSentence = \"\";\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t} );\n\n\t\tif ( \"\" !== currentSentence ) {\n\t\t\ttokenSentences.push( currentSentence );\n\t\t}\n\n\t\tif ( trimSentences ) {\n\t\t\ttokenSentences = map( tokenSentences, function( sentence ) {\n\t\t\t\treturn sentence.trim();\n\t\t\t} );\n\t\t}\n\n\t\treturn tokenSentences;\n\t}\n\n\t/**\n\t * Gets the current sentence when:\n\t * a) There is a next sentence, and the next character is a valid sentence beginning preceded by a white space, OR\n\t * b) The next token is a sentence start\n\t *\n\t * @param {boolean} hasNextSentence     Whether the next characters are more than two.\n\t * @param {string} nextSentenceStart    The second character of the next characters.\n\t * @param {string} nextCharacters       The string values of the next two tokens.\n\t * @param {object} nextToken            The next token object.\n\t * @param {array} tokenSentences        The array of pushed valid sentences.\n\t * @param {string} currentSentence      The current sentence.\n\t *\n\t * @returns {string} The current sentence.\n\t */\n\tgetValidSentence( hasNextSentence, nextSentenceStart, nextCharacters, nextToken, tokenSentences, currentSentence ) {\n\t\tif ( ( hasNextSentence && this.isValidSentenceBeginning( nextSentenceStart ) && this.isCharacterASpace( nextCharacters[ 0 ] ) ) ||\n\t\t\tthis.isSentenceStart( nextToken ) ) {\n\t\t\ttokenSentences.push( currentSentence );\n\t\t\tcurrentSentence = \"\";\n\t\t}\n\t\treturn currentSentence;\n\t}\n\n\t/**\n\t * Checks if the character is a whitespace.\n\t *\n\t * @param {string} character    The character to check.\n\t * @returns {boolean}   Whether the character is a whitespace.\n\t */\n\tisCharacterASpace( character ) {\n\t\treturn /\\s/.test( character );\n\t}\n}\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/sentence/countSentences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"countSentences.js","names":["getSentences","text","memoizedTokenizer","sentences","sentenceCount","i","length"],"sources":["../../../../src/languageProcessing/helpers/sentence/countSentences.js"],"sourcesContent":["/** @module stringProcessing/countSentences */\n\nimport getSentences from \"./getSentences.js\";\n\n/**\n * Counts the number of sentences in a given string.\n *\n * @param {string}      text                The text used to count sentences.\n * @param {function}    memoizedTokenizer   The memoized sentence tokenizer.\n *\n * @returns {number} The number of sentences in the text.\n */\nexport default function( text, memoizedTokenizer ) {\n\tconst sentences = getSentences( text, memoizedTokenizer );\n\tlet sentenceCount = 0;\n\tfor ( let i = 0; i < sentences.length; i++ ) {\n\t\tsentenceCount++;\n\t}\n\treturn sentenceCount;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,YAAY;;AAEnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,iBAAiB,EAAG;EAClD,MAAMC,SAAS,GAAGH,YAAY,CAAEC,IAAI,EAAEC,iBAAkB,CAAC;EACzD,IAAIE,aAAa,GAAG,CAAC;EACrB,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,SAAS,CAACG,MAAM,EAAED,CAAC,EAAE,EAAG;IAC5CD,aAAa,EAAE;EAChB;EACA,OAAOA,aAAa;AACrB","ignoreList":[]}

package/build/languageProcessing/helpers/sentence/getSentences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getSentences.js","names":["filter","flatMap","isEmpty","negate","getBlocks","imageRegex","stripBlockTagsAtStartEnd","unifyNonBreakingSpace","defaultSentenceTokenizer","newLines","newLineRegex","RegExp","paragraphTagsRegex","text","memoizedTokenizer","replace","blocks","block","split","test","sentences","map","flat","sentence","trim"],"sources":["../../../../src/languageProcessing/helpers/sentence/getSentences.js"],"sourcesContent":["// Lodash imports.\nimport { filter, flatMap, isEmpty, negate } from \"lodash\";\n\n// Internal dependencies.\nimport { getBlocks } from \"../html/html.js\";\nimport { imageRegex } from \"../image/imageInText\";\nimport { stripBlockTagsAtStartEnd } from \"../sanitize/stripHTMLTags\";\nimport { unifyNonBreakingSpace } from \"../sanitize/unifyWhitespace\";\nimport defaultSentenceTokenizer from \"./memoizedSentenceTokenizer\";\n\n// Character classes.\nconst newLines = \"\\n\\r|\\n|\\r\";\n\n// Regular expressions.\nconst newLineRegex = new RegExp( newLines );\nconst paragraphTagsRegex = new RegExp( \"^(<p>|</p>)$\" );\n\n/**\n * Returns sentences in a string.\n *\n * @param {String}      text                The string to count sentences in.\n * @param {function}    memoizedTokenizer   The memoized sentence tokenizer.\n *\n * @returns {Array} Sentences found in the text.\n */\nexport default function( text, memoizedTokenizer = defaultSentenceTokenizer ) {\n\t// We don't remove the other HTML tags here since removing them might lead to incorrect results when running the sentence tokenizer.\n\t// Unify only non-breaking spaces and not the other whitespaces since a whitespace could signify a sentence break or a new line.\n\ttext = unifyNonBreakingSpace( text );\n\t/*\n\t * Remove images from text before tokenizing it into sentences.\n\t * This is necessary since the highlighting feature doesn't work if the yoastmark tags are enclosing a sentence starting with an image.\n\t * This step is done here so that applying highlight in captions is possible for all assessments that use this helper.\n\t */\n\ttext = text.replace( imageRegex, \"\" );\n\n\tlet blocks = getBlocks( text );\n\n\t// Split each block on newlines.\n\tblocks = flatMap( blocks, function( block ) {\n\t\treturn block.split( newLineRegex );\n\t} );\n\n\t/*\n\t * Filter blocks that contain only paragraph tags. This step is necessary\n\t * since switching between editors might add extra paragraph tags with a new line tag in the end\n\t * that are incorrectly converted into separate blocks.\n\t */\n\tblocks = blocks.filter( block => ! paragraphTagsRegex.test( block ) );\n\n\t/*\n\t * We use the `map` method followed by `flat` instead of `flatMap` because `flatMap` would override the second\n\t * argument of the memoizedTokenizer with the index of the iteratee.\n\t */\n\tlet sentences = blocks.map( block => memoizedTokenizer( block ) ).flat();\n\n\t/*\n\t * Strip block tags from the start and/or the end of each sentence and whitespaces if present.\n\t * After tokenized, sometimes there are still block tags present in the beginning/end of a sentence.\n\t * Unstripped, these tags could potentially break the highlighting functionality.\n\t */\n\tsentences = sentences.map( sentence => stripBlockTagsAtStartEnd( sentence ).trim() );\n\n\treturn filter( sentences, negate( isEmpty ) );\n}\n"],"mappings":"AAAA;AACA,SAASA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,MAAM,QAAQ,QAAQ;;AAEzD;AACA,SAASC,SAAS;AAClB,SAASC,UAAU;AACnB,SAASC,wBAAwB;AACjC,SAASC,qBAAqB;AAC9B,OAAOC,wBAAwB;;AAE/B;AACA,MAAMC,QAAQ,GAAG,YAAY;;AAE7B;AACA,MAAMC,YAAY,GAAG,IAAIC,MAAM,CAAEF,QAAS,CAAC;AAC3C,MAAMG,kBAAkB,GAAG,IAAID,MAAM,CAAE,cAAe,CAAC;;AAEvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUE,IAAI,EAAEC,iBAAiB,GAAGN,wBAAwB,EAAG;EAC7E;EACA;EACAK,IAAI,GAAGN,qBAAqB,CAAEM,IAAK,CAAC;EACpC;AACD;AACA;AACA;AACA;EACCA,IAAI,GAAGA,IAAI,CAACE,OAAO,CAAEV,UAAU,EAAE,EAAG,CAAC;EAErC,IAAIW,MAAM,GAAGZ,SAAS,CAAES,IAAK,CAAC;;EAE9B;EACAG,MAAM,GAAGf,OAAO,CAAEe,MAAM,EAAE,UAAUC,KAAK,EAAG;IAC3C,OAAOA,KAAK,CAACC,KAAK,CAAER,YAAa,CAAC;EACnC,CAAE,CAAC;;EAEH;AACD;AACA;AACA;AACA;EACCM,MAAM,GAAGA,MAAM,CAAChB,MAAM,CAAEiB,KAAK,IAAI,CAAEL,kBAAkB,CAACO,IAAI,CAAEF,KAAM,CAAE,CAAC;;EAErE;AACD;AACA;AACA;EACC,IAAIG,SAAS,GAAGJ,MAAM,CAACK,GAAG,CAAEJ,KAAK,IAAIH,iBAAiB,CAAEG,KAAM,CAAE,CAAC,CAACK,IAAI,CAAC,CAAC;;EAExE;AACD;AACA;AACA;AACA;EACCF,SAAS,GAAGA,SAAS,CAACC,GAAG,CAAEE,QAAQ,IAAIjB,wBAAwB,CAAEiB,QAAS,CAAC,CAACC,IAAI,CAAC,CAAE,CAAC;EAEpF,OAAOxB,MAAM,CAAEoB,SAAS,EAAEjB,MAAM,CAAED,OAAQ,CAAE,CAAC;AAC9C","ignoreList":[]}

package/build/languageProcessing/helpers/sentence/getSentencesFromTree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getSentencesFromTree.js","names":["getStartOffset","node","sourceCodeLocation","startTag","endOffset","startOffset","getParentNode","paper","getTree","findAll","treeNode","childNodes","includes","tree","sentences","flatMap","map","sentence","parentNode","isImplicit","parentStartOffset","parentClientId","clientId","parentAttributeId","attributeId","isParentFirstSectionOfBlock","isFirstSection"],"sources":["../../../../src/languageProcessing/helpers/sentence/getSentencesFromTree.js"],"sourcesContent":["/**\n * Retrieves the start offset for a given node.\n * @param {Node} node The current node.\n * @returns {number} The start offset.\n */\nfunction getStartOffset( node ) {\n\treturn node.sourceCodeLocation &&\n\t\t( ( node.sourceCodeLocation.startTag && node.sourceCodeLocation.startTag.endOffset ) || node.sourceCodeLocation.startOffset ) || 0;\n}\n\n/**\n * Retrieves the parent node for a given node.\n * @param {Paper} \tpaper \tThe current paper.\n * @param {Node} \tnode \tThe current node.\n * @returns {Node} The parent node.\n */\nexport function getParentNode( paper, node ) {\n\t// Includes a fallback so that if a parent node cannot be found for an implicit paragraph, we use the current node as the parent node.\n\treturn paper.getTree().findAll( treeNode => treeNode.childNodes && treeNode.childNodes.includes( node ) )[ 0 ] || node;\n}\n\n/**\n * Gets all the sentences from paragraph and heading nodes.\n * These two node types are the nodes that should contain sentences for the analysis.\n *\n * @param {Paper} paper The paper to get the sentences from.\n *\n * @returns {Sentence[]} The array of sentences retrieved from paragraph and heading nodes plus sourceCodeLocation of the parent node.\n */\nexport default function( paper ) {\n\t// Get all nodes that have a sentence property which is not an empty array.\n\tconst tree = paper.getTree().findAll( treeNode => !! treeNode.sentences );\n\n\treturn tree.flatMap( node => node.sentences.map( sentence => {\n\t\tlet parentNode = node;\n\n\t\t// For implicit paragraphs, base the details on the parent of this node.\n\t\tif ( node.isImplicit ) {\n\t\t\tparentNode = getParentNode( paper, node );\n\t\t}\n\n\t\treturn {\n\t\t\t...sentence,\n\t\t\t// The parent node's start offset is the start offset of the parent node if it doesn't have a `startTag` property.\n\t\t\tparentStartOffset: getStartOffset( parentNode ),\n\t\t\t// The block client id of the parent node.\n\t\t\tparentClientId: parentNode.clientId || \"\",\n\t\t\t// The attribute id of the parent node, if available, otherwise an empty string.\n\t\t\t// Only used for position-based highlighting in sub-blocks of Yoast blocks.\n\t\t\tparentAttributeId: node.attributeId || \"\",\n\t\t\t// Whether the parent node is the first section of Yoast sub-blocks. Only used for position-based highlighting.\n\t\t\tisParentFirstSectionOfBlock: node.isFirstSection || false,\n\t\t};\n\t} ) );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,SAASA,cAAcA,CAAEC,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,kBAAkB,KACzBD,IAAI,CAACC,kBAAkB,CAACC,QAAQ,IAAIF,IAAI,CAACC,kBAAkB,CAACC,QAAQ,CAACC,SAAS,IAAMH,IAAI,CAACC,kBAAkB,CAACG,WAAW,CAAE,IAAI,CAAC;AACpI;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAAEC,KAAK,EAAEN,IAAI,EAAG;EAC5C;EACA,OAAOM,KAAK,CAACC,OAAO,CAAC,CAAC,CAACC,OAAO,CAAEC,QAAQ,IAAIA,QAAQ,CAACC,UAAU,IAAID,QAAQ,CAACC,UAAU,CAACC,QAAQ,CAAEX,IAAK,CAAE,CAAC,CAAE,CAAC,CAAE,IAAIA,IAAI;AACvH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUM,KAAK,EAAG;EAChC;EACA,MAAMM,IAAI,GAAGN,KAAK,CAACC,OAAO,CAAC,CAAC,CAACC,OAAO,CAAEC,QAAQ,IAAI,CAAC,CAAEA,QAAQ,CAACI,SAAU,CAAC;EAEzE,OAAOD,IAAI,CAACE,OAAO,CAAEd,IAAI,IAAIA,IAAI,CAACa,SAAS,CAACE,GAAG,CAAEC,QAAQ,IAAI;IAC5D,IAAIC,UAAU,GAAGjB,IAAI;;IAErB;IACA,IAAKA,IAAI,CAACkB,UAAU,EAAG;MACtBD,UAAU,GAAGZ,aAAa,CAAEC,KAAK,EAAEN,IAAK,CAAC;IAC1C;IAEA,OAAO;MACN,GAAGgB,QAAQ;MACX;MACAG,iBAAiB,EAAEpB,cAAc,CAAEkB,UAAW,CAAC;MAC/C;MACAG,cAAc,EAAEH,UAAU,CAACI,QAAQ,IAAI,EAAE;MACzC;MACA;MACAC,iBAAiB,EAAEtB,IAAI,CAACuB,WAAW,IAAI,EAAE;MACzC;MACAC,2BAA2B,EAAExB,IAAI,CAACyB,cAAc,IAAI;IACrD,CAAC;EACF,CAAE,CAAE,CAAC;AACN","ignoreList":[]}

package/build/languageProcessing/helpers/sentence/memoizedSentenceTokenizer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoizedSentenceTokenizer.js","names":["SentenceTokenizer","memoize","getSentenceTokenizer","text","trimSentences","sentenceTokenizer","tokenizer","tokens","createTokenizer","tokenize","length","getSentencesFromTokens","args","JSON","stringify"],"sources":["../../../../src/languageProcessing/helpers/sentence/memoizedSentenceTokenizer.js"],"sourcesContent":["import SentenceTokenizer from \"./SentenceTokenizer\";\nimport { memoize } from \"lodash\";\n\n/**\n * Returns the sentences from a certain text.\n *\n * @param {string} text \t\t\t\t\tThe text to retrieve sentences from.\n * @param {boolean} [trimSentences=true] \tWhether to trim whitespace from the beginning and end of the sentences or not.\n *\n * @returns {Array<string>} The list of sentences in the text.\n */\nfunction getSentenceTokenizer( text, trimSentences = true ) {\n\tconst sentenceTokenizer = new SentenceTokenizer();\n\tconst { tokenizer, tokens } = sentenceTokenizer.createTokenizer();\n\tsentenceTokenizer.tokenize( tokenizer, text );\n\n\treturn ( tokens.length === 0 ? [] : sentenceTokenizer.getSentencesFromTokens( tokens, trimSentences ) );\n}\n\n/*\n * The second argument to the memoize function is a so-called resolver function.\n * It creates a cache key consisting of a combination of all arguments to a function.\n * This is needed because by default, only the first argument to a function is used as the map cache key by the memoize function.\n * This means that a function is only re-run if the value of the first argument changes.\n * We want to re-run the getSentenceTokenizer function also when only the second argument changes to prevent cache collisions.\n * @see https://lodash.com/docs/4.17.15#memoize\n */\nexport default memoize( getSentenceTokenizer, ( ...args ) => JSON.stringify( args ) );\n"],"mappings":"AAAA,OAAOA,iBAAiB;AACxB,SAASC,OAAO,QAAQ,QAAQ;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,oBAAoBA,CAAEC,IAAI,EAAEC,aAAa,GAAG,IAAI,EAAG;EAC3D,MAAMC,iBAAiB,GAAG,IAAIL,iBAAiB,CAAC,CAAC;EACjD,MAAM;IAAEM,SAAS;IAAEC;EAAO,CAAC,GAAGF,iBAAiB,CAACG,eAAe,CAAC,CAAC;EACjEH,iBAAiB,CAACI,QAAQ,CAAEH,SAAS,EAAEH,IAAK,CAAC;EAE7C,OAASI,MAAM,CAACG,MAAM,KAAK,CAAC,GAAG,EAAE,GAAGL,iBAAiB,CAACM,sBAAsB,CAAEJ,MAAM,EAAEH,aAAc,CAAC;AACtG;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAeH,OAAO,CAAEC,oBAAoB,EAAE,CAAE,GAAGU,IAAI,KAAMC,IAAI,CAACC,SAAS,CAAEF,IAAK,CAAE,CAAC","ignoreList":[]}

package/build/languageProcessing/helpers/sentence/sentencesLength.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sentencesLength.js","names":["wordCount","forEach","stripFullTags","stripHTMLTags","sentences","researcher","sentencesWordCount","sentence","strippedSentence","countCharacters","getHelper","length","push","sentenceLength"],"sources":["../../../../src/languageProcessing/helpers/sentence/sentencesLength.js"],"sourcesContent":["import wordCount from \"../word/countWords.js\";\nimport { forEach } from \"lodash\";\nimport { stripFullTags as stripHTMLTags } from \"../sanitize/stripHTMLTags.js\";\n\n/**\n * Returns an array with the length of each sentence.\n *\n * @param {Array} sentences Array with sentences from text.\n * @param {Researcher} \tresearcher \tThe researcher to use for analysis.\n *\n * @returns {Array} Array with the length of each sentence.\n */\nexport default function( sentences, researcher ) {\n\tconst sentencesWordCount = [];\n\tforEach( sentences, function( sentence ) {\n\t\t// For counting words we want to omit the HTMLtags.\n\t\tconst strippedSentence = stripHTMLTags( sentence );\n\t\t// A helper to count characters for languages that don't count number of words for text length.\n\t\tconst countCharacters = researcher.getHelper( \"customCountLength\" );\n\t\tconst length = countCharacters ? countCharacters( strippedSentence ) : wordCount( strippedSentence );\n\t\tif ( length <= 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tsentencesWordCount.push( {\n\t\t\tsentence: sentence,\n\t\t\tsentenceLength: length,\n\t\t} );\n\t} );\n\treturn sentencesWordCount;\n}\n"],"mappings":"AAAA,OAAOA,SAAS;AAChB,SAASC,OAAO,QAAQ,QAAQ;AAChC,SAASC,aAAa,IAAIC,aAAa;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,SAAS,EAAEC,UAAU,EAAG;EAChD,MAAMC,kBAAkB,GAAG,EAAE;EAC7BL,OAAO,CAAEG,SAAS,EAAE,UAAUG,QAAQ,EAAG;IACxC;IACA,MAAMC,gBAAgB,GAAGL,aAAa,CAAEI,QAAS,CAAC;IAClD;IACA,MAAME,eAAe,GAAGJ,UAAU,CAACK,SAAS,CAAE,mBAAoB,CAAC;IACnE,MAAMC,MAAM,GAAGF,eAAe,GAAGA,eAAe,CAAED,gBAAiB,CAAC,GAAGR,SAAS,CAAEQ,gBAAiB,CAAC;IACpG,IAAKG,MAAM,IAAI,CAAC,EAAG;MAClB;IACD;IAEAL,kBAAkB,CAACM,IAAI,CAAE;MACxBL,QAAQ,EAAEA,QAAQ;MAClBM,cAAc,EAAEF;IACjB,CAAE,CAAC;EACJ,CAAE,CAAC;EACH,OAAOL,kBAAkB;AAC1B","ignoreList":[]}

package/build/languageProcessing/helpers/syllables/DeviationFragment.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviationFragment.js","names":["isUndefined","pick","DeviationFragment","constructor","options","_location","location","_fragment","word","_syllables","syllables","_regex","_options","createRegex","fragment","notFollowedBy","join","alsoFollowedBy","regexString","RegExp","getRegex","occursIn","regex","test","removeFrom","replace","getSyllables"],"sources":["../../../../src/languageProcessing/helpers/syllables/DeviationFragment.js"],"sourcesContent":["import { isUndefined, pick } from \"lodash\";\n\n/**\n * A DeviationFragment represents a partial deviation when counting syllables.\n */\nexport default class DeviationFragment {\n\t/**\n\t * Constructs a new DeviationFragment.\n\t *\n\t * @param {Object} options Extra options that are used to match this deviation fragment.\n\t * @param {string} options.location The location in the word where this deviation can occur.\n\t * @param {string} options.word The actual string that should be counted differently.\n\t * @param {number} options.syllables The amount of syllables this fragment has.\n\t * @param {string[]} [options.notFollowedBy] A list of characters that this fragment shouldn't be followed with.\n\t * @param {string[]} [options.alsoFollowedBy] A list of characters that this fragment could be followed with.\n\t *\n\t * @constructor\n\t */\n\tconstructor( options ) {\n\t\tthis._location = options.location;\n\t\tthis._fragment = options.word;\n\t\tthis._syllables = options.syllables;\n\t\tthis._regex = null;\n\n\t\tthis._options = pick( options, [ \"notFollowedBy\", \"alsoFollowedBy\" ] );\n\t}\n\n\t/**\n\t * Creates a regex that matches this fragment inside a word.\n\t *\n\t * @returns {void}\n\t */\n\tcreateRegex() {\n\t\tconst options = this._options;\n\n\t\tlet fragment = this._fragment;\n\n\t\tif ( ! isUndefined( options.notFollowedBy ) ) {\n\t\t\tfragment += \"(?![\" + options.notFollowedBy.join( \"\" ) + \"])\";\n\t\t}\n\n\t\tif ( ! isUndefined( options.alsoFollowedBy ) ) {\n\t\t\tfragment += \"[\" + options.alsoFollowedBy.join( \"\" ) + \"]?\";\n\t\t}\n\n\t\tlet regexString;\n\t\tswitch ( this._location ) {\n\t\t\tcase \"atBeginning\":\n\t\t\t\tregexString = \"^\" + fragment;\n\t\t\t\tbreak;\n\n\t\t\tcase \"atEnd\":\n\t\t\t\tregexString = fragment + \"$\";\n\t\t\t\tbreak;\n\n\t\t\tcase \"atBeginningOrEnd\":\n\t\t\t\tregexString = \"(^\" + fragment + \")|(\" + fragment + \"$)\";\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tregexString = fragment;\n\t\t\t\tbreak;\n\t\t}\n\n\t\tthis._regex = new RegExp( regexString );\n\t}\n\n\t/**\n\t * Returns the regex that matches this fragment inside a word.\n\t *\n\t * @returns {RegExp} The regex that matches this fragment.\n\t */\n\tgetRegex() {\n\t\tif ( null === this._regex ) {\n\t\t\tthis.createRegex();\n\t\t}\n\n\t\treturn this._regex;\n\t}\n\n\t/**\n\t * Returns whether this fragment occurs in a word.\n\t *\n\t * @param {string} word The word to match the fragment in.\n\t * @returns {boolean} Whether or not this fragment occurs in a word.\n\t */\n\toccursIn( word ) {\n\t\tconst regex = this.getRegex();\n\n\t\treturn regex.test( word );\n\t}\n\n\t/**\n\t * Removes this fragment from the given word.\n\t *\n\t * @param {string} word The word to remove this fragment from.\n\t * @returns {string} The modified word.\n\t */\n\tremoveFrom( word ) {\n\t\t// Replace by a space to keep the remaining parts separated.\n\t\treturn word.replace( this._fragment, \" \" );\n\t}\n\n\t/**\n\t * Returns the amount of syllables for this fragment.\n\t *\n\t * @returns {number} The amount of syllables for this fragment.\n\t */\n\tgetSyllables() {\n\t\treturn this._syllables;\n\t}\n}\n"],"mappings":"AAAA,SAASA,WAAW,EAAEC,IAAI,QAAQ,QAAQ;;AAE1C;AACA;AACA;AACA,eAAe,MAAMC,iBAAiB,CAAC;EACtC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACCC,WAAWA,CAAEC,OAAO,EAAG;IACtB,IAAI,CAACC,SAAS,GAAGD,OAAO,CAACE,QAAQ;IACjC,IAAI,CAACC,SAAS,GAAGH,OAAO,CAACI,IAAI;IAC7B,IAAI,CAACC,UAAU,GAAGL,OAAO,CAACM,SAAS;IACnC,IAAI,CAACC,MAAM,GAAG,IAAI;IAElB,IAAI,CAACC,QAAQ,GAAGX,IAAI,CAAEG,OAAO,EAAE,CAAE,eAAe,EAAE,gBAAgB,CAAG,CAAC;EACvE;;EAEA;AACD;AACA;AACA;AACA;EACCS,WAAWA,CAAA,EAAG;IACb,MAAMT,OAAO,GAAG,IAAI,CAACQ,QAAQ;IAE7B,IAAIE,QAAQ,GAAG,IAAI,CAACP,SAAS;IAE7B,IAAK,CAAEP,WAAW,CAAEI,OAAO,CAACW,aAAc,CAAC,EAAG;MAC7CD,QAAQ,IAAI,MAAM,GAAGV,OAAO,CAACW,aAAa,CAACC,IAAI,CAAE,EAAG,CAAC,GAAG,IAAI;IAC7D;IAEA,IAAK,CAAEhB,WAAW,CAAEI,OAAO,CAACa,cAAe,CAAC,EAAG;MAC9CH,QAAQ,IAAI,GAAG,GAAGV,OAAO,CAACa,cAAc,CAACD,IAAI,CAAE,EAAG,CAAC,GAAG,IAAI;IAC3D;IAEA,IAAIE,WAAW;IACf,QAAS,IAAI,CAACb,SAAS;MACtB,KAAK,aAAa;QACjBa,WAAW,GAAG,GAAG,GAAGJ,QAAQ;QAC5B;MAED,KAAK,OAAO;QACXI,WAAW,GAAGJ,QAAQ,GAAG,GAAG;QAC5B;MAED,KAAK,kBAAkB;QACtBI,WAAW,GAAG,IAAI,GAAGJ,QAAQ,GAAG,KAAK,GAAGA,QAAQ,GAAG,IAAI;QACvD;MAED;QACCI,WAAW,GAAGJ,QAAQ;QACtB;IACF;IAEA,IAAI,CAACH,MAAM,GAAG,IAAIQ,MAAM,CAAED,WAAY,CAAC;EACxC;;EAEA;AACD;AACA;AACA;AACA;EACCE,QAAQA,CAAA,EAAG;IACV,IAAK,IAAI,KAAK,IAAI,CAACT,MAAM,EAAG;MAC3B,IAAI,CAACE,WAAW,CAAC,CAAC;IACnB;IAEA,OAAO,IAAI,CAACF,MAAM;EACnB;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCU,QAAQA,CAAEb,IAAI,EAAG;IAChB,MAAMc,KAAK,GAAG,IAAI,CAACF,QAAQ,CAAC,CAAC;IAE7B,OAAOE,KAAK,CAACC,IAAI,CAAEf,IAAK,CAAC;EAC1B;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCgB,UAAUA,CAAEhB,IAAI,EAAG;IAClB;IACA,OAAOA,IAAI,CAACiB,OAAO,CAAE,IAAI,CAAClB,SAAS,EAAE,GAAI,CAAC;EAC3C;;EAEA;AACD;AACA;AACA;AACA;EACCmB,YAAYA,CAAA,EAAG;IACd,OAAO,IAAI,CAACjB,UAAU;EACvB;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/syllables/countSyllables.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"countSyllables.js","names":["getWords","filter","find","flatMap","forEach","isUndefined","map","memoize","sum","SyllableCountIterator","DeviationFragment","countVowelGroups","word","syllables","numberOfSyllables","vowelRegex","RegExp","vowels","foundVowels","split","filteredWords","vowel","length","countVowelDeviations","syllableCountIterator","countSyllables","countFullWordDeviations","fullWordDeviations","deviations","words","full","deviation","fullWordDeviation","createDeviationFragments","syllableConfig","deviationFragments","fragments","fragmentLocation","fragment","location","createDeviationFragmentsMemoized","countPartialWordDeviations","remainingParts","syllableCount","deviationFragment","occursIn","removeFrom","getSyllables","countUsingVowels","countSyllablesInWord","fullWordExclusion","partialExclusions","countSyllablesInText","text","toLocaleLowerCase","syllableCounts"],"sources":["../../../../src/languageProcessing/helpers/syllables/countSyllables.js"],"sourcesContent":["/** @module stringProcessing/countSyllables */\n\nimport getWords from \"../word/getWords.js\";\n\nimport { filter, find, flatMap, forEach, isUndefined, map, memoize, sum } from \"lodash\";\n\nimport SyllableCountIterator from \"./syllableCountIterator.js\";\nimport DeviationFragment from \"./DeviationFragment\";\n\n/**\n * Counts vowel groups inside a word.\n *\n * @param {string} word         A text with words to count syllables.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {number} the syllable count.\n */\nconst countVowelGroups = function( word, syllables ) {\n\tlet numberOfSyllables = 0;\n\tconst vowelRegex = new RegExp( \"[^\" + syllables.vowels + \"]\", \"ig\" );\n\tconst foundVowels = word.split( vowelRegex );\n\tconst filteredWords = filter( foundVowels, function( vowel ) {\n\t\treturn vowel !== \"\";\n\t} );\n\tnumberOfSyllables += filteredWords.length;\n\n\treturn numberOfSyllables;\n};\n\n/**\n * Counts the syllables using vowel exclusions. These are used for groups of vowels that are more or less\n * than 1 syllable.\n *\n * @param {String} word         The word to count syllables of.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {number} The number of syllables found in the given word.\n */\nconst countVowelDeviations = function( word, syllables ) {\n\tconst syllableCountIterator = new SyllableCountIterator( syllables );\n\treturn syllableCountIterator.countSyllables( word );\n};\n\n/**\n * Returns the number of syllables for the word if it is in the list of full word deviations.\n *\n * @param {String} word         The word to retrieve the syllables for.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {number} The number of syllables found.\n */\nconst countFullWordDeviations = function( word, syllables ) {\n\tconst fullWordDeviations = syllables.deviations.words.full;\n\n\tconst deviation = find( fullWordDeviations, function( fullWordDeviation ) {\n\t\treturn fullWordDeviation.word === word;\n\t} );\n\n\tif ( ! isUndefined( deviation ) ) {\n\t\treturn deviation.syllables;\n\t}\n\n\treturn 0;\n};\n\n/**\n * Creates an array of deviation fragments for a certain locale.\n *\n * @param {Object} syllableConfig Syllable config for a certain locale.\n * @returns {DeviationFragment[]} A list of deviation fragments\n */\nfunction createDeviationFragments( syllableConfig ) {\n\tlet deviationFragments = [];\n\n\tconst deviations = syllableConfig.deviations;\n\n\tdeviationFragments = flatMap( deviations.words.fragments, function( fragments, fragmentLocation ) {\n\t\treturn map( fragments, function( fragment ) {\n\t\t\tfragment.location = fragmentLocation;\n\n\t\t\treturn new DeviationFragment( fragment );\n\t\t} );\n\t} );\n\n\treturn deviationFragments;\n}\n\nconst createDeviationFragmentsMemoized = memoize( createDeviationFragments );\n\n/**\n * Counts syllables in partial exclusions. If these are found, returns the number of syllables found, and the modified word.\n * The word is modified so the excluded part isn't counted by the normal syllable counter.\n *\n * @param {String} word \t\tThe word to count syllables of.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {object} The number of syllables found and the modified word.\n */\nconst countPartialWordDeviations = function( word, syllables ) {\n\tconst deviationFragments = createDeviationFragmentsMemoized( syllables );\n\tlet remainingParts = word;\n\tlet syllableCount = 0;\n\n\tforEach( deviationFragments, function( deviationFragment ) {\n\t\tif ( deviationFragment.occursIn( remainingParts ) ) {\n\t\t\tremainingParts = deviationFragment.removeFrom( remainingParts );\n\t\t\tsyllableCount += deviationFragment.getSyllables();\n\t\t}\n\t} );\n\n\treturn { word: remainingParts, syllableCount: syllableCount };\n};\n\n/**\n * Count the number of syllables in a word, using vowels and exceptions.\n *\n * @param {String} word         The word to count the number of syllables of.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {number} The number of syllables found in a word.\n */\nconst countUsingVowels = function( word, syllables ) {\n\tlet syllableCount = 0;\n\n\tsyllableCount += countVowelGroups( word, syllables );\n\tif ( ! isUndefined( syllables.deviations ) && ! isUndefined( syllables.deviations.vowels ) ) {\n\t\tsyllableCount += countVowelDeviations( word, syllables );\n\t}\n\treturn syllableCount;\n};\n\n/**\n * Counts the number of syllables in a word.\n *\n * @param {string} word         The word to count syllables of.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {number} The syllable count for the word.\n */\nexport const countSyllablesInWord = function( word, syllables ) {\n\tlet syllableCount = 0;\n\n\tif ( ! isUndefined( syllables.deviations ) && ! isUndefined( syllables.deviations.words ) ) {\n\t\tif ( ! isUndefined( syllables.deviations.words.full ) ) {\n\t\t\tconst fullWordExclusion = countFullWordDeviations( word, syllables );\n\t\t\tif ( fullWordExclusion !== 0 ) {\n\t\t\t\treturn fullWordExclusion;\n\t\t\t}\n\t\t}\n\n\t\tif ( ! isUndefined( syllables.deviations.words.fragments ) ) {\n\t\t\tconst partialExclusions = countPartialWordDeviations( word, syllables );\n\t\t\tword = partialExclusions.word;\n\t\t\tsyllableCount += partialExclusions.syllableCount;\n\t\t}\n\t}\n\tsyllableCount += countUsingVowels( word, syllables );\n\n\treturn syllableCount;\n};\n\n/**\n * Counts the number of syllables in a text per word based on vowels.\n * Uses exclusion words for words that cannot be matched with vowel matching.\n *\n * @param {String} text         The text to count the syllables of.\n * @param {Object} syllables    The syllables data for the specific language.\n *\n * @returns {int} The total number of syllables found in the text.\n */\nconst countSyllablesInText = function( text, syllables ) {\n\ttext = text.toLocaleLowerCase();\n\tconst words = getWords( text );\n\n\tconst syllableCounts = map( words,  function( word ) {\n\t\treturn countSyllablesInWord( word, syllables );\n\t} );\n\n\treturn sum( syllableCounts );\n};\n\nexport default countSyllablesInText;\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/syllables/syllableCountIterator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syllableCountIterator.js","names":["SyllableCountStep","forEach","isUndefined","SyllableCountIterator","constructor","config","countSteps","createSyllableCountSteps","deviations","vowels","syllableCounts","syllableCountStep","push","bind","getAvailableSyllableCountSteps","countSyllables","word","syllableCount","step"],"sources":["../../../../src/languageProcessing/helpers/syllables/syllableCountIterator.js"],"sourcesContent":["import SyllableCountStep from \"./syllableCountStep.js\";\n\nimport { forEach, isUndefined } from \"lodash\";\n\n/**\n * A SyllableCountIterator contains individual SyllableCountSteps.\n */\nexport default class SyllableCountIterator {\n\t/**\n\t * Creates a syllable count iterator.\n\t *\n\t * @param {object} config The config object containing an array with syllable exclusions.\n\t * @constructor\n\t */\n\tconstructor( config ) {\n\t\tthis.countSteps = [];\n\t\tif ( ! isUndefined( config ) ) {\n\t\t\tthis.createSyllableCountSteps( config.deviations.vowels );\n\t\t}\n\t}\n\n\t/**\n\t * Creates a syllable count step object for each exclusion.\n\t *\n\t * @param {object} syllableCounts The object containing all exclusion syllables including the multipliers.\n\t * @returns {void}\n\t */\n\tcreateSyllableCountSteps( syllableCounts ) {\n\t\tforEach( syllableCounts, function( syllableCountStep ) {\n\t\t\tthis.countSteps.push( new SyllableCountStep( syllableCountStep ) );\n\t\t}.bind( this ) );\n\t}\n\n\t/**\n\t * Returns all available count steps.\n\t *\n\t * @returns {Array} All available count steps.\n\t */\n\tgetAvailableSyllableCountSteps() {\n\t\treturn this.countSteps;\n\t}\n\n\t/**\n\t * Counts the syllables for all the steps and returns the total syllable count.\n\t *\n\t * @param {String} word The word to count syllables in.\n\t * @returns {number} The number of syllables found based on exclusions.\n\t */\n\tcountSyllables( word ) {\n\t\tlet syllableCount = 0;\n\t\tforEach( this.countSteps, function( step ) {\n\t\t\tsyllableCount += step.countSyllables( word );\n\t\t} );\n\t\treturn syllableCount;\n\t}\n}\n"],"mappings":"AAAA,OAAOA,iBAAiB;AAExB,SAASC,OAAO,EAAEC,WAAW,QAAQ,QAAQ;;AAE7C;AACA;AACA;AACA,eAAe,MAAMC,qBAAqB,CAAC;EAC1C;AACD;AACA;AACA;AACA;AACA;EACCC,WAAWA,CAAEC,MAAM,EAAG;IACrB,IAAI,CAACC,UAAU,GAAG,EAAE;IACpB,IAAK,CAAEJ,WAAW,CAAEG,MAAO,CAAC,EAAG;MAC9B,IAAI,CAACE,wBAAwB,CAAEF,MAAM,CAACG,UAAU,CAACC,MAAO,CAAC;IAC1D;EACD;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCF,wBAAwBA,CAAEG,cAAc,EAAG;IAC1CT,OAAO,CAAES,cAAc,EAAE,UAAUC,iBAAiB,EAAG;MACtD,IAAI,CAACL,UAAU,CAACM,IAAI,CAAE,IAAIZ,iBAAiB,CAAEW,iBAAkB,CAAE,CAAC;IACnE,CAAC,CAACE,IAAI,CAAE,IAAK,CAAE,CAAC;EACjB;;EAEA;AACD;AACA;AACA;AACA;EACCC,8BAA8BA,CAAA,EAAG;IAChC,OAAO,IAAI,CAACR,UAAU;EACvB;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCS,cAAcA,CAAEC,IAAI,EAAG;IACtB,IAAIC,aAAa,GAAG,CAAC;IACrBhB,OAAO,CAAE,IAAI,CAACK,UAAU,EAAE,UAAUY,IAAI,EAAG;MAC1CD,aAAa,IAAIC,IAAI,CAACH,cAAc,CAAEC,IAAK,CAAC;IAC7C,CAAE,CAAC;IACH,OAAOC,aAAa;EACrB;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/syllables/syllableCountStep.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syllableCountStep.js","names":["isUndefined","arrayToRegex","SyllableCountStep","constructor","syllableRegex","_hasRegex","_regex","_multiplier","createRegex","hasRegex","fragments","countModifier","getRegex","countSyllables","word","match","length"],"sources":["../../../../src/languageProcessing/helpers/syllables/syllableCountStep.js"],"sourcesContent":["import { isUndefined } from \"lodash\";\n\nimport arrayToRegex from \"../regex/createRegexFromArray.js\";\n\n/**\n * A SyllableCountStep is an individual step in a SyllableCountIterator.\n */\nexport default class SyllableCountStep {\n\t/**\n\t * Constructs a language syllable regex that contains a regex for matching syllable exclusion.\n\t *\n\t * @param {object} syllableRegex The object containing the syllable exclusions.\n\t * @constructor\n\t */\n\tconstructor( syllableRegex ) {\n\t\tthis._hasRegex = false;\n\t\tthis._regex = \"\";\n\t\tthis._multiplier = \"\";\n\t\tthis.createRegex( syllableRegex );\n\t}\n\n\t/**\n\t * Checks whether a valid regex has been set.\n\t *\n\t * @returns {boolean} True if a regex has been set, false if not.\n\t */\n\thasRegex() {\n\t\treturn this._hasRegex;\n\t}\n\n\t/**\n\t * Creates a regex based on the given syllable exclusions, and sets the multiplier to use.\n\t *\n\t * @param {object} syllableRegex The object containing the syllable exclusions and multiplier.\n\t * @returns {void}\n\t */\n\tcreateRegex( syllableRegex ) {\n\t\tif ( ! isUndefined( syllableRegex ) && ! isUndefined( syllableRegex.fragments ) ) {\n\t\t\tthis._hasRegex = true;\n\t\t\tthis._regex = arrayToRegex( syllableRegex.fragments, true );\n\t\t\tthis._multiplier = syllableRegex.countModifier;\n\t\t}\n\t}\n\n\t/**\n\t * Returns the stored regular expression.\n\t *\n\t * @returns {RegExp} The stored regular expression.\n\t */\n\tgetRegex() {\n\t\treturn this._regex;\n\t}\n\n\t/**\n\t * Matches syllable exclusions in a given word and returns the number found multiplied by the\n\t * given multiplier. The result of this multiplication is the syllable count.\n\t *\n\t * @param {String} word The word to match for syllable exclusions.\n\t * @returns {number} The amount of syllables found.\n\t */\n\tcountSyllables( word ) {\n\t\tif ( this._hasRegex ) {\n\t\t\tconst match = word.match( this._regex ) || [];\n\t\t\treturn match.length * this._multiplier;\n\t\t}\n\t\treturn 0;\n\t}\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,QAAQ;AAEpC,OAAOC,YAAY;;AAEnB;AACA;AACA;AACA,eAAe,MAAMC,iBAAiB,CAAC;EACtC;AACD;AACA;AACA;AACA;AACA;EACCC,WAAWA,CAAEC,aAAa,EAAG;IAC5B,IAAI,CAACC,SAAS,GAAG,KAAK;IACtB,IAAI,CAACC,MAAM,GAAG,EAAE;IAChB,IAAI,CAACC,WAAW,GAAG,EAAE;IACrB,IAAI,CAACC,WAAW,CAAEJ,aAAc,CAAC;EAClC;;EAEA;AACD;AACA;AACA;AACA;EACCK,QAAQA,CAAA,EAAG;IACV,OAAO,IAAI,CAACJ,SAAS;EACtB;;EAEA;AACD;AACA;AACA;AACA;AACA;EACCG,WAAWA,CAAEJ,aAAa,EAAG;IAC5B,IAAK,CAAEJ,WAAW,CAAEI,aAAc,CAAC,IAAI,CAAEJ,WAAW,CAAEI,aAAa,CAACM,SAAU,CAAC,EAAG;MACjF,IAAI,CAACL,SAAS,GAAG,IAAI;MACrB,IAAI,CAACC,MAAM,GAAGL,YAAY,CAAEG,aAAa,CAACM,SAAS,EAAE,IAAK,CAAC;MAC3D,IAAI,CAACH,WAAW,GAAGH,aAAa,CAACO,aAAa;IAC/C;EACD;;EAEA;AACD;AACA;AACA;AACA;EACCC,QAAQA,CAAA,EAAG;IACV,OAAO,IAAI,CAACN,MAAM;EACnB;;EAEA;AACD;AACA;AACA;AACA;AACA;AACA;EACCO,cAAcA,CAAEC,IAAI,EAAG;IACtB,IAAK,IAAI,CAACT,SAAS,EAAG;MACrB,MAAMU,KAAK,GAAGD,IAAI,CAACC,KAAK,CAAE,IAAI,CAACT,MAAO,CAAC,IAAI,EAAE;MAC7C,OAAOS,KAAK,CAACC,MAAM,GAAG,IAAI,CAACT,WAAW;IACvC;IACA,OAAO,CAAC;EACT;AACD","ignoreList":[]}

package/build/languageProcessing/helpers/transform/transformWordsWithHyphens.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformWordsWithHyphens.js","names":["array","newArray","forEach","element","split","length","filter","unit","includes","concat"],"sources":["../../../../src/languageProcessing/helpers/transform/transformWordsWithHyphens.js"],"sourcesContent":["/**\n * Splits words from an array that contain hyphens and adds the elements to the array if they are not yet there.\n *\n * @param {Array} array The array to check and modify.\n *\n * @returns {Array} A new array with the elements containing hyphens split.\n */\nexport default function( array ) {\n\tlet newArray = array;\n\tarray.forEach( element => {\n\t\telement = element.split( \"-\" );\n\t\tif ( element.length > 0 && element.filter( unit => ! array.includes( unit ) ).length > 0 ) {\n\t\t\tnewArray = newArray.concat( element );\n\t\t}\n\t} );\n\treturn newArray;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,KAAK,EAAG;EAChC,IAAIC,QAAQ,GAAGD,KAAK;EACpBA,KAAK,CAACE,OAAO,CAAEC,OAAO,IAAI;IACzBA,OAAO,GAAGA,OAAO,CAACC,KAAK,CAAE,GAAI,CAAC;IAC9B,IAAKD,OAAO,CAACE,MAAM,GAAG,CAAC,IAAIF,OAAO,CAACG,MAAM,CAAEC,IAAI,IAAI,CAAEP,KAAK,CAACQ,QAAQ,CAAED,IAAK,CAAE,CAAC,CAACF,MAAM,GAAG,CAAC,EAAG;MAC1FJ,QAAQ,GAAGA,QAAQ,CAACQ,MAAM,CAAEN,OAAQ,CAAC;IACtC;EACD,CAAE,CAAC;EACH,OAAOF,QAAQ;AAChB","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/replaceDiacritics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replaceDiacritics.js","names":["diacriticsRemovalMap","text","map","i","length","replace","letters","base"],"sources":["../../../../src/languageProcessing/helpers/transliterate/replaceDiacritics.js"],"sourcesContent":["/** @module stringProcessing/replaceDiacritics */\n\nimport diacriticsRemovalMap from \"../../../config/diacritics.js\";\n\n/**\n * Replaces all diacritics from the text based on the diacritics removal map.\n *\n * @param {string} text The text to remove diacritics from.\n *\n * @returns {string} The text with all diacritics replaced.\n */\nexport default function( text ) {\n\tconst map = diacriticsRemovalMap();\n\n\tfor ( let i = 0; i < map.length; i++ ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letters,\n\t\t\tmap[ i ].base\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,oBAAoB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,MAAMC,GAAG,GAAGF,oBAAoB,CAAC,CAAC;EAElC,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,GAAG,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IACtCF,IAAI,GAAGA,IAAI,CAACI,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,OAAO,EAChBJ,GAAG,CAAEC,CAAC,CAAE,CAACI,IACV,CAAC;EACF;EACA,OAAON,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/specialCharacterMappings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"specialCharacterMappings.js","names":["filter","includes","isEqual","memoize","getWords","getIndicesOfWords","text","indices","words","startSearchFrom","forEach","word","currentIndex","indexOf","push","length","getIndicesOfCharacter","characterToFind","i","arraysDifference","bigArray","subarray","element","arraysOverlap","firstArray","secondArray","combinations","collection","acc","xs","array","x","l","concat","slice","replaceCharactersByIndex","substitute","modifiedTextSplitByLetter","split","index","splice","join","replaceTurkishIs","indicesOfAllIs","sort","indicesOfIsInWordBeginnings","results","combinationsDottedI","oneCombinationDottedI","indicesNotDottedI","combinationsDotlessI","oneCombinationDotlessI","indicesSmalli","combinationsDottedi","oneCombinationDottedi","oneCombinationDotlessi","textAlternations","result","toDottedI","toDotlessI","toDottedi","toDotlessi","replaceTurkishIsMemoized"],"sources":["../../../../src/languageProcessing/helpers/transliterate/specialCharacterMappings.js"],"sourcesContent":["import { filter, includes, isEqual, memoize } from \"lodash\";\nimport getWords from \"../word/getWords\";\n\n/**\n * Gets positions of the first character of a word in the input text.\n *\n * @param {string} text The original text, for which the indices of word beginnings need to be determined.\n *\n * @returns {Array} indices The array of indices in the text at which words start.\n */\nfunction getIndicesOfWords( text ) {\n\tconst indices = [];\n\tconst words = getWords( text );\n\tlet startSearchFrom = 0;\n\n\twords.forEach( function( word ) {\n\t\tconst currentIndex = text.indexOf( word, startSearchFrom );\n\t\tindices.push( currentIndex );\n\t\tstartSearchFrom = currentIndex + word.length;\n\t} );\n\n\treturn indices;\n}\n\n\n/**\n * Gets indices of a specific character in the input text.\n *\n * @param {string} text             The original text, for which the indices of specific characters have to be determined.\n * @param {string} characterToFind  The character that needs to be found in the text.\n *\n * @returns {Array} indices The array of indices in the text at which the characterToFind occurs.\n */\nfunction getIndicesOfCharacter( text, characterToFind ) {\n\tconst indices = [];\n\n\tif ( text.indexOf( characterToFind ) > -1 ) {\n\t\tfor ( let i = 0; i < text.length; i++ ) {\n\t\t\tif ( text[ i ] === characterToFind ) {\n\t\t\t\tindices.push( i );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn indices;\n}\n\n/**\n * Compares two arrays of which the second array is the sub-array of the first array.\n * Returns the array of elements of the first array which are not in the second array.\n *\n * @param {Array} bigArray The array with all elements.\n * @param {Array} subarray The array with some elements from the bigArray.\n *\n * @returns {Array} difference An array of all elements of bigArray which are not in subarray.\n */\nfunction arraysDifference( bigArray, subarray ) {\n\treturn filter( bigArray, function( element ) {\n\t\treturn ( ! includes( subarray, element ) );\n\t} );\n}\n\n/**\n * Compares two arrays and returns the array of elements that occur in both arrays.\n *\n * @param {Array} firstArray    The first array with elements to compare.\n * @param {Array} secondArray   The second array with elements to compare.\n *\n * @returns {Array} overlap An array of all elements of firstArray which are also in secondArray.\n */\nfunction arraysOverlap( firstArray, secondArray ) {\n\treturn filter( firstArray, function( element ) {\n\t\treturn ( includes( secondArray, element ) );\n\t} );\n}\n\n\n/**\n * Generates all possible combinations of the elements of an array (treated as unique).\n * https://gist.github.com/jpillora/4435759\n *\n * @param {Array} collection The array with elements that should be combined.\n *\n * @returns {Array} result An array of all possible combinations of elements of the original array.\n */\nfunction combinations( collection ) {\n\t/**\n\t * A recursive function that iterates through all elements of an array to produce its combinations.\n\t *\n\t * @param {Array} xs        The array to start accumulating with.\n\t * @param {Array} array     The array with elements that should be combined.\n\t *\n\t * @returns {Array} result An array of all possible combinations of elements of the original array.\n\t */\n\tfunction acc( xs, array ) {\n\t\tconst x = xs[ 0 ];\n\n\t\tif ( typeof x === \"undefined\" ) {\n\t\t\treturn array;\n\t\t}\n\n\t\tfor ( let i = 0, l = array.length; i < l; ++i ) {\n\t\t\tarray.push( array[ i ].concat( x ) );\n\t\t}\n\t\treturn acc( xs.slice( 1 ), array );\n\t}\n\treturn acc( collection, [ [ ] ] ).slice( 1 ).concat( [ [] ] );\n}\n\n\n/**\n * Replaces characters on specified indices in the input text.\n *\n * @param {string} text         The original text, for which the characters have to be substituted.\n * @param {Array} indices       The array of indices that have to be substituted.\n * @param {string} substitute   The character that is used to substitute in the text.\n *\n * @returns {string} result The string of the original text with the characters on specified indices are substituted with the substitute character.\n */\nfunction replaceCharactersByIndex( text, indices, substitute ) {\n\tconst modifiedTextSplitByLetter = text.split( \"\" );\n\n\tindices.forEach( function( index ) {\n\t\tmodifiedTextSplitByLetter.splice( index, 1, substitute );\n\t} );\n\n\treturn modifiedTextSplitByLetter.join( \"\" );\n}\n\n/**\n * Generates upper and lower case for Turkish strings that contain characters İ or ı, which appear to not be processed correctly by regexes.\n *\n * @param {string} text The text to build possible upper and lower case alternatives.\n *\n * @returns {Array} An array of strings that contains all possible upper and lower case alternatives of the original string\n */\nfunction replaceTurkishIs( text ) {\n\t// Get indices of all occurrences of İ, I, i, or ı.\n\tconst indicesOfAllIs = getIndicesOfCharacter( text, \"İ\" ).concat(\n\t\tgetIndicesOfCharacter( text, \"I\" ),\n\t\tgetIndicesOfCharacter( text, \"i\" ),\n\t\tgetIndicesOfCharacter( text, \"ı\" )\n\t);\n\tindicesOfAllIs.sort();\n\n\t// If there are no Is return the text\n\tif ( indicesOfAllIs.length === 0 ) {\n\t\treturn [ text ];\n\t}\n\tconst indicesOfIsInWordBeginnings = arraysOverlap( getIndicesOfWords( text ), indicesOfAllIs );\n\n\tconst results = [];\n\n\t// First round of creating combinations: assign which indices will be replaced by İ\n\tconst combinationsDottedI = combinations( indicesOfIsInWordBeginnings );\n\n\tcombinationsDottedI.forEach( function( oneCombinationDottedI ) {\n\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\tif ( isEqual( oneCombinationDottedI, indicesOfIsInWordBeginnings ) ) {\n\t\t\tresults.push( [ oneCombinationDottedI, [], [], [] ] );\n\t\t} else {\n\t\t\tconst indicesNotDottedI = arraysDifference( indicesOfIsInWordBeginnings, oneCombinationDottedI );\n\n\t\t\t// Second round of creating combinations: assign which indices will be replaced by I\n\t\t\tconst combinationsDotlessI = combinations( indicesNotDottedI );\n\t\t\tcombinationsDotlessI.forEach( function( oneCombinationDotlessI ) {\n\t\t\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\t\t\tif ( isEqual( oneCombinationDotlessI, indicesNotDottedI ) ) {\n\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, [], [] ] );\n\t\t\t\t} else {\n\t\t\t\t\tconst indicesSmalli = arraysDifference( indicesNotDottedI, oneCombinationDotlessI );\n\n\t\t\t\t\t// Third round of creating combinations: assign which indices will be replaced by i\n\t\t\t\t\tconst combinationsDottedi = combinations( indicesSmalli );\n\n\t\t\t\t\tcombinationsDottedi.forEach( function( oneCombinationDottedi ) {\n\t\t\t\t\t\t// If the combination is full array, just add it to results immediately without going through the rest of iterations.\n\t\t\t\t\t\tif ( isEqual( oneCombinationDottedi, indicesSmalli ) ) {\n\t\t\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, [] ] );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconst oneCombinationDotlessi = arraysDifference( indicesSmalli, oneCombinationDottedi );\n\n\t\t\t\t\t\t\tresults.push( [ oneCombinationDottedI, oneCombinationDotlessI, oneCombinationDottedi, oneCombinationDotlessi ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t} );\n\n\tconst textAlternations = [];\n\n\tresults.forEach( function( result ) {\n\t\tconst toDottedI = replaceCharactersByIndex( text, result[ 0 ], \"İ\" );\n\t\tconst toDotlessI = replaceCharactersByIndex( toDottedI, result[ 1 ], \"I\" );\n\t\tconst toDottedi = replaceCharactersByIndex( toDotlessI, result[ 2 ], \"i\" );\n\t\tconst toDotlessi = replaceCharactersByIndex( toDottedi, result[ 3 ], \"ı\" );\n\t\ttextAlternations.push( toDotlessi );\n\t} );\n\n\treturn textAlternations;\n}\n\nconst replaceTurkishIsMemoized = memoize( replaceTurkishIs );\n\nexport {\n\tgetIndicesOfWords,\n\tgetIndicesOfCharacter,\n\tarraysDifference,\n\tarraysOverlap,\n\tcombinations,\n\treplaceTurkishIs,\n\treplaceTurkishIsMemoized,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/transliterate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transliterate.js","names":["transliterationsMap","text","locale","map","i","length","replace","letter","alternative"],"sources":["../../../../src/languageProcessing/helpers/transliterate/transliterate.js"],"sourcesContent":["import transliterationsMap from \"../../../config/getTransliterations.js\";\n\n/**\n * Replaces all special characters from the text based on the transliterations map.\n *\n * @param {string} text     The text to remove special characters from.\n * @param {string} locale   The locale.\n *\n * @returns {string} The text with all special characters replaced.\n */\nexport default function( text, locale ) {\n\tconst map = transliterationsMap( locale );\n\tfor ( let i = 0; i < map.length; i++ ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letter,\n\t\t\tmap[ i ].alternative\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA,OAAOA,mBAAmB;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,MAAM,EAAG;EACvC,MAAMC,GAAG,GAAGH,mBAAmB,CAAEE,MAAO,CAAC;EACzC,KAAM,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,GAAG,CAACE,MAAM,EAAED,CAAC,EAAE,EAAG;IACtCH,IAAI,GAAGA,IAAI,CAACK,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,MAAM,EACfJ,GAAG,CAAEC,CAAC,CAAE,CAACI,WACV,CAAC;EACF;EACA,OAAOP,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/transliterate/transliterateWPstyle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transliterateWPstyle.js","names":["transliterationsMap","text","locale","map","i","length","replace","letter","alternative"],"sources":["../../../../src/languageProcessing/helpers/transliterate/transliterateWPstyle.js"],"sourcesContent":["import transliterationsMap from \"../../../config/transliterationsWPstyle.js\";\n\n/**\n * Replaces all special characters from the text based on the transliterations map specific for WP\n * (and different from the one used by YoastSEO.js).\n *\n * @param {string} text     The text to remove special characters from.\n * @param {string} locale   The locale.\n *\n * @returns {string} The text with all special characters replaced.\n */\nexport default function( text, locale ) {\n\tconst map = transliterationsMap( locale );\n\tfor ( let i = map.length - 1; i >= 0; i-- ) {\n\t\ttext = text.replace(\n\t\t\tmap[ i ].letter,\n\t\t\tmap[ i ].alternative\n\t\t);\n\t}\n\treturn text;\n}\n"],"mappings":"AAAA,OAAOA,mBAAmB;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,MAAM,EAAG;EACvC,MAAMC,GAAG,GAAGH,mBAAmB,CAAEE,MAAO,CAAC;EACzC,KAAM,IAAIE,CAAC,GAAGD,GAAG,CAACE,MAAM,GAAG,CAAC,EAAED,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAG;IAC3CH,IAAI,GAAGA,IAAI,CAACK,OAAO,CAClBH,GAAG,CAAEC,CAAC,CAAE,CAACG,MAAM,EACfJ,GAAG,CAAEC,CAAC,CAAE,CAACI,WACV,CAAC;EACF;EACA,OAAOP,IAAI;AACZ","ignoreList":[]}

package/build/languageProcessing/helpers/url/parseSlug.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseSlug.js","names":["slug","replace"],"sources":["../../../../src/languageProcessing/helpers/url/parseSlug.js"],"sourcesContent":["/**\n * Parses the slug by transforming hyphens and underscores into white space.\n *\n * @param {string} slug The slug to parse\n *\n * @returns {string} The parsed slug.\n */\nexport default function( slug ) {\n\treturn slug.replace( /[-_]/ig, \" \" );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAG;EAC/B,OAAOA,IAAI,CAACC,OAAO,CAAE,QAAQ,EAAE,GAAI,CAAC;AACrC","ignoreList":[]}

package/build/languageProcessing/helpers/url/url.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.js","names":["urlFromAnchorRegex","urlMethods","removeHash","url","split","removeQueryArgs","removeTrailingSlash","replace","addTrailingSlash","getFromAnchorTag","anchorTag","urlMatch","exec","areEqual","urlA","urlB","getHostname","parse","hostname","getProtocol","protocol","isInternalLink","anchorUrl","siteUrlOrDomain","parsedAnchorUrl","anchorUrlHostName","indexOf","parsedSiteUrlOrDomain","siteUrlOrDomainHostName","protocolIsHttpScheme","isRelativeFragmentURL"],"sources":["../../../../src/languageProcessing/helpers/url/url.js"],"sourcesContent":["const urlFromAnchorRegex = /href=([\"'])([^\"']+)\\1/i;\nimport urlMethods from \"url\";\n\n/**\n * Removes a hash from a URL, assumes a well formed URL.\n *\n * @param {string} url The URL to remove a hash from.\n * @returns {string} The URL without the hash.\n */\nfunction removeHash( url ) {\n\treturn url.split( \"#\" )[ 0 ];\n}\n\n/**\n * Removes all query args from a URL, assumes a well formed URL.\n *\n * @param {string} url The URL to remove the query args from.\n * @returns {string} The URL without the query args.\n */\nfunction removeQueryArgs( url ) {\n\treturn url.split( \"?\" )[ 0 ];\n}\n\n/**\n * Removes the trailing slash of a URL.\n *\n * @param {string} url The URL to remove the trailing slash from.\n * @returns {string} A URL without a trailing slash.\n */\nfunction removeTrailingSlash( url ) {\n\treturn url.replace( /\\/$/, \"\" );\n}\n\n/**\n * Adds a trailing slash to a URL if it is not present.\n *\n * @param {string} url The URL to add a trailing slash to.\n * @returns {string} A URL with a trailing slash.\n */\nfunction addTrailingSlash( url ) {\n\treturn removeTrailingSlash( url ) + \"/\";\n}\n\n/**\n * Retrieves the URL from an anchor tag.\n *\n * @param {string} anchorTag An anchor tag.\n * @returns {string} The URL in the anchor tag.\n */\nfunction getFromAnchorTag( anchorTag ) {\n\tconst urlMatch = urlFromAnchorRegex.exec( anchorTag );\n\n\treturn ( urlMatch === null ) ? \"\" : urlMatch[ 2 ];\n}\n\n/**\n * Returns whether or not the given URLs are equal.\n *\n * @param {string} urlA The first URL to compare.\n * @param {string} urlB The second URL to compare.\n *\n * @returns {boolean} Whether or not the given URLs are equal.\n */\nfunction areEqual( urlA, urlB ) {\n\t// Make sure we are comparing URLs without query arguments and hashes.\n\turlA = removeQueryArgs( removeHash( urlA ) );\n\turlB = removeQueryArgs( removeHash( urlB ) );\n\n\treturn addTrailingSlash( urlA ) === addTrailingSlash( urlB );\n}\n\n/**\n * Returns the domain name of a URL.\n *\n * @param {string} url The URL to retrieve the domain name of.\n * @returns {string} The domain name of the URL.\n */\nfunction getHostname( url ) {\n\turl = urlMethods.parse( url );\n\n\treturn url.hostname;\n}\n\n/**\n * Returns the protocol of a URL.\n *\n * Note that the colon (http:) is also part of the protocol, conform to node's url.parse api.\n *\n * @param {string} url The URL to retrieve the protocol of.\n * @returns {string|null} The protocol of the URL or null if no protocol is present.\n */\nfunction getProtocol( url ) {\n\treturn urlMethods.parse( url ).protocol;\n}\n\n/**\n * Determine whether an anchor URL is internal.\n *\n * @param {string} anchorUrl \t\tThe anchor URL to test.\n * @param {string} siteUrlOrDomain  The current site's URL or domain.\n *\n * @returns {boolean} Whether or not the anchor URL is internal.\n */\nfunction isInternalLink( anchorUrl, siteUrlOrDomain ) {\n\tconst parsedAnchorUrl = urlMethods.parse( anchorUrl, false, true );\n\tconst anchorUrlHostName = parsedAnchorUrl.hostname;\n\n\t// Check if the anchor URL starts with a single slash.\n\tif ( anchorUrl.indexOf( \"//\" ) === -1 && anchorUrl.indexOf( \"/\" ) === 0 ) {\n\t\treturn true;\n\t}\n\n\t// Check if the anchor URL starts with a # indicating a fragment.\n\tif ( anchorUrl.indexOf( \"#\" ) === 0 ) {\n\t\treturn false;\n\t}\n\n\t// No host of the anchor URL indicates an internal link.\n\tif ( ! anchorUrlHostName ) {\n\t\treturn true;\n\t}\n\n\t// If the siteUrlOrDomain variable is a domain, it would be idential to the anchor URL's hostname in case of an internal link.\n\tif ( anchorUrlHostName === siteUrlOrDomain ) {\n\t\treturn true;\n\t}\n\n\t// If the siteUrlOrDomain variable is a URL and it shares the hostname with the anchor URL, it's an internal link.\n\tconst parsedSiteUrlOrDomain = urlMethods.parse( siteUrlOrDomain );\n\tconst siteUrlOrDomainHostName = parsedSiteUrlOrDomain.hostname;\n\treturn anchorUrlHostName === siteUrlOrDomainHostName;\n}\n\n/**\n * Checks whether the protocol is either HTTP: or HTTPS:.\n *\n * @param {string} protocol The protocol to test.\n *\n * @returns {boolean} Whether the protocol is http(s):.\n */\nfunction protocolIsHttpScheme( protocol ) {\n\tif ( ! protocol ) {\n\t\treturn false;\n\t}\n\n\treturn ( protocol === \"http:\" || protocol === \"https:\" );\n}\n\n/**\n * Determines whether the link is a relative fragment URL.\n *\n * @param {string} url The URL to test.\n *\n * @returns {boolean} Whether the link is a relative fragment URL.\n */\nfunction isRelativeFragmentURL( url ) {\n\treturn url.indexOf( \"#\" ) === 0;\n}\n\nexport default {\n\tremoveHash: removeHash,\n\tremoveQueryArgs: removeQueryArgs,\n\tremoveTrailingSlash: removeTrailingSlash,\n\taddTrailingSlash: addTrailingSlash,\n\tgetFromAnchorTag: getFromAnchorTag,\n\tareEqual: areEqual,\n\tgetHostname: getHostname,\n\tgetProtocol: getProtocol,\n\tisInternalLink: isInternalLink,\n\tprotocolIsHttpScheme: protocolIsHttpScheme,\n\tisRelativeFragmentURL: isRelativeFragmentURL,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/word/addWordboundary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"addWordboundary.js","names":["matchString","positiveLookAhead","extraWordBoundary","language","wordBoundary","wordBoundaryEnd","wordBoundaryStart"],"sources":["../../../../src/languageProcessing/helpers/word/addWordboundary.js"],"sourcesContent":["/**\n * Returns a string that can be used in a regex to match a matchString with word boundaries.\n *\n * @param {string}  matchString                 The string to generate a regex string for.\n * @param {boolean} [positiveLookAhead=false]   Boolean indicating whether or not to include a positive look ahead\n * for the word boundaries at the end.\n * @param {string} [extraWordBoundary=\"\"]       Extra characters to match a word boundary on.\n * @param {string} [language=\"\"]                The language used to determine the word boundary.\n *\n * @returns {string} A regex string that matches the matchString with word boundaries.\n */\nexport default function( matchString, positiveLookAhead = false, extraWordBoundary = \"\", language = \"\" ) {\n\tlet wordBoundary, wordBoundaryEnd;\n\n\tif ( language === \"id\" ) {\n\t\twordBoundary = \"[ \\\\u00a0\\\\n\\\\r\\\\t.,()”“〝〞〟‟„\\\"+;!¡?¿:/»«‹›\" + extraWordBoundary + \"<>\";\n\t} else {\n\t\t/*\n\t\t * \\u00a0 - no-break space\n\t\t * \\u2014 - em dash\n         * \\u06d4 - Urdu full stop\n         * \\u061f - Arabic question mark\n         * \\u060C - Arabic comma\n         * \\u061B - Arabic semicolon\n         */\n\t\twordBoundary = \"[ \\\\u00a0\\\\u2014\\\\u06d4\\\\u061f\\\\u060C\\\\u061B\\\\n\\\\r\\\\t.,()”“〝〞〟‟„\\\"+\\\\-;!¡?¿:/»«‹›\" + extraWordBoundary + \"<>\";\n\t}\n\n\tconst wordBoundaryStart = \"(^|\" + wordBoundary + \"'‘’‛`])\";\n\tif ( positiveLookAhead ) {\n\t\twordBoundaryEnd = \"($|((?=\" + wordBoundary + \"]))|((['‘’‛`])(\" + wordBoundary + \"])))\";\n\t} else {\n\t\twordBoundaryEnd = \"($|(\" + wordBoundary + \"])|((['‘’‛`])(\" + wordBoundary + \"])))\";\n\t}\n\n\treturn wordBoundaryStart + matchString + wordBoundaryEnd;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,WAAW,EAAEC,iBAAiB,GAAG,KAAK,EAAEC,iBAAiB,GAAG,EAAE,EAAEC,QAAQ,GAAG,EAAE,EAAG;EACxG,IAAIC,YAAY,EAAEC,eAAe;EAEjC,IAAKF,QAAQ,KAAK,IAAI,EAAG;IACxBC,YAAY,GAAG,6CAA6C,GAAGF,iBAAiB,GAAG,IAAI;EACxF,CAAC,MAAM;IACN;AACF;AACA;AACA;AACA;AACA;AACA;AACA;IACEE,YAAY,GAAG,mFAAmF,GAAGF,iBAAiB,GAAG,IAAI;EAC9H;EAEA,MAAMI,iBAAiB,GAAG,KAAK,GAAGF,YAAY,GAAG,SAAS;EAC1D,IAAKH,iBAAiB,EAAG;IACxBI,eAAe,GAAG,SAAS,GAAGD,YAAY,GAAG,iBAAiB,GAAGA,YAAY,GAAG,MAAM;EACvF,CAAC,MAAM;IACNC,eAAe,GAAG,MAAM,GAAGD,YAAY,GAAG,gBAAgB,GAAGA,YAAY,GAAG,MAAM;EACnF;EAEA,OAAOE,iBAAiB,GAAGN,WAAW,GAAGK,eAAe;AACzD","ignoreList":[]}

package/build/languageProcessing/helpers/word/areWordsInSentence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"areWordsInSentence.js","names":["filter","getWords","areWordsInSentence","words","sentence","matches","word","includes","toLocaleLowerCase","length"],"sources":["../../../../src/languageProcessing/helpers/word/areWordsInSentence.js"],"sourcesContent":["import { filter } from \"lodash\";\nimport getWords from \"./getWords.js\";\n\n/**\n * Checks if one or more words of a list occur in a sentence.\n *\n * @param {Array} words The list of words.\n * @param {string} sentence The sentence to match against.\n * @returns {Boolean} Whether the sentence contains the word.\n */\nexport default function areWordsInSentence( words, sentence ) {\n\tconst matches = filter( getWords( sentence ), function( word ) {\n\t\treturn words.includes( word.toLocaleLowerCase() );\n\t} );\n\treturn matches.length !== 0;\n}\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,QAAQ;AAC/B,OAAOC,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,kBAAkBA,CAAEC,KAAK,EAAEC,QAAQ,EAAG;EAC7D,MAAMC,OAAO,GAAGL,MAAM,CAAEC,QAAQ,CAAEG,QAAS,CAAC,EAAE,UAAUE,IAAI,EAAG;IAC9D,OAAOH,KAAK,CAACI,QAAQ,CAAED,IAAI,CAACE,iBAAiB,CAAC,CAAE,CAAC;EAClD,CAAE,CAAC;EACH,OAAOH,OAAO,CAACI,MAAM,KAAK,CAAC;AAC5B","ignoreList":[]}

package/build/languageProcessing/helpers/word/countMetaDescriptionLength.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"countMetaDescriptionLength.js","names":["date","description","descriptionLength","length"],"sources":["../../../../src/languageProcessing/helpers/word/countMetaDescriptionLength.js"],"sourcesContent":["/**\n * Check the length of the description.\n *\n * @param {string}  date          The date.\n * @param {string}  description   The meta description.\n *\n * @returns {number} The length of the description.\n */\nexport default function( date, description ) {\n\tlet descriptionLength = description.length;\n\t/* If the meta description is preceded by a date, two spaces and a hyphen (\" - \") are added as well. Therefore,\n\tthree needs to be added to the total length. */\n\tif ( date !== \"\" && descriptionLength > 0 ) {\n\t\tdescriptionLength += date.length + 3;\n\t}\n\n\treturn descriptionLength;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAEC,WAAW,EAAG;EAC5C,IAAIC,iBAAiB,GAAGD,WAAW,CAACE,MAAM;EAC1C;AACD;EACC,IAAKH,IAAI,KAAK,EAAE,IAAIE,iBAAiB,GAAG,CAAC,EAAG;IAC3CA,iBAAiB,IAAIF,IAAI,CAACG,MAAM,GAAG,CAAC;EACrC;EAEA,OAAOD,iBAAiB;AACzB","ignoreList":[]}

package/build/languageProcessing/helpers/word/countWords.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"countWords.js","names":["getWords","text","length"],"sources":["../../../../src/languageProcessing/helpers/word/countWords.js"],"sourcesContent":["/** @module stringProcessing/countWords */\n\nimport getWords from \"./getWords.js\";\n\n/**\n * Calculates the word count of a certain text.\n *\n * @param {string} text The text to be counted.\n *\n * @returns {number} The word count of the given text.\n */\nexport default function( text ) {\n\treturn getWords( text ).length;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOD,QAAQ,CAAEC,IAAK,CAAC,CAACC,MAAM;AAC/B","ignoreList":[]}

package/build/languageProcessing/helpers/word/createPunctuationTokens.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createPunctuationTokens.js","names":["punctuationRegexEnd","punctuationRegexStart","hashedHtmlEntitiesRegexEnd","hashedHtmlEntitiesRegexStart","createPunctuationTokens","rawTokens","tokenTexts","forEach","token","preTokens","postTokens","test","push","slice","unshift","length","currentTokens","filter","x"],"sources":["../../../../src/languageProcessing/helpers/word/createPunctuationTokens.js"],"sourcesContent":["import { punctuationRegexEnd, punctuationRegexStart } from \"../sanitize/removePunctuation\";\nimport { hashedHtmlEntitiesRegexEnd, hashedHtmlEntitiesRegexStart } from \"../../../helpers/htmlEntities\";\n\n/**\n * Removes punctuation from the beginning and end of a word token, and creates separate tokens from them.\n *\n * @param {string[]} rawTokens\tThe tokens that may contain punctuation at the beginning and end of words.\n *\n * @returns {string[]} The tokens with the punctuation moved into separate tokens.\n */\nconst createPunctuationTokens = ( rawTokens ) => {\n\tconst tokenTexts = [];\n\trawTokens.forEach( token => {\n\t\t// Pretokens contains all that occurs before the first letter of the token.\n\t\tconst preTokens = [];\n\t\t// Posttokens contains all that occurs after the last letter of the token.\n\t\tconst postTokens = [];\n\n\t\t// Add all punctuation marks that occur before the first letter of the token to the pretokens array.\n\t\t// Also, prevent matching with a hashed HTML entity in the beginning of the token.\n\t\twhile ( punctuationRegexStart.test( token ) && ! hashedHtmlEntitiesRegexStart.test( token ) ) {\n\t\t\tpreTokens.push( token[ 0 ] );\n\t\t\ttoken = token.slice( 1 );\n\t\t}\n\t\t// Add all punctuation marks that occur after the last letter of the token to the posttokens array.\n\t\t// Also, prevent matching with a hashed HTML entity at the end of the token.\n\t\twhile ( punctuationRegexEnd.test( token ) && ! hashedHtmlEntitiesRegexEnd.test( token ) ) {\n\t\t\t// Using unshift here because we are iterating from the end of the string to the beginning,\n\t\t\t// and we want to keep the order of the punctuation marks.\n\t\t\t// Therefore, we add them to the start of the array.\n\t\t\tpostTokens.unshift( token[ token.length - 1 ] );\n\t\t\ttoken = token.slice( 0, -1 );\n\t\t}\n\n\t\tlet currentTokens = [ ...preTokens, token, ...postTokens ];\n\t\tcurrentTokens = currentTokens.filter( x => x !== \"\" );\n\t\ttokenTexts.push( ...currentTokens );\n\t} );\n\treturn tokenTexts;\n};\n\nexport default createPunctuationTokens;\n"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,qBAAqB;AACnD,SAASC,0BAA0B,EAAEC,4BAA4B;;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,uBAAuB,GAAKC,SAAS,IAAM;EAChD,MAAMC,UAAU,GAAG,EAAE;EACrBD,SAAS,CAACE,OAAO,CAAEC,KAAK,IAAI;IAC3B;IACA,MAAMC,SAAS,GAAG,EAAE;IACpB;IACA,MAAMC,UAAU,GAAG,EAAE;;IAErB;IACA;IACA,OAAQT,qBAAqB,CAACU,IAAI,CAAEH,KAAM,CAAC,IAAI,CAAEL,4BAA4B,CAACQ,IAAI,CAAEH,KAAM,CAAC,EAAG;MAC7FC,SAAS,CAACG,IAAI,CAAEJ,KAAK,CAAE,CAAC,CAAG,CAAC;MAC5BA,KAAK,GAAGA,KAAK,CAACK,KAAK,CAAE,CAAE,CAAC;IACzB;IACA;IACA;IACA,OAAQb,mBAAmB,CAACW,IAAI,CAAEH,KAAM,CAAC,IAAI,CAAEN,0BAA0B,CAACS,IAAI,CAAEH,KAAM,CAAC,EAAG;MACzF;MACA;MACA;MACAE,UAAU,CAACI,OAAO,CAAEN,KAAK,CAAEA,KAAK,CAACO,MAAM,GAAG,CAAC,CAAG,CAAC;MAC/CP,KAAK,GAAGA,KAAK,CAACK,KAAK,CAAE,CAAC,EAAE,CAAC,CAAE,CAAC;IAC7B;IAEA,IAAIG,aAAa,GAAG,CAAE,GAAGP,SAAS,EAAED,KAAK,EAAE,GAAGE,UAAU,CAAE;IAC1DM,aAAa,GAAGA,aAAa,CAACC,MAAM,CAAEC,CAAC,IAAIA,CAAC,KAAK,EAAG,CAAC;IACrDZ,UAAU,CAACM,IAAI,CAAE,GAAGI,aAAc,CAAC;EACpC,CAAE,CAAC;EACH,OAAOV,UAAU;AAClB,CAAC;AAED,eAAeF,uBAAuB","ignoreList":[]}

package/build/languageProcessing/helpers/word/filterWordsFromArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterWordsFromArray.js","names":["filter","includes","filterWordsFromArray","array","words","word","trim","toLocaleLowerCase"],"sources":["../../../../src/languageProcessing/helpers/word/filterWordsFromArray.js"],"sourcesContent":["import { filter, includes } from \"lodash\";\n\n/**\n * Filters certain words from an array of words.\n *\n * @param {Array} array The words to check.\n * @param {Array} words The words to filter.\n *\n * @returns {Array} The original array with the certain words filtered out.\n */\nexport default function filterWordsFromArray( array, words = [] ) {\n\treturn filter( array, function( word ) {\n\t\treturn ( ! includes( words, word.trim().toLocaleLowerCase() ) );\n\t} );\n}\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,QAAQ,QAAQ,QAAQ;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,oBAAoBA,CAAEC,KAAK,EAAEC,KAAK,GAAG,EAAE,EAAG;EACjE,OAAOJ,MAAM,CAAEG,KAAK,EAAE,UAAUE,IAAI,EAAG;IACtC,OAAS,CAAEJ,QAAQ,CAAEG,KAAK,EAAEC,IAAI,CAACC,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAE,CAAC;EAC9D,CAAE,CAAC;AACJ","ignoreList":[]}

package/build/languageProcessing/helpers/word/followsIndex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"followsIndex.js","names":["isEmpty","forEach","includes","followingWords","match","wordAfterMatchIndex","index","length","followingWordsIndices","followingWord","push"],"sources":["../../../../src/languageProcessing/helpers/word/followsIndex.js"],"sourcesContent":["import { isEmpty, forEach, includes } from \"lodash\";\n\n/**\n * Checks whether a given word is followed by any word from a given list.\n *\n * @param {Array} followingWords    The array of objects with matches and indices.\n * @param {Object} match            The object with the match and index to test the following words for.\n *\n * @returns {boolean} Returns true if the match is followed by a given word, otherwise returns false.\n */\nexport default function( followingWords, match ) {\n\tif ( isEmpty( followingWords ) ) {\n\t\treturn false;\n\t}\n\n\t// The followingWordIndices include the preceding space.\n\tconst wordAfterMatchIndex = match.index + match.match.length;\n\tconst followingWordsIndices = [];\n\n\tforEach( followingWords, function( followingWord ) {\n\t\tfollowingWordsIndices.push( followingWord.index );\n\t} );\n\n\treturn includes( followingWordsIndices, wordAfterMatchIndex );\n}\n"],"mappings":"AAAA,SAASA,OAAO,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,cAAc,EAAEC,KAAK,EAAG;EAChD,IAAKJ,OAAO,CAAEG,cAAe,CAAC,EAAG;IAChC,OAAO,KAAK;EACb;;EAEA;EACA,MAAME,mBAAmB,GAAGD,KAAK,CAACE,KAAK,GAAGF,KAAK,CAACA,KAAK,CAACG,MAAM;EAC5D,MAAMC,qBAAqB,GAAG,EAAE;EAEhCP,OAAO,CAAEE,cAAc,EAAE,UAAUM,aAAa,EAAG;IAClDD,qBAAqB,CAACE,IAAI,CAAED,aAAa,CAACH,KAAM,CAAC;EAClD,CAAE,CAAC;EAEH,OAAOJ,QAAQ,CAAEM,qBAAqB,EAAEH,mBAAoB,CAAC;AAC9D","ignoreList":[]}

package/build/languageProcessing/helpers/word/getAllWordsFromTree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAllWordsFromTree.js","names":["getSentencesFromTree","flatMap","removePunctuation","paper","sentences","tokens","map","sentence","words","token","text","filter","word","trim"],"sources":["../../../../src/languageProcessing/helpers/word/getAllWordsFromTree.js"],"sourcesContent":["import getSentencesFromTree from \"../sentence/getSentencesFromTree\";\nimport { flatMap } from \"lodash\";\nimport removePunctuation from \"../sanitize/removePunctuation\";\n\n/**\n * Gets the words from the tree, i.e. from the paragraph and heading nodes.\n * These two node types are the nodes that should contain words for the analysis.\n *\n * @param {Paper} paper The paper to get the tree and words from.\n *\n * @returns {String[]} Array of words retrieved from the tree.\n */\nexport default function( paper ) {\n\tconst sentences = getSentencesFromTree( paper );\n\t// Get all the tokens from each sentence.\n\tconst tokens = sentences.map( sentence => sentence.tokens );\n\tlet words = flatMap( tokens ).map( token => token.text );\n\t// Remove punctuation and spaces.\n\twords = words.map( token => removePunctuation( token ) );\n\n\t// Filter out empty tokens.\n\treturn words.filter( word => word.trim() !== \"\" );\n}\n"],"mappings":"AAAA,OAAOA,oBAAoB;AAC3B,SAASC,OAAO,QAAQ,QAAQ;AAChC,OAAOC,iBAAiB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,KAAK,EAAG;EAChC,MAAMC,SAAS,GAAGJ,oBAAoB,CAAEG,KAAM,CAAC;EAC/C;EACA,MAAME,MAAM,GAAGD,SAAS,CAACE,GAAG,CAAEC,QAAQ,IAAIA,QAAQ,CAACF,MAAO,CAAC;EAC3D,IAAIG,KAAK,GAAGP,OAAO,CAAEI,MAAO,CAAC,CAACC,GAAG,CAAEG,KAAK,IAAIA,KAAK,CAACC,IAAK,CAAC;EACxD;EACAF,KAAK,GAAGA,KAAK,CAACF,GAAG,CAAEG,KAAK,IAAIP,iBAAiB,CAAEO,KAAM,CAAE,CAAC;;EAExD;EACA,OAAOD,KAAK,CAACG,MAAM,CAAEC,IAAI,IAAIA,IAAI,CAACC,IAAI,CAAC,CAAC,KAAK,EAAG,CAAC;AAClD","ignoreList":[]}

package/build/languageProcessing/helpers/word/getWords.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getWords.js","names":["sanitizeString","filter","flatMap","removePunctuation","punctuationRegexString","punctuationRegex","RegExp","text","wordBoundaryRegexString","shouldRemovePunctuation","chineseCharRegex","hasChinese","test","hasNoSpaces","words","Array","from","char","wordBoundaryRegex","split","map","word","newWord","replace","trim"],"sources":["../../../../src/languageProcessing/helpers/word/getWords.js"],"sourcesContent":["/** @module stringProcessing/countWords */\nimport sanitizeString from '../sanitize/sanitizeString';\nimport {filter, flatMap} from 'lodash';\nimport removePunctuation, {punctuationRegexString} from '../sanitize/removePunctuation.js';\n\nconst punctuationRegex = new RegExp(`([${punctuationRegexString}])`, 'g');\n\n/**\n * Returns an array with words used in the text.\n *\n * @param {string} text The text to be counted.\n * @param {string} [wordBoundaryRegexString=\\\\s] The regex string for the word boundary that should be used to split the text into words.\n * @param {boolean} [shouldRemovePunctuation=true] If punctuation should be removed. Defaults to `true`.\n *\n * @returns {Array} The array with all words.\n */\nexport default function(text, wordBoundaryRegexString = '\\\\s', shouldRemovePunctuation = true) {\n  // Unify whitespaces and non-breaking spaces, remove table of content and strip the tags and multiple spaces.\n  text = sanitizeString(text);\n\n  if (text === '') {\n    return [];\n  }\n\n  const chineseCharRegex = /[\\u4e00-\\u9fff]/;\n  const hasChinese = chineseCharRegex.test(text);\n  const hasNoSpaces = !/\\s/.test(text);\n\n  let words = [];\n\n  if (hasChinese && hasNoSpaces) {\n    words = Array.from(text).filter(char => chineseCharRegex.test(char));\n  } else {\n    const wordBoundaryRegex = new RegExp(wordBoundaryRegexString, 'g');\n\n    words = text.split(wordBoundaryRegex);\n\n    if (shouldRemovePunctuation) {\n      words = words.map(removePunctuation);\n    } else {\n      // If punctuation is not removed, punctuation marks are tokenized as if they were words.\n      words = flatMap(words, word => {\n        const newWord = word.replace(punctuationRegex, ' $1 ');\n        return newWord.split(' ');\n      });\n    }\n  }\n\n  return filter(words, function(word) {\n    return word.trim() !== '';\n  });\n}\n"],"mappings":"AAAA;AACA,OAAOA,cAAc;AACrB,SAAQC,MAAM,EAAEC,OAAO,QAAO,QAAQ;AACtC,OAAOC,iBAAiB,IAAGC,sBAAsB;AAEjD,MAAMC,gBAAgB,GAAG,IAAIC,MAAM,CAAC,KAAKF,sBAAsB,IAAI,EAAE,GAAG,CAAC;;AAEzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAASG,IAAI,EAAEC,uBAAuB,GAAG,KAAK,EAAEC,uBAAuB,GAAG,IAAI,EAAE;EAC7F;EACAF,IAAI,GAAGP,cAAc,CAACO,IAAI,CAAC;EAE3B,IAAIA,IAAI,KAAK,EAAE,EAAE;IACf,OAAO,EAAE;EACX;EAEA,MAAMG,gBAAgB,GAAG,iBAAiB;EAC1C,MAAMC,UAAU,GAAGD,gBAAgB,CAACE,IAAI,CAACL,IAAI,CAAC;EAC9C,MAAMM,WAAW,GAAG,CAAC,IAAI,CAACD,IAAI,CAACL,IAAI,CAAC;EAEpC,IAAIO,KAAK,GAAG,EAAE;EAEd,IAAIH,UAAU,IAAIE,WAAW,EAAE;IAC7BC,KAAK,GAAGC,KAAK,CAACC,IAAI,CAACT,IAAI,CAAC,CAACN,MAAM,CAACgB,IAAI,IAAIP,gBAAgB,CAACE,IAAI,CAACK,IAAI,CAAC,CAAC;EACtE,CAAC,MAAM;IACL,MAAMC,iBAAiB,GAAG,IAAIZ,MAAM,CAACE,uBAAuB,EAAE,GAAG,CAAC;IAElEM,KAAK,GAAGP,IAAI,CAACY,KAAK,CAACD,iBAAiB,CAAC;IAErC,IAAIT,uBAAuB,EAAE;MAC3BK,KAAK,GAAGA,KAAK,CAACM,GAAG,CAACjB,iBAAiB,CAAC;IACtC,CAAC,MAAM;MACL;MACAW,KAAK,GAAGZ,OAAO,CAACY,KAAK,EAAEO,IAAI,IAAI;QAC7B,MAAMC,OAAO,GAAGD,IAAI,CAACE,OAAO,CAAClB,gBAAgB,EAAE,MAAM,CAAC;QACtD,OAAOiB,OAAO,CAACH,KAAK,CAAC,GAAG,CAAC;MAC3B,CAAC,CAAC;IACJ;EACF;EAEA,OAAOlB,MAAM,CAACa,KAAK,EAAE,UAASO,IAAI,EAAE;IAClC,OAAOA,IAAI,CAACG,IAAI,CAAC,CAAC,KAAK,EAAE;EAC3B,CAAC,CAAC;AACJ","ignoreList":[]}

package/build/languageProcessing/helpers/word/includesIndex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"includesIndex.js","names":["forEach","includes","isEmpty","precedingWords","matchIndex","addSpace","space","precedingWordsEndIndices","precedingWord","precedingWordsEndIndex","index","match","length","push"],"sources":["../../../../src/languageProcessing/helpers/word/includesIndex.js"],"sourcesContent":["import { forEach, includes, isEmpty } from \"lodash\";\n\n/**\n * Checks whether a given word is directly preceded by a word from a list of words.\n *\n * @param {Array} precedingWords    The array of objects with matches and indices.\n * @param {number} matchIndex       The index of the word for which to check whether it's preceded by one of the other words.\n * @param {boolean} addSpace        True if a space should be added.\n *\n * @returns {boolean} Returns true if the match is preceded by a given word, otherwise returns false.\n */\nexport default function( precedingWords, matchIndex, addSpace = true ) {\n\t/*\n\t1 if there is a space between the match and the preceding word\n\t(because the end word boundary is not included in the match).\n\t0 if the preceding word is a contraction.\n\t*/\n\tconst space = addSpace ? 1 : 0;\n\n\tif ( isEmpty( precedingWords ) ) {\n\t\treturn false;\n\t}\n\n\tconst precedingWordsEndIndices = [];\n\tforEach( precedingWords, function( precedingWord ) {\n\t\tconst precedingWordsEndIndex = precedingWord.index + precedingWord.match.length + space;\n\t\tprecedingWordsEndIndices.push( precedingWordsEndIndex );\n\t} );\n\treturn includes( precedingWordsEndIndices, matchIndex );\n}\n"],"mappings":"AAAA,SAASA,OAAO,EAAEC,QAAQ,EAAEC,OAAO,QAAQ,QAAQ;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,cAAc,EAAEC,UAAU,EAAEC,QAAQ,GAAG,IAAI,EAAG;EACtE;AACD;AACA;AACA;AACA;EACC,MAAMC,KAAK,GAAGD,QAAQ,GAAG,CAAC,GAAG,CAAC;EAE9B,IAAKH,OAAO,CAAEC,cAAe,CAAC,EAAG;IAChC,OAAO,KAAK;EACb;EAEA,MAAMI,wBAAwB,GAAG,EAAE;EACnCP,OAAO,CAAEG,cAAc,EAAE,UAAUK,aAAa,EAAG;IAClD,MAAMC,sBAAsB,GAAGD,aAAa,CAACE,KAAK,GAAGF,aAAa,CAACG,KAAK,CAACC,MAAM,GAAGN,KAAK;IACvFC,wBAAwB,CAACM,IAAI,CAAEJ,sBAAuB,CAAC;EACxD,CAAE,CAAC;EACH,OAAOR,QAAQ,CAAEM,wBAAwB,EAAEH,UAAW,CAAC;AACxD","ignoreList":[]}

package/build/languageProcessing/helpers/word/indices.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"indices.js","names":["isUndefined","forEach","stripSpaces","isWordInSentence","matchWordInSentence","characterInBoundary","getIndicesByWord","word","text","startIndex","searchStringLength","length","index","indices","indexOf","isPreviousCharacterWordBoundary","isNextCharacterWordBoundary","push","match","getIndicesByWordList","words","matchedWords","concat","sortIndices","sort","a","b","filterIndices","filtered","i","getIndicesByWordListSorted"],"sources":["../../../../src/languageProcessing/helpers/word/indices.js"],"sourcesContent":["import { isUndefined, forEach } from \"lodash\";\nimport stripSpaces from \"../sanitize/stripSpaces.js\";\nimport { isWordInSentence as matchWordInSentence, characterInBoundary } from \"./matchWordInSentence.js\";\n\n/**\n * Returns the indices of a string in a text. If it is found multiple times, it will return multiple indices.\n *\n * @param {string} word The word to find in the text.\n * @param {string} text The text to check for the given word.\n *\n * @returns {Array} All indices found.\n */\nfunction getIndicesByWord( word, text ) {\n\tlet startIndex = 0;\n\tconst searchStringLength = word.length;\n\tlet index;\n\tconst indices = [];\n\twhile ( ( index = text.indexOf( word, startIndex ) ) > -1 ) {\n\t\t// Check if the previous and next character are word boundaries to determine if a complete word was detected\n\t\tconst isPreviousCharacterWordBoundary = characterInBoundary( text[ index - 1 ] ) || index === 0;\n\n\t\tconst isNextCharacterWordBoundary = characterInBoundary( text[ index + searchStringLength ] ) ||\n\t\t\t( text.length === index + searchStringLength );\n\n\t\tif ( isPreviousCharacterWordBoundary && isNextCharacterWordBoundary ) {\n\t\t\tindices.push(\n\t\t\t\t{\n\t\t\t\t\tindex: index,\n\t\t\t\t\tmatch: word,\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\tstartIndex = index + searchStringLength;\n\t}\n\treturn indices;\n}\n\n/**\n * Matches string with an array, returns the word and the index it was found on.\n *\n * @param {Array} words The array with strings to match.\n * @param {string} text The text to match the strings from the array to.\n *\n * @returns {Array} The array with words, containing the index of the match and the matched string.\n * Returns an empty array if none are found.\n */\nconst getIndicesByWordList = function( words, text ) {\n\tlet matchedWords = [];\n\n\tforEach( words, function( word ) {\n\t\tword = stripSpaces( word );\n\t\tif ( ! matchWordInSentence( word, text ) ) {\n\t\t\treturn;\n\t\t}\n\t\tmatchedWords = matchedWords.concat( getIndicesByWord( word, text ) );\n\t} );\n\treturn matchedWords;\n};\n\n/**\n * Sorts the array on the index property of each entry.\n *\n * @param {Array} indices The array with indices.\n *\n * @returns {Array} The sorted array with indices.\n */\nconst sortIndices = function( indices ) {\n\treturn indices.sort( function( a, b ) {\n\t\treturn ( a.index - b.index );\n\t} );\n};\n\n/**\n * Filters duplicate entries if the indices overlap.\n *\n * @param {Array} indices The array with indices to be filtered.\n *\n * @returns {Array} The filtered array.\n */\nconst filterIndices = function( indices ) {\n\tindices = sortIndices( indices );\n\tconst filtered = [];\n\tfor ( let i = 0; i < indices.length; i++ ) {\n\t\t// If the next index is within the range of the current index and the length of the word, remove it\n\t\t// This makes sure we don't match combinations twice, like \"even though\" and \"though\".\n\t\tif ( ! isUndefined( indices[ i + 1 ] ) && indices[ i + 1 ].index < indices[ i ].index + indices[ i ].match.length ) {\n\t\t\tfiltered.push( indices[ i ] );\n\n\t\t\t// Adds 1 to i, so we skip the next index that is overlapping with the current index.\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tfiltered.push( indices[ i ] );\n\t}\n\treturn filtered;\n};\n\n/**\n * Matches string with an array, returns the word and the index it was found on, and sorts the match instances based on\n * the index property of the match.\n *\n * @param {Array} words The array with strings to match.\n * @param {string} text The text to match the strings from the array to.\n *\n * @returns {Array} The array with words, containing the index of the match and the matched string.\n * Returns an empty array if none are found.\n */\nconst getIndicesByWordListSorted = function( words, text ) {\n\tlet matchedWords = [];\n\n\tforEach( words, function( word ) {\n\t\tword = stripSpaces( word );\n\t\tif ( ! matchWordInSentence( word, text ) ) {\n\t\t\treturn matchedWords;\n\t\t}\n\t\tmatchedWords = matchedWords.concat( getIndicesByWord( word, text ) );\n\t} );\n\n\tmatchedWords = matchedWords.sort( function( a, b ) {\n\t\tif ( a.index < b.index ) {\n\t\t\treturn -1;\n\t\t}\n\t\tif ( a.index > b.index ) {\n\t\t\treturn 1;\n\t\t}\n\t\treturn 0;\n\t} );\n\n\treturn matchedWords;\n};\n\nexport {\n\tgetIndicesByWord,\n\tgetIndicesByWordList,\n\tfilterIndices,\n\tsortIndices,\n\tgetIndicesByWordListSorted,\n};\n\nexport default {\n\tgetIndicesByWord,\n\tgetIndicesByWordList,\n\tfilterIndices,\n\tsortIndices,\n\tgetIndicesByWordListSorted,\n};\n"],"mappings":"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","ignoreList":[]}