axyseo 2.1.12 → 2.1.13

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"markWordsInSentences.js","names":["matchWords","arrayToRegex","addMark","Mark","escapeRegExp","getAnchorsFromText","SINGLE_QUOTES_ARRAY","SINGLE_QUOTES_REGEX","anchorDeconstructionRegex","deConstructAnchor","anchor","openTag","content","match","reConstructAnchor","getMarkedAnchors","sentence","wordsRegex","anchors","markedAnchors","map","markedAnchorText","replace","x","collectMarkingsInSentence","wordsFoundInSentence","matchWordCustomHelper","allWordsFound","forEach","word","matchedSingleQuotes","singleQuote","matchedSingleQuote","push","RegExp","markup","length","markupAnchors","i","markWordsInASentence","original","marked","markWordsInSentences","wordsToMark","sentences","locale","markings","matches","concat"],"sources":["../../../../src/languageProcessing/helpers/word/markWordsInSentences.js"],"sourcesContent":["import matchWords from \"../match/matchTextWithArray\";\nimport arrayToRegex from \"../regex/createRegexFromArray\";\nimport addMark from \"../../../markers/addMarkSingleWord\";\nimport Mark from \"../../../values/Mark\";\nimport { escapeRegExp } from \"lodash\";\nimport getAnchorsFromText from \"../link/getAnchorsFromText\";\nimport { SINGLE_QUOTES_ARRAY, SINGLE_QUOTES_REGEX } from \"../sanitize/quotes\";\n\n// Regex to deconstruct an anchor into open tag, content and close tag.\nconst anchorDeconstructionRegex = /(<a[\\s]+[^>]+>)([^]*?)(<\\/a>)/;\n\n/**\n * Deconstructs an anchor to the opening tag and the content. The content is the anchor text.\n * We don't return the closing tag since the value would always be the same, i.e. </a>.\n *\n * @param {string} anchor An anchor of the shape <a ...>...</a>.\n *\n * @returns {object} An object containing the opening tag and the content.\n */\nexport const deConstructAnchor = function( anchor ) {\n\t// The const array mirrors the anchorDeconstructionRegex, using a comma to access the first element without a name.\n\tconst [ , openTag, content ] = anchor.match( anchorDeconstructionRegex );\n\treturn {\n\t\topenTag: openTag,\n\t\tcontent: content,\n\t};\n};\n\n/**\n * Reconstructs an anchor from an openTag, the content, and the closing tag.\n *\n * @param {string} openTag The opening tag of the anchor. Must be of the shape <a ...>.\n * @param {string} content The text of the anchor.\n *\n * @returns {string} An anchor.\n */\nexport const reConstructAnchor = function( openTag, content ) {\n\treturn `${openTag}${content}</a>`;\n};\n\n\n/**\n * Gets the anchors and marks the anchors' text if the words are found in it.\n *\n * @param {string} sentence The sentence to retrieve the anchors from.\n * @param {RegExp} wordsRegex The regex of the words.\n *\n * @returns {Object} The anchors and the marked anchors.\n */\nconst getMarkedAnchors = function( sentence, wordsRegex ) {\n\t// Retrieve the anchors.\n\tconst anchors = getAnchorsFromText( sentence );\n\t// For every anchor, apply the markings only to the anchor tag.\n\tconst markedAnchors = anchors.map( anchor => {\n\t\t// Retrieve the open tag and the content/anchor text.\n\t\tconst { openTag, content } = deConstructAnchor( anchor );\n\n\t\t// Apply the marking to the anchor text if there is a match.\n\t\tconst markedAnchorText = content.replace( wordsRegex, ( x ) => addMark( x ) );\n\n\t\t// Create a new anchor tag with a (marked) anchor text.\n\t\treturn reConstructAnchor( openTag, markedAnchorText );\n\t} );\n\n\treturn { anchors, markedAnchors };\n};\n\n/**\n * Adds marks to a sentence and merges marks if those are only separated by a space\n * (e.g., if highlighting words \"ballet\" and \"shoes\" in a sentence \"I have a lot of ballet shoes and other paraphernalia.\"\n * the marks will be put around \"ballet shoes\" together, not \"`ballet` `shoes`\".)\n *\n * @param {string}    sentence               The sentence to mark words in.\n * @param {[string]}  wordsFoundInSentence   The words to mark in the sentence.\n * @param {function}  matchWordCustomHelper  The language-specific helper function to match word in text.\n *\n * @returns {string} The sentence with marks.\n */\nexport const collectMarkingsInSentence = function( sentence, wordsFoundInSentence, matchWordCustomHelper ) {\n\tconst allWordsFound = [];\n\twordsFoundInSentence.forEach( word => {\n\t\t// Check if the word in `wordsFoundInSentence` contains single quote(s).\n\t\tconst matchedSingleQuotes = word.match( SINGLE_QUOTES_REGEX );\n\t\tif ( matchedSingleQuotes ) {\n\t\t\t/*\n\t\t\t * If yes, make all different combinations of the word with different types of single quotes in the array.\n\t\t\t * Later, a regex will be created for all words that were found in the sentence including their variations.\n\t\t\t *\n\t\t\t * For example:\n\t\t\t * `wordsFoundInSentence`: [ \"red\", \"panda’s\" ]\n\t\t\t * For the word \"panda’s\", we'll create the following variations:\n\t\t\t * \"panda's\", \"panda‘s\", \"panda’s\", \"panda‛s\", \"panda`s\", \"panda‹s\", \"panda›s\"\n\t\t\t * And those variations will be added to `allWordsFound`.\n\t\t\t */\n\t\t\tSINGLE_QUOTES_ARRAY.forEach( singleQuote => {\n\t\t\t\tmatchedSingleQuotes.forEach( matchedSingleQuote => {\n\t\t\t\t\tallWordsFound.push( escapeRegExp( word.replace( new RegExp( matchedSingleQuote, \"g\" ), singleQuote ) ) );\n\t\t\t\t} );\n\t\t\t} );\n\t\t} else {\n\t\t\tallWordsFound.push( escapeRegExp( word ) );\n\t\t}\n\t} );\n\n\t// If a language has a custom helper to match words, we disable the word boundary when creating the regex.\n\tconst wordsRegex = matchWordCustomHelper ? arrayToRegex( allWordsFound, true ) : arrayToRegex( allWordsFound );\n\n\t// Retrieve the anchors and mark the anchors' text if the words are found in the anchors' text.\n\tconst { anchors, markedAnchors } = getMarkedAnchors( sentence, wordsRegex );\n\n\tlet markup = sentence.replace( wordsRegex, function( x ) {\n\t\treturn addMark( x );\n\t} );\n\n\t/**\n\t * In 'markup', we apply the markings also inside the anchor's attribute if there is a match, on top of\n\t * marking the anchor's text.\n\t * The step below is to replace the incorrectly marked anchors with the marked anchors that we want:\n\t * where the markings are only applied in the anchor's text.\n\t */\n\tif ( anchors.length > 0 ) {\n\t\tconst markupAnchors = getAnchorsFromText( markup );\n\t\tfor ( let i = 0; i < markupAnchors.length; i++ ) {\n\t\t\tmarkup = markup.replace( markupAnchors[ i ], markedAnchors[ i ] );\n\t\t}\n\t}\n\n\t/*\n\t * If two marks are separated by only a space, remove the closing tag of the first mark and the opening tag of the\n\t * second mark so that the two marks can be combined into one.\n\t */\n\treturn ( markup.replace( new RegExp( \"</yoastmark> <yoastmark class='yoast-text-mark'>\", \"ig\" ), \" \" ) );\n};\n\n/**\n * Adds marks to a sentence.\n *\n * @param {string}      sentence                The sentence in which we want to apply highlighting.\n * @param {Array}       wordsFoundInSentence    The words to highlight in a sentence.\n * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.\n * @returns {Mark[]}  The array of Mark objects of each sentence.\n */\nexport function markWordsInASentence( sentence, wordsFoundInSentence, matchWordCustomHelper ) {\n\treturn [ new Mark( {\n\t\toriginal: sentence,\n\t\tmarked: collectMarkingsInSentence( sentence, wordsFoundInSentence, matchWordCustomHelper ),\n\t} ) ];\n}\n\n/**\n * Adds marks to an array of sentences.\n *\n * @param {[string]}    wordsToMark The words to mark.\n * @param {[string]}    sentences   The sentences in which to mark these words.\n * @param {string}      locale      The locale.\n * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.\n *\n * @returns {[string]} The sentences with marks.\n */\nexport function markWordsInSentences( wordsToMark, sentences, locale, matchWordCustomHelper ) {\n\tlet wordsFoundInSentence = [];\n\tlet markings = [];\n\n\tsentences.forEach( function( sentence ) {\n\t\twordsFoundInSentence = matchWords( sentence, wordsToMark, locale, matchWordCustomHelper ).matches;\n\n\t\tif ( wordsFoundInSentence.length > 0 ) {\n\t\t\tmarkings = markings.concat( markWordsInASentence( sentence, wordsFoundInSentence, matchWordCustomHelper ) );\n\t\t}\n\t} );\n\n\treturn markings;\n}\n"],"mappings":"AAAA,OAAOA,UAAU;AACjB,OAAOC,YAAY;AACnB,OAAOC,OAAO;AACd,OAAOC,IAAI;AACX,SAASC,YAAY,QAAQ,QAAQ;AACrC,OAAOC,kBAAkB;AACzB,SAASC,mBAAmB,EAAEC,mBAAmB;;AAEjD;AACA,MAAMC,yBAAyB,GAAG,+BAA+B;;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,iBAAiB,GAAG,SAAAA,CAAUC,MAAM,EAAG;EACnD;EACA,MAAM,GAAIC,OAAO,EAAEC,OAAO,CAAE,GAAGF,MAAM,CAACG,KAAK,CAAEL,yBAA0B,CAAC;EACxE,OAAO;IACNG,OAAO,EAAEA,OAAO;IAChBC,OAAO,EAAEA;EACV,CAAC;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,iBAAiB,GAAG,SAAAA,CAAUH,OAAO,EAAEC,OAAO,EAAG;EAC7D,OAAO,GAAGD,OAAO,GAAGC,OAAO,MAAM;AAClC,CAAC;;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,gBAAgB,GAAG,SAAAA,CAAUC,QAAQ,EAAEC,UAAU,EAAG;EACzD;EACA,MAAMC,OAAO,GAAGb,kBAAkB,CAAEW,QAAS,CAAC;EAC9C;EACA,MAAMG,aAAa,GAAGD,OAAO,CAACE,GAAG,CAAEV,MAAM,IAAI;IAC5C;IACA,MAAM;MAAEC,OAAO;MAAEC;IAAQ,CAAC,GAAGH,iBAAiB,CAAEC,MAAO,CAAC;;IAExD;IACA,MAAMW,gBAAgB,GAAGT,OAAO,CAACU,OAAO,CAAEL,UAAU,EAAIM,CAAC,IAAMrB,OAAO,CAAEqB,CAAE,CAAE,CAAC;;IAE7E;IACA,OAAOT,iBAAiB,CAAEH,OAAO,EAAEU,gBAAiB,CAAC;EACtD,CAAE,CAAC;EAEH,OAAO;IAAEH,OAAO;IAAEC;EAAc,CAAC;AAClC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMK,yBAAyB,GAAG,SAAAA,CAAUR,QAAQ,EAAES,oBAAoB,EAAEC,qBAAqB,EAAG;EAC1G,MAAMC,aAAa,GAAG,EAAE;EACxBF,oBAAoB,CAACG,OAAO,CAAEC,IAAI,IAAI;IACrC;IACA,MAAMC,mBAAmB,GAAGD,IAAI,CAAChB,KAAK,CAAEN,mBAAoB,CAAC;IAC7D,IAAKuB,mBAAmB,EAAG;MAC1B;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACGxB,mBAAmB,CAACsB,OAAO,CAAEG,WAAW,IAAI;QAC3CD,mBAAmB,CAACF,OAAO,CAAEI,kBAAkB,IAAI;UAClDL,aAAa,CAACM,IAAI,CAAE7B,YAAY,CAAEyB,IAAI,CAACP,OAAO,CAAE,IAAIY,MAAM,CAAEF,kBAAkB,EAAE,GAAI,CAAC,EAAED,WAAY,CAAE,CAAE,CAAC;QACzG,CAAE,CAAC;MACJ,CAAE,CAAC;IACJ,CAAC,MAAM;MACNJ,aAAa,CAACM,IAAI,CAAE7B,YAAY,CAAEyB,IAAK,CAAE,CAAC;IAC3C;EACD,CAAE,CAAC;;EAEH;EACA,MAAMZ,UAAU,GAAGS,qBAAqB,GAAGzB,YAAY,CAAE0B,aAAa,EAAE,IAAK,CAAC,GAAG1B,YAAY,CAAE0B,aAAc,CAAC;;EAE9G;EACA,MAAM;IAAET,OAAO;IAAEC;EAAc,CAAC,GAAGJ,gBAAgB,CAAEC,QAAQ,EAAEC,UAAW,CAAC;EAE3E,IAAIkB,MAAM,GAAGnB,QAAQ,CAACM,OAAO,CAAEL,UAAU,EAAE,UAAUM,CAAC,EAAG;IACxD,OAAOrB,OAAO,CAAEqB,CAAE,CAAC;EACpB,CAAE,CAAC;;EAEH;AACD;AACA;AACA;AACA;AACA;EACC,IAAKL,OAAO,CAACkB,MAAM,GAAG,CAAC,EAAG;IACzB,MAAMC,aAAa,GAAGhC,kBAAkB,CAAE8B,MAAO,CAAC;IAClD,KAAM,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,aAAa,CAACD,MAAM,EAAEE,CAAC,EAAE,EAAG;MAChDH,MAAM,GAAGA,MAAM,CAACb,OAAO,CAAEe,aAAa,CAAEC,CAAC,CAAE,EAAEnB,aAAa,CAAEmB,CAAC,CAAG,CAAC;IAClE;EACD;;EAEA;AACD;AACA;AACA;EACC,OAASH,MAAM,CAACb,OAAO,CAAE,IAAIY,MAAM,CAAE,kDAAkD,EAAE,IAAK,CAAC,EAAE,GAAI,CAAC;AACvG,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASK,oBAAoBA,CAAEvB,QAAQ,EAAES,oBAAoB,EAAEC,qBAAqB,EAAG;EAC7F,OAAO,CAAE,IAAIvB,IAAI,CAAE;IAClBqC,QAAQ,EAAExB,QAAQ;IAClByB,MAAM,EAAEjB,yBAAyB,CAAER,QAAQ,EAAES,oBAAoB,EAAEC,qBAAsB;EAC1F,CAAE,CAAC,CAAE;AACN;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASgB,oBAAoBA,CAAEC,WAAW,EAAEC,SAAS,EAAEC,MAAM,EAAEnB,qBAAqB,EAAG;EAC7F,IAAID,oBAAoB,GAAG,EAAE;EAC7B,IAAIqB,QAAQ,GAAG,EAAE;EAEjBF,SAAS,CAAChB,OAAO,CAAE,UAAUZ,QAAQ,EAAG;IACvCS,oBAAoB,GAAGzB,UAAU,CAAEgB,QAAQ,EAAE2B,WAAW,EAAEE,MAAM,EAAEnB,qBAAsB,CAAC,CAACqB,OAAO;IAEjG,IAAKtB,oBAAoB,CAACW,MAAM,GAAG,CAAC,EAAG;MACtCU,QAAQ,GAAGA,QAAQ,CAACE,MAAM,CAAET,oBAAoB,CAAEvB,QAAQ,EAAES,oBAAoB,EAAEC,qBAAsB,CAAE,CAAC;IAC5G;EACD,CAAE,CAAC;EAEH,OAAOoB,QAAQ;AAChB","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"matchWordInSentence.js","names":["wordBoundariesFactory","wordBoundaries","escapeRegExp","includes","addWordBoundary","characterInBoundary","character","isWordInSentence","word","sentence","toLocaleLowerCase","wordWithBoundaries","occurrenceStart","search","RegExp","occurrenceEnd","length","previousCharacter","nextCharacter"],"sources":["../../../../src/languageProcessing/helpers/word/matchWordInSentence.js"],"sourcesContent":["import wordBoundariesFactory from \"../../../config/wordBoundaries.js\";\nconst wordBoundaries = wordBoundariesFactory();\nimport { escapeRegExp, includes } from \"lodash\";\nimport addWordBoundary from \"./addWordboundary.js\";\n\n/**\n * Checks whether a character is present in the list of word boundaries.\n *\n * @param {string} character The character to look for.\n * @returns {boolean} Whether or not the character is present in the list of word boundaries.\n */\nconst characterInBoundary = function( character ) {\n\treturn includes( wordBoundaries, character );\n};\n\n/**\n * Checks whether a word is present in a sentence.\n *\n * @param {string} word The word to search for in the sentence.\n * @param {string} sentence The sentence to look through.\n * @returns {boolean} Whether or not the word is present in the sentence.\n */\nconst isWordInSentence = function( word, sentence ) {\n\t// To ensure proper matching, make everything lowercase.\n\tword = word.toLocaleLowerCase();\n\tsentence = sentence.toLocaleLowerCase();\n\n\t// Escape regex in word, since we use regex characters like in abbreviations (\"e.g.\").\n\tconst wordWithBoundaries = addWordBoundary( escapeRegExp( word ) );\n\tlet occurrenceStart = sentence.search( new RegExp( wordWithBoundaries, \"ig\" ) );\n\t// Return false if no match has been found.\n\tif ( occurrenceStart === -1 ) {\n\t\treturn false;\n\t}\n\t/*\n\tIf there is a word boundary before the matched word, the regex includes this word boundary in the match.\n\tThis means that occurrenceStart is the index of the word boundary before the match. Therefore 1 has to\n\tbe added to occurrenceStart, except when there is no word boundary before the match (i.e. at the start\n\tof a sentence).\n\t */\n\tif ( occurrenceStart > 0 ) {\n\t\toccurrenceStart += 1;\n\t}\n\tconst occurrenceEnd = occurrenceStart + word.length;\n\n\t// Check if the previous and next character are word boundaries to determine if a complete word was detected\n\tconst previousCharacter = characterInBoundary( sentence[ occurrenceStart - 1 ] ) || occurrenceStart === 0;\n\tconst nextCharacter = characterInBoundary( sentence[ occurrenceEnd ] ) || occurrenceEnd === sentence.length;\n\n\treturn ( ( previousCharacter ) && ( nextCharacter ) );\n};\n\nexport {\n\tcharacterInBoundary,\n\tisWordInSentence,\n};\n\nexport default {\n\tcharacterInBoundary,\n\tisWordInSentence,\n};\n"],"mappings":"AAAA,OAAOA,qBAAqB;AAC5B,MAAMC,cAAc,GAAGD,qBAAqB,CAAC,CAAC;AAC9C,SAASE,YAAY,EAAEC,QAAQ,QAAQ,QAAQ;AAC/C,OAAOC,eAAe;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,GAAG,SAAAA,CAAUC,SAAS,EAAG;EACjD,OAAOH,QAAQ,CAAEF,cAAc,EAAEK,SAAU,CAAC;AAC7C,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,gBAAgB,GAAG,SAAAA,CAAUC,IAAI,EAAEC,QAAQ,EAAG;EACnD;EACAD,IAAI,GAAGA,IAAI,CAACE,iBAAiB,CAAC,CAAC;EAC/BD,QAAQ,GAAGA,QAAQ,CAACC,iBAAiB,CAAC,CAAC;;EAEvC;EACA,MAAMC,kBAAkB,GAAGP,eAAe,CAAEF,YAAY,CAAEM,IAAK,CAAE,CAAC;EAClE,IAAII,eAAe,GAAGH,QAAQ,CAACI,MAAM,CAAE,IAAIC,MAAM,CAAEH,kBAAkB,EAAE,IAAK,CAAE,CAAC;EAC/E;EACA,IAAKC,eAAe,KAAK,CAAC,CAAC,EAAG;IAC7B,OAAO,KAAK;EACb;EACA;AACD;AACA;AACA;AACA;AACA;EACC,IAAKA,eAAe,GAAG,CAAC,EAAG;IAC1BA,eAAe,IAAI,CAAC;EACrB;EACA,MAAMG,aAAa,GAAGH,eAAe,GAAGJ,IAAI,CAACQ,MAAM;;EAEnD;EACA,MAAMC,iBAAiB,GAAGZ,mBAAmB,CAAEI,QAAQ,CAAEG,eAAe,GAAG,CAAC,CAAG,CAAC,IAAIA,eAAe,KAAK,CAAC;EACzG,MAAMM,aAAa,GAAGb,mBAAmB,CAAEI,QAAQ,CAAEM,aAAa,CAAG,CAAC,IAAIA,aAAa,KAAKN,QAAQ,CAACO,MAAM;EAE3G,OAAWC,iBAAiB,IAAQC,aAAe;AACpD,CAAC;AAED,SACCb,mBAAmB,EACnBE,gBAAgB;AAGjB,eAAe;EACdF,mBAAmB;EACnBE;AACD,CAAC","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"splitIntoTokens.js","names":["createPunctuationTokens","WORD_SEPARATORS_REGEX","splitIntoTokens","text","rawTokens","split","filter","x"],"sources":["../../../../src/languageProcessing/helpers/word/splitIntoTokens.js"],"sourcesContent":["import createPunctuationTokens from \"./createPunctuationTokens\";\n\n/*\n*  The following regex is used to split a text into tokens.\n * The regex matches word separators. A word separator is either a whitespace, a slash, a\n * tab, a non-breaking space, a hyphen, an en-dash or an em-dash.\n * Opening and closing square brackets are added to deal correctly with shortcodes downstream.\n * The regex is used to split a text into tokens.\n * Do not add punctuation marks to this regex, as they are handled separately inside `createPunctuationTokens()`.\n * The word separator explicitly only contains characters that split two words and not a word and a space.\n * - A space is a word separator because it separates two words if it occurs between them. For example: \"foo bar\"\n * - A tab is a word separator because it separates two words if it occurs between them. For example: \"foo\tbar\"\n * - A non-breaking space (u00A0) is a word separator because it separates two words if it occurs between them. For example: \"foo\\u00A0bar\".\n * - An en-dash (u2013), an em-dash (u2014), and a hyphen (u002d) are word separators because they separate two words if they occur between them.\n *   For example: \"foo–bar\".\n * Note that   is added here as #nbsp; -- we transform the & to # to prevent parse5 from converting it to a space and messing up highlighting.\n */\nconst WORD_SEPARATORS_REGEX = /([\\s\\t\\u00A0\\u2013\\u2014\\u002d[\\]]|#nbsp;)/;\n\n/**\n * Tokenizes a text similarly to `getWords`, but in a way that's suitable for the HTML parser.\n * 1. It does not normalize whitespace.\n * This operation is too risky for the HTML parser because it may throw away characters and as a result, the token positions are corrupted.\n * 2. It does not remove punctuation marks but keeps them.\n *\n * This algorithm splits the text by word separators: tokens that are the border between two words.\n * This algorithm separates punctuation marks from words and keeps them as separate tokens.\n * It only splits them off if they appear at the start or the end of a word.\n *\n * @param {string} text The text to tokenize.\n *\n * @returns {string[]} \tAn array of tokens.\n */\nconst splitIntoTokens = ( text ) => {\n\tif ( ! text ) {\n\t\treturn [];\n\t}\n\n\t// Split the sentence string into tokens. Those tokens are unrefined as they may contain punctuation.\n\tconst rawTokens = text.split( WORD_SEPARATORS_REGEX ).filter( x => x !== \"\" );\n\n\t// Remove punctuation from the beginning and end of word tokens, and make them into separate tokens.\n\treturn createPunctuationTokens( rawTokens );\n};\n\nexport default splitIntoTokens;\n"],"mappings":"AAAA,OAAOA,uBAAuB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qBAAqB,GAAG,4CAA4C;;AAE1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,eAAe,GAAKC,IAAI,IAAM;EACnC,IAAK,CAAEA,IAAI,EAAG;IACb,OAAO,EAAE;EACV;;EAEA;EACA,MAAMC,SAAS,GAAGD,IAAI,CAACE,KAAK,CAAEJ,qBAAsB,CAAC,CAACK,MAAM,CAAEC,CAAC,IAAIA,CAAC,KAAK,EAAG,CAAC;;EAE7E;EACA,OAAOP,uBAAuB,CAAEI,SAAU,CAAC;AAC5C,CAAC;AAED,eAAeF,eAAe","ignoreList":[]}

package/build/languageProcessing/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["replaceDiacritics","transliterate","createRegexFromArray","imageInText","stripSpaces","baseStemmer","getWords","AbstractResearcher","flattenSortLength","indices","buildFormRule","createRulesFromArrays","createSingleRuleFromArray","matchRegularParticiples","directPrecedenceException","precedenceException","nonDirectPrecedenceException","findMatchingEndingInArray","regexHelpers","exceptionListHelpers","stemHelpers","values","areWordsInSentence","getClauses","getClausesSplitOnStopWords","stripFullTags","stripHTMLTags","stripBlockTagsAtStartEnd","sanitizeString","unifyAllSpaces","removePunctuation","normalizeHTML","countMetaDescriptionLength","getLanguage","getSentences","getFieldsToMark","normalizeSingle","parseSynonyms","mergeListItems","findWordFormsInString","collectMarkingsInSentence","markWordsInSentences","helpers","researches"],"sources":["../../src/languageProcessing/index.js"],"sourcesContent":["import replaceDiacritics from './helpers/transliterate/replaceDiacritics';\nimport transliterate from './helpers/transliterate/transliterate';\nimport createRegexFromArray from './helpers/regex/createRegexFromArray';\nimport imageInText from './helpers/image/imageInText';\nimport stripSpaces from './helpers/sanitize/stripSpaces';\nimport baseStemmer from './helpers/morphology/baseStemmer';\nimport getWords from './helpers/word/getWords';\nimport AbstractResearcher from './AbstractResearcher';\nimport flattenSortLength from './helpers/morphology/flattenSortLength';\nimport indices from './helpers/word/indices';\nimport buildFormRule from './helpers/morphology/buildFormRule';\nimport createRulesFromArrays, {\n  createSingleRuleFromArray\n} from './helpers/morphology/createRulesFromArrays';\nimport matchRegularParticiples from './helpers/passiveVoice/periphrastic/matchRegularParticiples';\nimport directPrecedenceException from './helpers/passiveVoice/periphrastic/directPrecedenceException';\nimport precedenceException from './helpers/passiveVoice/periphrastic/precedenceException';\nimport nonDirectPrecedenceException from './helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException';\nimport findMatchingEndingInArray from './helpers/morphology/findMatchingEndingInArray';\nimport * as regexHelpers from './helpers/morphology/regexHelpers';\nimport * as exceptionListHelpers from './helpers/morphology/exceptionListHelpers';\nimport * as stemHelpers from './helpers/morphology/stemHelpers';\nimport * as values from './values';\nimport areWordsInSentence from './helpers/word/areWordsInSentence';\nimport getClauses from './helpers/passiveVoice/periphrastic/getClauses';\nimport getClausesSplitOnStopWords from './helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords';\nimport {\n  stripFullTags as stripHTMLTags,\n  stripBlockTagsAtStartEnd\n} from './helpers/sanitize/stripHTMLTags';\nimport sanitizeString from './helpers/sanitize/sanitizeString';\nimport {unifyAllSpaces} from './helpers/sanitize/unifyWhitespace';\nimport removePunctuation from './helpers/sanitize/removePunctuation';\nimport normalizeHTML from './helpers/html/normalizeHTML';\nimport countMetaDescriptionLength from './helpers/word/countMetaDescriptionLength';\nimport getLanguage from './helpers/language/getLanguage';\nimport getSentences from './helpers/sentence/getSentences';\nimport {getFieldsToMark} from './helpers/html/getFieldsToMark';\nimport {normalizeSingle} from './helpers/sanitize/quotes';\nimport parseSynonyms from './helpers/sanitize/parseSynonyms';\nimport {mergeListItems} from './helpers/sanitize/mergeListItems';\nimport {findWordFormsInString} from './helpers/match/findKeywordFormsInString';\nimport {collectMarkingsInSentence, markWordsInSentences} from './helpers/word/markWordsInSentences';\nimport * as helpers from './helpers';\nimport * as researches from './researches';\n\nexport {\n  AbstractResearcher,\n  transliterate,\n  replaceDiacritics,\n  createRegexFromArray,\n  imageInText,\n  stripSpaces,\n  baseStemmer,\n  getWords,\n  flattenSortLength,\n  indices,\n  buildFormRule,\n  createRulesFromArrays,\n  createSingleRuleFromArray,\n  matchRegularParticiples,\n  directPrecedenceException,\n  precedenceException,\n  nonDirectPrecedenceException,\n  findMatchingEndingInArray,\n  regexHelpers,\n  exceptionListHelpers,\n  stemHelpers,\n  areWordsInSentence,\n  values,\n  getClauses,\n  getClausesSplitOnStopWords,\n  stripHTMLTags,\n  stripBlockTagsAtStartEnd,\n  countMetaDescriptionLength,\n  sanitizeString,\n  removePunctuation,\n  getLanguage,\n  getSentences,\n  getFieldsToMark,\n  unifyAllSpaces,\n  normalizeHTML,\n  collectMarkingsInSentence,\n  normalizeSingle,\n  parseSynonyms,\n  mergeListItems,\n  findWordFormsInString,\n  markWordsInSentences,\n  helpers,\n  researches\n};\n"],"mappings":"AAAA,OAAOA,iBAAiB;AACxB,OAAOC,aAAa;AACpB,OAAOC,oBAAoB;AAC3B,OAAOC,WAAW;AAClB,OAAOC,WAAW;AAClB,OAAOC,WAAW;AAClB,OAAOC,QAAQ;AACf,OAAOC,kBAAkB;AACzB,OAAOC,iBAAiB;AACxB,OAAOC,OAAO;AACd,OAAOC,aAAa;AACpB,OAAOC,qBAAqB,IAC1BC,yBAAyB;AAE3B,OAAOC,uBAAuB;AAC9B,OAAOC,yBAAyB;AAChC,OAAOC,mBAAmB;AAC1B,OAAOC,4BAA4B;AACnC,OAAOC,yBAAyB;AAChC,OAAO,KAAKC,YAAY;AACxB,OAAO,KAAKC,oBAAoB;AAChC,OAAO,KAAKC,WAAW;AACvB,OAAO,KAAKC,MAAM;AAClB,OAAOC,kBAAkB;AACzB,OAAOC,UAAU;AACjB,OAAOC,0BAA0B;AACjC,SACEC,aAAa,IAAIC,aAAa,EAC9BC,wBAAwB;AAE1B,OAAOC,cAAc;AACrB,SAAQC,cAAc;AACtB,OAAOC,iBAAiB;AACxB,OAAOC,aAAa;AACpB,OAAOC,0BAA0B;AACjC,OAAOC,WAAW;AAClB,OAAOC,YAAY;AACnB,SAAQC,eAAe;AACvB,SAAQC,eAAe;AACvB,OAAOC,aAAa;AACpB,SAAQC,cAAc;AACtB,SAAQC,qBAAqB;AAC7B,SAAQC,yBAAyB,EAAEC,oBAAoB;AACvD,OAAO,KAAKC,OAAO;AACnB,OAAO,KAAKC,UAAU;AAEtB,SACEpC,kBAAkB,EAClBN,aAAa,EACbD,iBAAiB,EACjBE,oBAAoB,EACpBC,WAAW,EACXC,WAAW,EACXC,WAAW,EACXC,QAAQ,EACRE,iBAAiB,EACjBC,OAAO,EACPC,aAAa,EACbC,qBAAqB,EACrBC,yBAAyB,EACzBC,uBAAuB,EACvBC,yBAAyB,EACzBC,mBAAmB,EACnBC,4BAA4B,EAC5BC,yBAAyB,EACzBC,YAAY,EACZC,oBAAoB,EACpBC,WAAW,EACXE,kBAAkB,EAClBD,MAAM,EACNE,UAAU,EACVC,0BAA0B,EAC1BE,aAAa,EACbC,wBAAwB,EACxBK,0BAA0B,EAC1BJ,cAAc,EACdE,iBAAiB,EACjBG,WAAW,EACXC,YAAY,EACZC,eAAe,EACfN,cAAc,EACdE,aAAa,EACbS,yBAAyB,EACzBJ,eAAe,EACfC,aAAa,EACbC,cAAc,EACdC,qBAAqB,EACrBE,oBAAoB,EACpBC,OAAO,EACPC,UAAU","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Researcher.js","names":["languageProcessing","AbstractResearcher","getStemmer","Researcher","constructor","paper","defaultResearches","getFleschReadingScore","getPassiveVoiceResult","getSentenceBeginnings","findTransitionWords","functionWordsInKeyphrase","Object","assign","config","functionWords","helpers"],"sources":["../../../../src/languageProcessing/languages/_default/Researcher.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {AbstractResearcher} = languageProcessing;\n\n// All helpers\nimport getStemmer from './helpers/getStemmer';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    // Deletes researches that are not available for languages that we haven't supported yet.\n    delete this.defaultResearches.getFleschReadingScore;\n    delete this.defaultResearches.getPassiveVoiceResult;\n    delete this.defaultResearches.getSentenceBeginnings;\n    delete this.defaultResearches.findTransitionWords;\n    delete this.defaultResearches.functionWordsInKeyphrase;\n\n    Object.assign(this.config, {\n      functionWords: []\n    });\n\n    Object.assign(this.helpers, {\n      getStemmer\n    });\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAkB,CAAC,GAAGD,kBAAkB;;AAE/C;AACA,OAAOE,UAAU;;AAEjB;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASF,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEG,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;;IAEZ;IACA,OAAO,IAAI,CAACC,iBAAiB,CAACC,qBAAqB;IACnD,OAAO,IAAI,CAACD,iBAAiB,CAACE,qBAAqB;IACnD,OAAO,IAAI,CAACF,iBAAiB,CAACG,qBAAqB;IACnD,OAAO,IAAI,CAACH,iBAAiB,CAACI,mBAAmB;IACjD,OAAO,IAAI,CAACJ,iBAAiB,CAACK,wBAAwB;IAEtDC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,aAAa,EAAE;IACjB,CAAC,CAAC;IAEFH,MAAM,CAACC,MAAM,CAAC,IAAI,CAACG,OAAO,EAAE;MAC1Bd;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

package/build/languageProcessing/languages/_default/helpers/getStemmer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getStemmer.js","names":["languageProcessing","baseStemmer","getStemmer"],"sources":["../../../../../src/languageProcessing/languages/_default/helpers/getStemmer.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {baseStemmer} = languageProcessing;\n\n/**\n * Returns the stemmer for a researcher.\n *\n * @returns {Function} The stemmer.\n */\nexport default function getStemmer() {\n  return baseStemmer;\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAW,CAAC,GAAGD,kBAAkB;;AAExC;AACA;AACA;AACA;AACA;AACA,eAAe,SAASE,UAAUA,CAAA,EAAG;EACnC,OAAOD,WAAW;AACpB","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Researcher.js","names":["languageProcessing","AbstractResearcher","firstWordExceptions","all","functionWords","transitionWords","twoPartTransitionWords","PREFIXED_FUNCTION_WORDS_REGEX","createBasicWordForms","getStemmer","isPassiveSentence","Researcher","constructor","paper","defaultResearches","getFleschReadingScore","Object","assign","config","language","passiveConstructionType","prefixedFunctionWordsRegex","helpers"],"sources":["../../../../src/languageProcessing/languages/ar/Researcher.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {AbstractResearcher} = languageProcessing;\n\n// All config\nimport firstWordExceptions from './config/firstWordExceptions';\nimport {all as functionWords} from './config/functionWords';\nimport transitionWords from './config/transitionWords';\nimport twoPartTransitionWords from './config/twoPartTransitionWords';\nimport {PREFIXED_FUNCTION_WORDS_REGEX} from './config/prefixedFunctionWords';\n\n// All helpers\nimport {createBasicWordForms} from './helpers/createBasicWordForms';\nimport getStemmer from './helpers/getStemmer';\nimport isPassiveSentence from './helpers/isPassiveSentence';\n\n/**\n * The researcher contains all the researches, helpers, data, and config.\n */\nexport default class Researcher extends AbstractResearcher {\n  /**\n   * Constructor\n   * @param {Paper} paper The Paper object that is needed within the researches.\n   * @constructor\n   */\n  constructor(paper) {\n    super(paper);\n\n    delete this.defaultResearches.getFleschReadingScore;\n\n    Object.assign(this.config, {\n      language: 'ar',\n      passiveConstructionType: 'morphological',\n      firstWordExceptions,\n      functionWords,\n      transitionWords,\n      twoPartTransitionWords,\n      prefixedFunctionWordsRegex: PREFIXED_FUNCTION_WORDS_REGEX\n    });\n\n    Object.assign(this.helpers, {\n      createBasicWordForms,\n      getStemmer,\n      isPassiveSentence\n    });\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC;AAAkB,CAAC,GAAGD,kBAAkB;;AAE/C;AACA,OAAOE,mBAAmB;AAC1B,SAAQC,GAAG,IAAIC,aAAa;AAC5B,OAAOC,eAAe;AACtB,OAAOC,sBAAsB;AAC7B,SAAQC,6BAA6B;;AAErC;AACA,SAAQC,oBAAoB;AAC5B,OAAOC,UAAU;AACjB,OAAOC,iBAAiB;;AAExB;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASV,kBAAkB,CAAC;EACzD;AACF;AACA;AACA;AACA;EACEW,WAAWA,CAACC,KAAK,EAAE;IACjB,KAAK,CAACA,KAAK,CAAC;IAEZ,OAAO,IAAI,CAACC,iBAAiB,CAACC,qBAAqB;IAEnDC,MAAM,CAACC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE;MACzBC,QAAQ,EAAE,IAAI;MACdC,uBAAuB,EAAE,eAAe;MACxClB,mBAAmB;MACnBE,aAAa;MACbC,eAAe;MACfC,sBAAsB;MACtBe,0BAA0B,EAAEd;IAC9B,CAAC,CAAC;IAEFS,MAAM,CAACC,MAAM,CAAC,IAAI,CAACK,OAAO,EAAE;MAC1Bd,oBAAoB;MACpBC,UAAU;MACVC;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"firstWordExceptions.js","names":[],"sources":["../../../../../src/languageProcessing/languages/ar/config/firstWordExceptions.js"],"sourcesContent":["/**\n * Returns an array with exceptions for the sentence beginning researcher.\n * @returns {Array} The array filled with exceptions.\n */\nexport default [\n\t// Articles (those which are not prefixes):\n\t\"قليل\", \"بعض\", \"واحد\",\n\t// Numbers 1-10:\n\t\"واحد\", \"إثنان\", \"ثلاثة\", \"أربعة\", \"خمسة\", \"ستة\", \"سبعة\", \"ثمانية\", \"تسعة\", \"عشرة\",\n\t// Demonstrative pronouns:\n\t\"هذا\", \"هذه\", \"ذلك\", \"تلك\", \"هذين\", \"هذان\", \"هتين\", \"هتان\", \"هؤلا\", \"أولائك\", \"هؤلاء\",\n];\n\n\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA,eAAe;AACd;AACA,MAAM,EAAE,KAAK,EAAE,MAAM;AACrB;AACA,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM;AAClF;AACA,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CACrF","ignoreList":[]}