axyseo 2.1.11 → 2.1.13

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

@@ -1 +0,0 @@
-{"version":3,"file":"html.js","names":["blockElements","inlineElements","blockElementsRegex","RegExp","join","inlineElementsRegex","blockElementStartRegex","blockElementEndRegex","inlineElementStartRegex","inlineElementEndRegex","otherElementStartRegex","otherElementEndRegex","contentRegex","greaterThanContentRegex","commentRegex","forEach","memoize","core","tokens","htmlBlockTokenizer","createTokenizer","token","push","addRule","isBlockElement","htmlElementName","test","isInlineElement","getBlocks","text","blocks","depth","blockStartTag","currentBlock","blockEndTag","replace","onText","end","i","nextToken","type","src","trim","memoizedGetBlocks"],"sources":["../../../../src/languageProcessing/helpers/html/html.js"],"sourcesContent":["const blockElements = [ \"address\", \"article\", \"aside\", \"blockquote\", \"canvas\", \"dd\", \"div\", \"dl\", \"fieldset\", \"figcaption\",\n\t\"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"header\", \"hgroup\", \"hr\", \"li\", \"main\", \"nav\",\n\t\"noscript\", \"ol\", \"output\", \"p\", \"pre\", \"section\", \"table\", \"tfoot\", \"ul\", \"video\" ];\nconst inlineElements = [ \"b\", \"big\", \"i\", \"small\", \"tt\", \"abbr\", \"acronym\", \"cite\", \"code\", \"dfn\", \"em\", \"kbd\", \"strong\",\n\t\"samp\", \"time\", \"var\", \"a\", \"bdo\", \"br\", \"img\", \"map\", \"object\", \"q\", \"script\", \"span\", \"sub\", \"sup\", \"button\",\n\t\"input\", \"label\", \"select\", \"textarea\" ];\n\nconst blockElementsRegex = new RegExp( \"^(\" + blockElements.join( \"|\" ) + \")$\", \"i\" );\nconst inlineElementsRegex = new RegExp( \"^(\" + inlineElements.join( \"|\" ) + \")$\", \"i\" );\n\nconst blockElementStartRegex = new RegExp( \"^<(\" + blockElements.join( \"|\" ) + \")[^>]*?>$\", \"i\" );\nconst blockElementEndRegex = new RegExp( \"^</(\" + blockElements.join( \"|\" ) + \")[^>]*?>$\", \"i\" );\n\nconst inlineElementStartRegex = new RegExp( \"^<(\" + inlineElements.join( \"|\" ) + \")[^>]*>$\", \"i\" );\nconst inlineElementEndRegex = new RegExp( \"^</(\" + inlineElements.join( \"|\" ) + \")[^>]*>$\", \"i\" );\n\nconst otherElementStartRegex = /^<([^>\\s/]+)[^>]*>$/;\nconst otherElementEndRegex = /^<\\/([^>\\s]+)[^>]*>$/;\n\nconst contentRegex = /^[^<]+$/;\nconst greaterThanContentRegex = /^<[^><]*$/;\n\nconst commentRegex = /<!--(.|[\\r\\n])*?-->/g;\n\nimport { forEach, memoize } from \"lodash\";\nimport core from \"tokenizer2/core\";\n\nlet tokens = [];\nlet htmlBlockTokenizer;\n\n/**\n * Creates a tokenizer to tokenize HTML into blocks.\n *\n * @returns {void}\n */\nfunction createTokenizer() {\n\ttokens = [];\n\n\thtmlBlockTokenizer = core( function( token ) {\n\t\ttokens.push( token );\n\t} );\n\n\thtmlBlockTokenizer.addRule( contentRegex, \"content\" );\n\thtmlBlockTokenizer.addRule( greaterThanContentRegex, \"greater-than-sign-content\" );\n\n\thtmlBlockTokenizer.addRule( blockElementStartRegex, \"block-start\" );\n\thtmlBlockTokenizer.addRule( blockElementEndRegex, \"block-end\" );\n\thtmlBlockTokenizer.addRule( inlineElementStartRegex, \"inline-start\" );\n\thtmlBlockTokenizer.addRule( inlineElementEndRegex, \"inline-end\" );\n\n\thtmlBlockTokenizer.addRule( otherElementStartRegex, \"other-element-start\" );\n\thtmlBlockTokenizer.addRule( otherElementEndRegex, \"other-element-end\" );\n}\n\n/**\n * Returns whether or not the given element name is a block element.\n *\n * @param {string} htmlElementName The name of the HTML element.\n * @returns {boolean} Whether or not it is a block element.\n */\nfunction isBlockElement( htmlElementName ) {\n\treturn blockElementsRegex.test( htmlElementName );\n}\n\n/**\n * Returns whether or not the given element name is an inline element.\n *\n * @param {string} htmlElementName The name of the HTML element.\n * @returns {boolean} Whether or not it is an inline element.\n */\nfunction isInlineElement( htmlElementName ) {\n\treturn inlineElementsRegex.test( htmlElementName );\n}\n\n/**\n * Splits a text into blocks based on HTML block elements.\n *\n * @param {string} text The text to split.\n * @returns {Array} A list of blocks based on HTML block elements.\n */\nfunction getBlocks( text ) {\n\tconst blocks = [];\n\tlet depth = 0,\n\t\tblockStartTag = \"\",\n\t\tcurrentBlock = \"\",\n\t\tblockEndTag = \"\";\n\n\t// Remove all comments because it is very hard to tokenize them.\n\ttext = text.replace( commentRegex, \"\" );\n\n\tcreateTokenizer();\n\thtmlBlockTokenizer.onText( text );\n\thtmlBlockTokenizer.end();\n\n\tforEach( tokens, function( token, i ) {\n\t\tconst nextToken = tokens[ i + 1 ];\n\n\t\tswitch ( token.type ) {\n\t\t\tcase \"content\":\n\t\t\tcase \"greater-than-sign-content\":\n\t\t\tcase \"inline-start\":\n\t\t\tcase \"inline-end\":\n\t\t\tcase \"other-tag\":\n\t\t\tcase \"other-element-start\":\n\t\t\tcase \"other-element-end\":\n\t\t\tcase \"greater than sign\":\n\t\t\t\tif ( ! nextToken || ( depth === 0 && ( nextToken.type === \"block-start\" || nextToken.type === \"block-end\" ) ) ) {\n\t\t\t\t\tcurrentBlock += token.src;\n\n\t\t\t\t\tblocks.push( currentBlock );\n\t\t\t\t\tblockStartTag = \"\";\n\t\t\t\t\tcurrentBlock = \"\";\n\t\t\t\t\tblockEndTag = \"\";\n\t\t\t\t} else {\n\t\t\t\t\tcurrentBlock += token.src;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tcase \"block-start\":\n\t\t\t\tif ( depth !== 0 ) {\n\t\t\t\t\tif ( currentBlock.trim() !== \"\" ) {\n\t\t\t\t\t\tblocks.push( currentBlock );\n\t\t\t\t\t}\n\t\t\t\t\tcurrentBlock = \"\";\n\t\t\t\t\tblockEndTag = \"\";\n\t\t\t\t}\n\n\t\t\t\tdepth++;\n\t\t\t\tblockStartTag = token.src;\n\t\t\t\tbreak;\n\n\t\t\tcase \"block-end\":\n\t\t\t\tdepth--;\n\t\t\t\tblockEndTag = token.src;\n\n\t\t\t\t/*\n\t\t\t\t * We try to match the most deep blocks so discard any other blocks that have been started but not\n\t\t\t\t * finished.\n\t\t\t\t */\n\t\t\t\tif ( \"\" !== blockStartTag && \"\" !== blockEndTag ) {\n\t\t\t\t\tblocks.push( blockStartTag + currentBlock + blockEndTag );\n\t\t\t\t} else if ( \"\" !== currentBlock.trim() ) {\n\t\t\t\t\tblocks.push( currentBlock );\n\t\t\t\t}\n\t\t\t\tblockStartTag = \"\";\n\t\t\t\tcurrentBlock = \"\";\n\t\t\t\tblockEndTag = \"\";\n\t\t\t\tbreak;\n\t\t}\n\n\t\t// Handles HTML with too many closing tags.\n\t\tif ( depth < 0 ) {\n\t\t\tdepth = 0;\n\t\t}\n\t} );\n\n\treturn blocks;\n}\n\nconst memoizedGetBlocks = memoize( getBlocks );\n\nexport {\n\tblockElements,\n\tinlineElements,\n\tisBlockElement,\n\tisInlineElement,\n\tmemoizedGetBlocks as getBlocks,\n};\n\nexport default {\n\tblockElements: blockElements,\n\tinlineElements: inlineElements,\n\tisBlockElement: isBlockElement,\n\tisInlineElement: isInlineElement,\n\tgetBlocks: memoizedGetBlocks,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/html/htmlParser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"htmlParser.js","names":["htmlparser","textArray","inIgnorableBlock","ignoreStack","IGNORED_TAGS","IGNORED_CLASSES","parser","Parser","onopentag","tagName","nodeValue","push","classNames","class","split","includes","some","className","nodeValueType","Object","keys","nodeValueString","forEach","node","ontext","text","onclosetag","length","pop","decodeEntities","write","parseComplete","join"],"sources":["../../../../src/languageProcessing/helpers/html/htmlParser.js"],"sourcesContent":["/**\n * This file is used for HTML parsing for assessment that not use the HTML Parser.\n * We use a (simpler) external library, which can be found here: https://github.com/fb55/htmlparser2.\n */\nimport htmlparser from \"htmlparser2\";\n\n/**\n * The array containing the text parts without ignored HTML blocks.\n * @type {string[]}\n */\nlet textArray = [];\n/**\n * Whether we are currently in an ignored HTML block.\n * @type {boolean}\n */\nlet inIgnorableBlock = false;\n/**\n * The stack of currently ignored tags, when we are in an ignorable HTML block.\n * @type {string[]}\n */\nlet ignoreStack = [];\n\n/**\n * The HTML tags that should be ignored.\n * @type {string[]}\n */\nconst IGNORED_TAGS = [ \"script\", \"style\", \"code\", \"pre\", \"blockquote\", \"textarea\" ];\n/**\n * The classes of HTML elements that should be ignored.\n * @type {string[]}\n */\nconst IGNORED_CLASSES = [\n\t\"yoast-table-of-contents\",\n\t\"yoast-reading-time__wrapper\",\n\t\"elementor-button-wrapper\",\n\t\"elementor-divider\",\n\t\"elementor-spacer\",\n\t\"elementor-custom-embed\",\n\t\"elementor-icon-wrapper\",\n\t\"elementor-icon-box-wrapper\",\n\t\"elementor-counter\",\n\t\"elementor-progress-wrapper\",\n\t\"elementor-alert\",\n\t\"elementor-soundcloud-wrapper\",\n\t\"elementor-shortcode\",\n\t\"elementor-menu-anchor\",\n\t\"elementor-title\",\n];\n\n/**\n * Parses the text.\n */\nconst parser = new htmlparser.Parser( {\n\t/**\n\t * Handles the opening tag.\n\t * If we are in an ignorable block, disregard the tag.\n\t * If the opening tag is included in the `IGNORED_TAGS` array, or the class is in the `IGNORED_CLASSES` array,\n\t * set `inIgnorableBlock` to true and add the tag to the `ignoreStack`.\n\t * Otherwise, push the tag to the `textArray`.\n\t *\n\t * @param {string} tagName The tag name.\n\t * @param {object} nodeValue The attribute with the keys and values of the tag.\n\t *\n\t * @returns {void}\n\t */\n\tonopentag: function( tagName, nodeValue ) {\n\t\tif ( inIgnorableBlock ) {\n\t\t\tignoreStack.push( tagName );\n\t\t\treturn;\n\t\t}\n\n\t\tconst classNames = nodeValue.class ? nodeValue.class.split( \" \" ) : [];\n\t\tif ( IGNORED_TAGS.includes( tagName ) || classNames.some( className => IGNORED_CLASSES.includes( className ) ) ) {\n\t\t\tinIgnorableBlock = true;\n\t\t\tignoreStack.push( tagName );\n\t\t\treturn;\n\t\t}\n\n\t\tconst nodeValueType = Object.keys( nodeValue );\n\t\tlet nodeValueString = \"\";\n\n\t\tnodeValueType.forEach( function( node ) {\n\t\t\t// Build the tag again.\n\t\t\tnodeValueString += \" \" + node + \"='\" + nodeValue[ node ] + \"'\";\n\t\t} );\n\n\t\ttextArray.push( \"<\" + tagName + nodeValueString + \">\" );\n\t},\n\t/**\n\t * Handles the text that doesn't contain opening or closing tags.\n\t * If `inIgnorableBlock` is false, the text gets pushed to the `textArray` array.\n\t *\n\t * @param {string} text The text that doesn't contain opening or closing tags.\n\t *\n\t * @returns {void}\n\t */\n\tontext: function( text ) {\n\t\tif ( ! inIgnorableBlock ) {\n\t\t\ttextArray.push( text );\n\t\t}\n\t},\n\t/**\n\t * Handles the closing tag.\n\t * If the closing tag is the last tag on the `ignoreStack`, jump out of the ignorable block.\n\t * Otherwise, if we are not currently in an ignorable block, push the tag to the `textArray`.\n\t *\n\t * @param {string} tagName The tag name.\n\t *\n\t * @returns {void}\n\t */\n\tonclosetag: function( tagName ) {\n\t\tif ( ignoreStack.length === 1 && ignoreStack[ 0 ] === tagName ) {\n\t\t\tinIgnorableBlock = false;\n\t\t\tignoreStack = [];\n\t\t\treturn;\n\t\t}\n\n\t\tif ( inIgnorableBlock ) {\n\t\t\tignoreStack.pop();\n\t\t\treturn;\n\t\t}\n\n\t\ttextArray.push( \"</\" + tagName + \">\" );\n\t},\n}, { decodeEntities: true } );\n\n/**\n * Calls htmlparser2 and returns the text without HTML blocks that we do not want to consider for the content analysis.\n * Note that this function will soon be deprecated in favour of our own HTML parser.\n *\n * @param {string} text The text to parse.\n *\n * @returns {string} The text without the HTML blocks.\n */\nexport default function( text ) {\n\t// Return the globals to their starting values.\n\ttextArray = [];\n\tinIgnorableBlock = false;\n\tignoreStack = [];\n\n\tparser.write( text );\n\t// Make sure to complete the process of parsing and reset the parser to avoid side effects.\n\tparser.parseComplete();\n\treturn textArray.join( \"\" );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/html/matchParagraphs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchParagraphs.js","names":["filter","flatMap","map","getBlocks","getParagraphsInTags","text","paragraphs","regex","match","exec","push","paragraph","length","blocks","block","indexOf","split"],"sources":["../../../../src/languageProcessing/helpers/html/matchParagraphs.js"],"sourcesContent":["import { filter, flatMap, map } from \"lodash\";\n\nimport { getBlocks } from \"./html\";\n\n/**\n * Matches the paragraphs in <p>-tags and returns the text in them.\n *\n * @param {string} text The text to match paragraph in.\n *\n * @returns {array} An array containing all paragraphs texts.\n */\nconst getParagraphsInTags = function( text ) {\n\tlet paragraphs = [];\n\t// Matches everything between the <p> and </p> tags.\n\tconst regex = /<p(?:[^>]+)?>(.*?)<\\/p>/ig;\n\tlet match;\n\n\twhile ( ( match = regex.exec( text ) ) !== null ) {\n\t\tparagraphs.push( match );\n\t}\n\n\t// Returns only the text from within the paragraph tags.\n\tparagraphs = map( paragraphs, function( paragraph ) {\n\t\treturn paragraph[ 1 ];\n\t} );\n\n\treturn paragraphs.filter( paragraph => paragraph.length > 0 );\n};\n\n/**\n * Returns an array with all paragraphs from the text.\n *\n * @param {string} text The text to match paragraph in.\n *\n * @returns {Array} The array containing all paragraphs from the text.\n */\nexport default function( text ) {\n\tlet paragraphs = getParagraphsInTags( text );\n\n\tif ( paragraphs.length > 0 ) {\n\t\treturn paragraphs;\n\t}\n\n\t// If no <p> tags found, split on double linebreaks.\n\tlet blocks = getBlocks( text );\n\n\tblocks = filter( blocks, function( block ) {\n\t\t// Match explicit paragraph tags, or if a block has no HTML tags.\n\t\treturn 0 !== block.indexOf( \"<h\" );\n\t} );\n\n\tparagraphs = flatMap( blocks, function( block ) {\n\t\treturn block.split( \"\\n\\n\" );\n\t} );\n\n\tif ( paragraphs.length > 0 ) {\n\t\treturn paragraphs;\n\t}\n\n\t// If no paragraphs are found, return an array containing the entire text.\n\treturn [ text ];\n}\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,OAAO,EAAEC,GAAG,QAAQ,QAAQ;AAE7C,SAASC,SAAS;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,GAAG,SAAAA,CAAUC,IAAI,EAAG;EAC5C,IAAIC,UAAU,GAAG,EAAE;EACnB;EACA,MAAMC,KAAK,GAAG,2BAA2B;EACzC,IAAIC,KAAK;EAET,OAAQ,CAAEA,KAAK,GAAGD,KAAK,CAACE,IAAI,CAAEJ,IAAK,CAAC,MAAO,IAAI,EAAG;IACjDC,UAAU,CAACI,IAAI,CAAEF,KAAM,CAAC;EACzB;;EAEA;EACAF,UAAU,GAAGJ,GAAG,CAAEI,UAAU,EAAE,UAAUK,SAAS,EAAG;IACnD,OAAOA,SAAS,CAAE,CAAC,CAAE;EACtB,CAAE,CAAC;EAEH,OAAOL,UAAU,CAACN,MAAM,CAAEW,SAAS,IAAIA,SAAS,CAACC,MAAM,GAAG,CAAE,CAAC;AAC9D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUP,IAAI,EAAG;EAC/B,IAAIC,UAAU,GAAGF,mBAAmB,CAAEC,IAAK,CAAC;EAE5C,IAAKC,UAAU,CAACM,MAAM,GAAG,CAAC,EAAG;IAC5B,OAAON,UAAU;EAClB;;EAEA;EACA,IAAIO,MAAM,GAAGV,SAAS,CAAEE,IAAK,CAAC;EAE9BQ,MAAM,GAAGb,MAAM,CAAEa,MAAM,EAAE,UAAUC,KAAK,EAAG;IAC1C;IACA,OAAO,CAAC,KAAKA,KAAK,CAACC,OAAO,CAAE,IAAK,CAAC;EACnC,CAAE,CAAC;EAEHT,UAAU,GAAGL,OAAO,CAAEY,MAAM,EAAE,UAAUC,KAAK,EAAG;IAC/C,OAAOA,KAAK,CAACE,KAAK,CAAE,MAAO,CAAC;EAC7B,CAAE,CAAC;EAEH,IAAKV,UAAU,CAACM,MAAM,GAAG,CAAC,EAAG;IAC5B,OAAON,UAAU;EAClB;;EAEA;EACA,OAAO,CAAED,IAAI,CAAE;AAChB","ignoreList":[]}

package/build/languageProcessing/helpers/html/normalizeHTML.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeHTML.js","names":["str","doc","DOMParser","parseFromString","normalizedHTML","body","innerHTML","replace"],"sources":["../../../../src/languageProcessing/helpers/html/normalizeHTML.js"],"sourcesContent":["/**\n * Replaces single quotes around HTML attribute values with double quotes.\n * Double quotes are the standard, but we convert these to single quotes when parsing the HTML in `@axyseo` package.\n * Here, we change them back to double quotes so by parsing the HTML and then outputting it again.\n * Note that this function does more than just replacing single quotes with double quotes. It also restores corrupted HTML.\n * @param {string} str The input string.\n *\n * @returns {string} The string with single quotes around HTML attributes replaced with double quotes.\n */\nexport default function(str) {\n  const doc = new DOMParser().parseFromString(str, 'text/html');\n  const normalizedHTML = doc.body.innerHTML;\n\n  // Replace ` ` with an actual non breaking space (U+00A0).\n  return normalizedHTML.replace(/ /g, '\\u00A0');\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAASA,GAAG,EAAE;EAC3B,MAAMC,GAAG,GAAG,IAAIC,SAAS,CAAC,CAAC,CAACC,eAAe,CAACH,GAAG,EAAE,WAAW,CAAC;EAC7D,MAAMI,cAAc,GAAGH,GAAG,CAACI,IAAI,CAACC,SAAS;;EAEzC;EACA,OAAOF,cAAc,CAACG,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC;AACpD","ignoreList":[]}

package/build/languageProcessing/helpers/image/getAltAttribute.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAltAttribute.js","names":["stripSpaces","imageNode","alt","name","attributes","replace"],"sources":["../../../../src/languageProcessing/helpers/image/getAltAttribute.js"],"sourcesContent":["import stripSpaces from \"../sanitize/stripSpaces.js\";\n\n/**\n * Checks for an alt attribute in the image and returns its content.\n *\n * @param {Node} imageNode Text string to match the alt attribute.\n * @returns {String} The contents of the alt attribute, empty if none is set.\n */\nexport default function( imageNode ) {\n\tlet alt = \"\";\n\n\tif ( imageNode.name === \"img\" ) {\n\t\talt = stripSpaces( imageNode.attributes.alt || \"\" );\n\n\t\talt = alt.replace( /"/g, \"\\\"\" );\n\t\talt = alt.replace( /'/g, \"'\" );\n\t}\n\n\treturn alt;\n}\n"],"mappings":"AAAA,OAAOA,WAAW;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,SAAS,EAAG;EACpC,IAAIC,GAAG,GAAG,EAAE;EAEZ,IAAKD,SAAS,CAACE,IAAI,KAAK,KAAK,EAAG;IAC/BD,GAAG,GAAGF,WAAW,CAAEC,SAAS,CAACG,UAAU,CAACF,GAAG,IAAI,EAAG,CAAC;IAEnDA,GAAG,GAAGA,GAAG,CAACG,OAAO,CAAE,SAAS,EAAE,IAAK,CAAC;IACpCH,GAAG,GAAGA,GAAG,CAACG,OAAO,CAAE,SAAS,EAAE,GAAI,CAAC;EACpC;EAEA,OAAOH,GAAG;AACX","ignoreList":[]}

package/build/languageProcessing/helpers/image/getImagesInTree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getImagesInTree.js","names":["paper","tree","getTree","findAll","node","name"],"sources":["../../../../src/languageProcessing/helpers/image/getImagesInTree.js"],"sourcesContent":["/**\n * Checks the tree for images.\n *\n * @param {Paper}       paper       The paper to check for images.\n *\n * @returns {Array} Array containing all images in the tree\n */\nexport default function( paper ) {\n\tconst tree = paper.getTree();\n\n\tif ( ! tree ) {\n\t\treturn [];\n\t}\n\n\treturn tree.findAll( node => node.name === \"img\" );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,KAAK,EAAG;EAChC,MAAMC,IAAI,GAAGD,KAAK,CAACE,OAAO,CAAC,CAAC;EAE5B,IAAK,CAAED,IAAI,EAAG;IACb,OAAO,EAAE;EACV;EAEA,OAAOA,IAAI,CAACE,OAAO,CAAEC,IAAI,IAAIA,IAAI,CAACC,IAAI,KAAK,KAAM,CAAC;AACnD","ignoreList":[]}

package/build/languageProcessing/helpers/image/imageInText.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"imageInText.js","names":["matchStringWithRegex","imageRegex","RegExp","text"],"sources":["../../../../src/languageProcessing/helpers/image/imageInText.js"],"sourcesContent":["/** @module stringProcessing/imageInText */\n\nimport matchStringWithRegex from \"../regex/matchStringWithRegex.js\";\n\n/**\n * @returns {object} A precompiled regex for recognizing self closing image tags.\n */\nexport const imageRegex = new RegExp( \"<img(?:[^>]+)?>(</img>)*\", \"ig\" );\n\n\n/**\n * Checks the text for images.\n *\n * @param {string} text The text string to check for images\n * @returns {Array} Array containing all types of found images\n */\nexport default function( text ) {\n\treturn matchStringWithRegex( text, imageRegex );\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,oBAAoB;;AAE3B;AACA;AACA;AACA,OAAO,MAAMC,UAAU,GAAG,IAAIC,MAAM,CAAE,0BAA0B,EAAE,IAAK,CAAC;;AAGxE;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOH,oBAAoB,CAAEG,IAAI,EAAEF,UAAW,CAAC;AAChD","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["normalize","createShortcodeTagsRegex","filterShortcodesFromHTML","processExactMatchRequest","removeHtmlBlocks"],"sources":["../../../src/languageProcessing/helpers/index.js"],"sourcesContent":["import { normalize } from \"./sanitize/quotes\";\nimport { createShortcodeTagsRegex, filterShortcodesFromHTML } from \"./sanitize/filterShortcodesFromTree\";\nimport processExactMatchRequest from \"./match/processExactMatchRequest\";\nimport removeHtmlBlocks from \"./html/htmlParser\";\n\nexport {\n\tnormalize,\n\tremoveHtmlBlocks,\n\tfilterShortcodesFromHTML,\n\tcreateShortcodeTagsRegex,\n\tprocessExactMatchRequest,\n};\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,wBAAwB,EAAEC,wBAAwB;AAC3D,OAAOC,wBAAwB;AAC/B,OAAOC,gBAAgB;AAEvB,SACCJ,SAAS,EACTI,gBAAgB,EAChBF,wBAAwB,EACxBD,wBAAwB,EACxBE,wBAAwB","ignoreList":[]}

package/build/languageProcessing/helpers/language/chineseHelperFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chineseHelperFactory.js","names":["isChineseText","createChineseMatchHelper","sentence","word","text","matches","lowerText","toLowerCase","lowerWord","startIndex","index","indexOf","push","length","createChineseUrlMatchHelper","slugText","chineseChar","lowerChar","hasRelevantContent","checkForRelevantContent","chineseToEnglishMap","跨","境","物","流","货","运","输","送","配","仓","储","possibleMatches","some","term","includes","getMatchHelper","keyword","existingHelper","isUrlContext","enhanceResearcherForChinese","researcher","getHelper","enhancedResearcher","Object","create","helpers","matchWordCustomHelper","shouldEnhanceForChinese"],"sources":["../../../../src/languageProcessing/helpers/language/chineseHelperFactory.js"],"sourcesContent":["import isChineseText from './isChineseText.js';\n\n/**\n * Creates a Chinese helper function for matching words in sentences\n * This is used to provide consistent Chinese text processing across all functions\n *\n * @returns {Function} Chinese helper function for matching words\n */\nexport function createChineseMatchHelper() {\n  return function(sentence, word) {\n    const text = typeof sentence === 'string' ? sentence : sentence.text || sentence;\n    const matches = [];\n\n    if (!text || !word) {\n      return matches;\n    }\n\n    const lowerText = text.toLowerCase();\n    const lowerWord = word.toLowerCase();\n\n    let startIndex = 0;\n    let index;\n\n    // Use exact string matching for Chinese text\n    while ((index = lowerText.indexOf(lowerWord, startIndex)) !== -1) {\n      matches.push(word);\n      startIndex = index + lowerWord.length;\n    }\n\n    return matches;\n  };\n}\n\n/**\n * Creates an enhanced Chinese helper function specifically for URL/slug matching\n * This provides better matching logic for Chinese keywords in URL contexts\n *\n * @returns {Function} Enhanced Chinese helper function for URL matching\n */\nexport function createChineseUrlMatchHelper() {\n  return function(slugText, chineseChar) {\n    const text = typeof slugText === 'string' ? slugText : slugText.text || slugText;\n    const matches = [];\n\n    if (!text || !chineseChar) {\n      return matches;\n    }\n\n    const lowerText = text.toLowerCase();\n    const lowerChar = chineseChar.toLowerCase();\n\n    // First, try exact character matching (for Chinese characters in slug)\n    let startIndex = 0;\n    let index;\n    while ((index = lowerText.indexOf(lowerChar, startIndex)) !== -1) {\n      matches.push(chineseChar);\n      startIndex = index + lowerChar.length;\n    }\n\n    // If no exact matches found and we have a Chinese character, try fuzzy matching\n    if (matches.length === 0 && isChineseText(chineseChar)) {\n      // For URL context, be more lenient - if the slug contains any related terms,\n      // we'll consider it a partial match to improve user experience\n      const hasRelevantContent = checkForRelevantContent(lowerText, lowerChar);\n      if (hasRelevantContent) {\n        matches.push(chineseChar);\n      }\n    }\n\n    return matches;\n  };\n}\n\n/**\n * Checks if the slug contains content that might be related to the Chinese character\n * This is a fuzzy matching approach for better URL keyword assessment\n *\n * @param {string} slugText - The slug text to check\n * @param {string} chineseChar - The Chinese character to match\n * @returns {boolean} True if relevant content is found\n */\nfunction checkForRelevantContent(slugText, chineseChar) {\n  // For common Chinese business/logistics terms, provide some fuzzy matching\n  const chineseToEnglishMap = {\n    跨: ['cross', 'trans', 'inter', 'kuà', 'kua', 'kuajing'],\n    境: ['border', 'boundary', 'realm', 'jìng', 'jing', 'kuajing'],\n    物: ['goods', 'item', 'thing', 'material', 'wù', 'wu', 'wuliu'],\n    流: ['flow', 'current', 'logistics', 'liú', 'liu', 'wuliu'],\n    货: ['goods', 'cargo', 'freight', 'huò', 'huo'],\n    运: ['transport', 'shipping', 'yùn', 'yun'],\n    输: ['transport', 'transmit', 'shū', 'shu'],\n    送: ['deliver', 'send', 'sòng', 'song'],\n    配: ['distribute', 'match', 'pèi', 'pei'],\n    仓: ['warehouse', 'storage', 'cāng', 'cang'],\n    储: ['store', 'storage', 'chǔ', 'chu']\n  };\n\n  const possibleMatches = chineseToEnglishMap[chineseChar] || [];\n\n  // Check if slug contains any related terms\n  return possibleMatches.some(term => slugText.includes(term.toLowerCase()));\n}\n\n/**\n * Gets appropriate match helper based on text content\n * Auto-detects Chinese text and returns Chinese helper if needed\n *\n * @param {string} text - Text to analyze\n * @param {string} keyword - Keyword to analyze\n * @param {Function} existingHelper - Existing helper if available\n * @param {boolean} isUrlContext - Whether this is for URL/slug matching\n * @returns {Function|boolean} Appropriate helper function or false\n */\nexport function getMatchHelper(text, keyword, existingHelper, isUrlContext = false) {\n  // If there's already a custom helper, use it\n  if (existingHelper) {\n    return existingHelper;\n  }\n\n  // Auto-detect Chinese and provide appropriate Chinese helper\n  if (isChineseText(keyword + ' ' + text)) {\n    return isUrlContext ? createChineseUrlMatchHelper() : createChineseMatchHelper();\n  }\n\n  // Return false for default behavior with other languages\n  return false;\n}\n\n/**\n * Applies Chinese helper to researcher if Chinese text is detected\n * This is a utility function for updating researchers dynamically\n *\n * @param {Object} researcher - The researcher object to update\n * @param {string} text - Text to analyze\n * @param {string} keyword - Keyword to analyze\n * @param {boolean} isUrlContext - Whether this is for URL/slug matching\n * @returns {Object} Updated researcher object\n */\nexport function enhanceResearcherForChinese(researcher, text, keyword, isUrlContext = false) {\n  if (!researcher.getHelper('matchWordCustomHelper') && isChineseText(keyword + ' ' + text)) {\n    // Clone the researcher to avoid modifying original\n    const enhancedResearcher = Object.create(researcher);\n    enhancedResearcher.helpers = {...researcher.helpers};\n    enhancedResearcher.helpers.matchWordCustomHelper = isUrlContext\n      ? createChineseUrlMatchHelper()\n      : createChineseMatchHelper();\n    return enhancedResearcher;\n  }\n\n  return researcher;\n}\n\n/**\n * Checks if auto-Chinese enhancement should be applied\n *\n * @param {Object} researcher - The researcher object\n * @param {string} text - Text to analyze\n * @param {string} keyword - Keyword to analyze\n * @returns {boolean} True if Chinese enhancement should be applied\n */\nexport function shouldEnhanceForChinese(researcher, text, keyword) {\n  return !researcher.getHelper('matchWordCustomHelper') && isChineseText(keyword + ' ' + text);\n}\n\nexport default {\n  createChineseMatchHelper,\n  createChineseUrlMatchHelper,\n  getMatchHelper,\n  enhanceResearcherForChinese,\n  shouldEnhanceForChinese\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/language/getLanguage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLanguage.js","names":["locale","split"],"sources":["../../../../src/languageProcessing/helpers/language/getLanguage.js"],"sourcesContent":["/**\n * The function getting the language part of the locale.\n *\n * @param {string} locale The locale.\n * @returns {string} The language part of the locale.\n */\nexport default function( locale ) {\n\treturn locale.split( \"_\" )[ 0 ];\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,MAAM,EAAG;EACjC,OAAOA,MAAM,CAACC,KAAK,CAAE,GAAI,CAAC,CAAE,CAAC,CAAE;AAChC","ignoreList":[]}

package/build/languageProcessing/helpers/language/isChineseText.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isChineseText.js","names":["isChineseText","text","chineseCharRegex","test"],"sources":["../../../../src/languageProcessing/helpers/language/isChineseText.js"],"sourcesContent":["/**\n * Checks if the given text contains Chinese characters.\n *\n * @param {string} text The text to check.\n *\n * @returns {boolean} True if the text contains Chinese characters, false otherwise.\n */\nexport default function isChineseText(text) {\n  if (!text || typeof text !== 'string') {\n    return false;\n  }\n\n  // Chinese character range in Unicode\n  const chineseCharRegex = /[\\u4e00-\\u9fff]/;\n\n  return chineseCharRegex.test(text);\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,aAAaA,CAACC,IAAI,EAAE;EAC1C,IAAI,CAACA,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IACrC,OAAO,KAAK;EACd;;EAEA;EACA,MAAMC,gBAAgB,GAAG,iBAAiB;EAE1C,OAAOA,gBAAgB,CAACC,IAAI,CAACF,IAAI,CAAC;AACpC","ignoreList":[]}

package/build/languageProcessing/helpers/link/checkNofollow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkNofollow.js","names":["htmlparser","anchorHTML","linkFollow","parser","Parser","onopentag","tagName","attributes","rel","toLowerCase","split","includes","write","end"],"sources":["../../../../src/languageProcessing/helpers/link/checkNofollow.js"],"sourcesContent":["/** @module stringProcessing/checkNofollow */\n\n// We use an external library, which can be found here: https://github.com/fb55/htmlparser2.\nimport htmlparser from \"htmlparser2\";\n\n/**\n * Checks if a link has a `rel` attribute with a `nofollow` value. If it has, returns Nofollow, otherwise Dofollow.\n *\n * @param {string} anchorHTML The anchor HTML to check against.\n * @returns {string} Returns Dofollow or Nofollow.\n */\nexport default function( anchorHTML ) {\n\tlet linkFollow = \"Dofollow\";\n\n\tconst parser = new htmlparser.Parser( {\n\t\t/**\n\t\t * Detects if there is a `nofollow` value in the `rel` attribute of a link.\n\t\t *\n\t\t * @param {string} tagName The tag name.\n\t\t * @param {object} attributes The tag attributes with the names and values of each attribute found.\n\t\t * @returns {void}\n\t\t */\n\t\tonopentag: function( tagName, attributes ) {\n\t\t\tif ( tagName !== \"a\" || ! attributes.rel ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( attributes.rel.toLowerCase().split( /\\s/ ).includes( \"nofollow\" ) ) {\n\t\t\t\tlinkFollow = \"Nofollow\";\n\t\t\t}\n\t\t},\n\t} );\n\n\tparser.write( anchorHTML );\n\tparser.end();\n\n\treturn linkFollow;\n}\n"],"mappings":"AAAA;;AAEA;AACA,OAAOA,UAAU,MAAM,aAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,UAAU,EAAG;EACrC,IAAIC,UAAU,GAAG,UAAU;EAE3B,MAAMC,MAAM,GAAG,IAAIH,UAAU,CAACI,MAAM,CAAE;IACrC;AACF;AACA;AACA;AACA;AACA;AACA;IACEC,SAAS,EAAE,SAAAA,CAAUC,OAAO,EAAEC,UAAU,EAAG;MAC1C,IAAKD,OAAO,KAAK,GAAG,IAAI,CAAEC,UAAU,CAACC,GAAG,EAAG;QAC1C;MACD;MAEA,IAAKD,UAAU,CAACC,GAAG,CAACC,WAAW,CAAC,CAAC,CAACC,KAAK,CAAE,IAAK,CAAC,CAACC,QAAQ,CAAE,UAAW,CAAC,EAAG;QACxET,UAAU,GAAG,UAAU;MACxB;IACD;EACD,CAAE,CAAC;EAEHC,MAAM,CAACS,KAAK,CAAEX,UAAW,CAAC;EAC1BE,MAAM,CAACU,GAAG,CAAC,CAAC;EAEZ,OAAOX,UAAU;AAClB","ignoreList":[]}

package/build/languageProcessing/helpers/link/getAnchorsFromText.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAnchorsFromText.js","names":["text","matches","match"],"sources":["../../../../src/languageProcessing/helpers/link/getAnchorsFromText.js"],"sourcesContent":["/** @module stringProcessing/getAnchorsFromText */\n\n/**\n * Check for anchors in the text string and returns them in an array.\n *\n * @param {String} text The text to check for matches.\n *\n * @returns {Array} The matched links in text.\n */\nexport default function( text ) {\n\tlet matches;\n\n\t/*\n\t  * Regex matches everything between <a> and </a>.\n\t  *\n\t  * There must be:\n\t  * - at least one whitespace after the starting `<a`, otherwise it matches `<abbr` tags.\n\t  * - followed by at least one not `>`, to match any attributes that are given.\n\t  *   This could be one or zero (`*`), but an anchor tag without an `href` attribute does not make sense.\n\t  *   The regex could be more precise here, by checking for the `href`, but this is less complex.\n\t  * - losing tag of the opening tag `>`.\n\t  * - content of the anchor tag. Any character, including line separators (`[\\n\\r\\u2028\\u2029]`).\n\t  * - the closing anchor tag.\n\t */\n\tmatches = text.match( /<a[\\s]+(?:[^>]+)>((?:.|[\\n\\r\\u2028\\u2029])*?)<\\/a>/ig );\n\n\tif ( matches === null ) {\n\t\tmatches = [];\n\t}\n\n\treturn matches;\n}\n"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAG;EAC/B,IAAIC,OAAO;;EAEX;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACCA,OAAO,GAAGD,IAAI,CAACE,KAAK,CAAE,sDAAuD,CAAC;EAE9E,IAAKD,OAAO,KAAK,IAAI,EAAG;IACvBA,OAAO,GAAG,EAAE;EACb;EAEA,OAAOA,OAAO;AACf","ignoreList":[]}

package/build/languageProcessing/helpers/link/getLinkType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLinkType.js","names":["urlHelper","anchor","siteUrlOrDomain","anchorUrl","getFromAnchorTag","protocol","getProtocol","protocolIsHttpScheme","isRelativeFragmentURL","isInternalLink"],"sources":["../../../../src/languageProcessing/helpers/link/getLinkType.js"],"sourcesContent":["/** @module stringProcess/getLinkType */\n\nimport urlHelper from \"../url/url\";\n\n/**\n * Determines the type of link.\n *\n * @param {string} \tanchor \t\t\t\tString with anchor element.\n * @param {string} \tsiteUrlOrDomain\t\tURL or domain to match against.\n *\n * @returns {string} The link type (other, external or internal).\n */\nexport default function( anchor, siteUrlOrDomain ) {\n\tconst anchorUrl = urlHelper.getFromAnchorTag( anchor );\n\n\t/**\n\t * A link is \"Other\" if:\n\t * - The protocol is neither null, nor http, nor https.\n\t * - The link is a relative fragment URL (starts with #), because it won't navigate to another page.\n\t */\n\tconst protocol = urlHelper.getProtocol( anchorUrl );\n\tif ( protocol && ! urlHelper.protocolIsHttpScheme( protocol ) ||\n\t\turlHelper.isRelativeFragmentURL( anchorUrl ) ) {\n\t\treturn \"other\";\n\t}\n\n\tif ( urlHelper.isInternalLink( anchorUrl, siteUrlOrDomain ) ) {\n\t\treturn \"internal\";\n\t}\n\n\treturn \"external\";\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,SAAS;;AAEhB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,MAAM,EAAEC,eAAe,EAAG;EAClD,MAAMC,SAAS,GAAGH,SAAS,CAACI,gBAAgB,CAAEH,MAAO,CAAC;;EAEtD;AACD;AACA;AACA;AACA;EACC,MAAMI,QAAQ,GAAGL,SAAS,CAACM,WAAW,CAAEH,SAAU,CAAC;EACnD,IAAKE,QAAQ,IAAI,CAAEL,SAAS,CAACO,oBAAoB,CAAEF,QAAS,CAAC,IAC5DL,SAAS,CAACQ,qBAAqB,CAAEL,SAAU,CAAC,EAAG;IAC/C,OAAO,OAAO;EACf;EAEA,IAAKH,SAAS,CAACS,cAAc,CAAEN,SAAS,EAAED,eAAgB,CAAC,EAAG;IAC7D,OAAO,UAAU;EAClB;EAEA,OAAO,UAAU;AAClB","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"findKeywordFormsInString.js","names":["isEmpty","sum","matchTextWithArray","findWordFormsInString","keywordForms","text","locale","matchWordCustomHelper","wordNumber","length","foundWords","Array","positions","matches","i","matchedKeyphrase","count","push","position","concat","foundNumberOfWords","result","countWordMatches","percentWordMatches","Math","round","filter","min","findTopicFormsInString","topicForms","useSynonyms","keyphraseForms","toLowerCase","keyphraseOrSynonym","synonymsForms","resultsSynonyms","synonym","foundSynonyms","map","resultSynonyms","bestSynonymIndex","indexOf","max"],"sources":["../../../../src/languageProcessing/helpers/match/findKeywordFormsInString.js"],"sourcesContent":["import {isEmpty, sum} from 'lodash';\nimport matchTextWithArray from './matchTextWithArray.js';\n\n/**\n * Matches forms of words in the keyphrase against a given text.\n *\n * @param {Array}       keywordForms    The array with word forms of all (content) words from the keyphrase in a shape\n *                                      [ [ form1, form2, ... ], [ form1, form2, ... ] ].\n * @param {string}      text            The string to match the word forms against.\n * @param {string}      locale          The locale of the paper.\n * @param {function}    matchWordCustomHelper The helper function to match word in text.\n *\n * @returns {Object} The number and the percentage of the keyphrase words that were matched in the text by at least one form,\n * and the lowest number of positions of the matches.\n */\nconst findWordFormsInString = function(keywordForms, text, locale, matchWordCustomHelper) {\n  const wordNumber = keywordForms.length;\n  const foundWords = Array(wordNumber);\n  let positions = [];\n  let matches = [];\n\n  for (let i = 0; i < wordNumber; i++) {\n    const matchedKeyphrase = matchTextWithArray(\n      text,\n      keywordForms[i],\n      locale,\n      matchWordCustomHelper\n    );\n    foundWords[i] = matchedKeyphrase.count > 0 ? 1 : 0;\n    positions.push(matchedKeyphrase.position);\n    matches = matches.concat(matchedKeyphrase.matches);\n  }\n  const foundNumberOfWords = sum(foundWords);\n  const result = {\n    countWordMatches: foundNumberOfWords,\n    percentWordMatches: 0,\n    matches: matches\n  };\n\n  if (wordNumber > 0) {\n    result.percentWordMatches = Math.round((foundNumberOfWords / wordNumber) * 100);\n  }\n  // Filtered out negative number, i.e. -1.\n  positions = positions.filter(position => position >= 0);\n  result.position = positions.length === 0 ? -1 : Math.min(...positions);\n\n  return result;\n};\n\n/**\n * Matches forms of words in the keyphrase and in the synonyms against a given text.\n *\n * @param {Object}      topicForms       The object with word forms of all (content) words from the keyphrase and eventually synonyms,\n * comes in a shape {\n *                     keyphraseForms: [[ form1, form2, ... ], [ form1, form2, ... ]],\n *                     synonymsForms: [\n *                          [[ form1, form2, ... ], [ form1, form2, ... ]],\n *                          [[ form1, form2, ... ], [ form1, form2, ... ]],\n *                          [[ form1, form2, ... ], [ form1, form2, ... ]],\n *                     ],\n *                  }\n * @param {string}      text                    The string to match the word forms against.\n * @param {boolean}     useSynonyms             Whether to use synonyms as if it was keyphrase or not (depends on the assessment).\n * @param {string}      locale                  The locale of the paper.\n * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.\n *\n * @returns {Object} The number and the percentage for the keyphrase words or synonyms that were matched in the text by at least one form,\n * and whether the keyphrase or a synonym was matched.\n */\nconst findTopicFormsInString = function(\n  topicForms,\n  text,\n  useSynonyms,\n  locale,\n  matchWordCustomHelper\n) {\n  // First check if the keyword is found in the text\n  let result = findWordFormsInString(\n    topicForms.keyphraseForms,\n    text.toLowerCase(),\n    locale,\n    matchWordCustomHelper\n  );\n  result.keyphraseOrSynonym = 'keyphrase';\n\n  // If a full match found with the keyword or if no synonyms are supplied or supposed to be used, return the keyphrase search result.\n  if (\n    result.percentWordMatches === 100 ||\n    useSynonyms === false ||\n    isEmpty(topicForms.synonymsForms)\n  ) {\n    return result;\n  }\n\n  // Collect results of matching of every synonym with the text.\n  const resultsSynonyms = [];\n  for (let i = 0; i < topicForms.synonymsForms.length; i++) {\n    const synonym = topicForms.synonymsForms[i];\n    resultsSynonyms[i] = findWordFormsInString(\n      synonym,\n      text.toLowerCase(),\n      locale,\n      matchWordCustomHelper\n    );\n  }\n\n  // Find which synonym occurred most fully.\n  const foundSynonyms = resultsSynonyms.map(resultSynonyms => resultSynonyms.percentWordMatches);\n  const bestSynonymIndex = foundSynonyms.indexOf(Math.max(...foundSynonyms));\n\n  // If the best synonym showed lower results than the keyword, return the keyword.\n  if (result.percentWordMatches >= resultsSynonyms[bestSynonymIndex].percentWordMatches) {\n    return result;\n  }\n\n  // If the best synonym showed better results than the keyword, return the synonym.\n  result = resultsSynonyms[bestSynonymIndex];\n  result.keyphraseOrSynonym = 'synonym';\n\n  return result;\n};\n\nexport {findWordFormsInString, findTopicFormsInString};\n"],"mappings":"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","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"isDoubleQuoted.js","names":["doubleQuotes","includes","isDoubleQuoted","keyphrase","length"],"sources":["../../../../src/languageProcessing/helpers/match/isDoubleQuoted.js"],"sourcesContent":["import doubleQuotes from \"../sanitize/doubleQuotes\";\nimport { includes } from \"lodash\";\n\n/**\n * Checks if the keyphrase is double-quoted.\n * @param {string} keyphrase The keyphrase to check.\n * @returns {boolean} Whether the keyphrase is double-quoted.\n */\nconst isDoubleQuoted = ( keyphrase ) => {\n\treturn ( includes( doubleQuotes, keyphrase[ 0 ] ) && includes( doubleQuotes, keyphrase[ keyphrase.length - 1 ] ) );\n};\n\nexport default isDoubleQuoted;\n"],"mappings":"AAAA,OAAOA,YAAY;AACnB,SAASC,QAAQ,QAAQ,QAAQ;;AAEjC;AACA;AACA;AACA;AACA;AACA,MAAMC,cAAc,GAAKC,SAAS,IAAM;EACvC,OAASF,QAAQ,CAAED,YAAY,EAAEG,SAAS,CAAE,CAAC,CAAG,CAAC,IAAIF,QAAQ,CAAED,YAAY,EAAEG,SAAS,CAAEA,SAAS,CAACC,MAAM,GAAG,CAAC,CAAG,CAAC;AACjH,CAAC;AAED,eAAeF,cAAc","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"matchTextWithArray.js","names":["matchTextWithWord","uniq","unique","text","array","locale","matchWordCustomHelper","count","matches","positions","forEach","wordToMatch","occurrence","concat","push","position","filter","length","Math","min"],"sources":["../../../../src/languageProcessing/helpers/match/matchTextWithArray.js"],"sourcesContent":["/** @module stringProcessing/matchTextWithArray */\n\nimport matchTextWithWord from \"./matchTextWithWord\";\nimport { uniq as unique } from \"lodash\";\n\n/**\n * Matches strings from an array against a given text.\n *\n * @param {String}      text                    The text to match.\n * @param {Array}       array                   The array with strings to match.\n * @param {String}      [locale = \"en_EN\"]      The locale of the text to get transliterations.\n * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.\n *\n * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.\n */\nexport default function( text, array, locale = \"en_EN\", matchWordCustomHelper ) {\n\tlet count = 0;\n\tlet matches = [];\n\tlet positions = [];\n\n\tunique( array ).forEach( function( wordToMatch ) {\n\t\tconst occurrence = matchTextWithWord( text, wordToMatch, locale, matchWordCustomHelper );\n\t\tcount += occurrence.count;\n\t\tmatches = matches.concat( occurrence.matches );\n\t\tpositions.push( occurrence.position );\n\t} );\n\n\t// Filtered out negative number, i.e. -1.\n\tpositions = positions.filter( position => position >= 0 );\n\n\treturn {\n\t\tcount: count,\n\t\tmatches: matches,\n\t\tposition: positions.length === 0 ? -1 : Math.min( ...positions ),\n\t};\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,iBAAiB;AACxB,SAASC,IAAI,IAAIC,MAAM,QAAQ,QAAQ;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAEC,KAAK,EAAEC,MAAM,GAAG,OAAO,EAAEC,qBAAqB,EAAG;EAC/E,IAAIC,KAAK,GAAG,CAAC;EACb,IAAIC,OAAO,GAAG,EAAE;EAChB,IAAIC,SAAS,GAAG,EAAE;EAElBP,MAAM,CAAEE,KAAM,CAAC,CAACM,OAAO,CAAE,UAAUC,WAAW,EAAG;IAChD,MAAMC,UAAU,GAAGZ,iBAAiB,CAAEG,IAAI,EAAEQ,WAAW,EAAEN,MAAM,EAAEC,qBAAsB,CAAC;IACxFC,KAAK,IAAIK,UAAU,CAACL,KAAK;IACzBC,OAAO,GAAGA,OAAO,CAACK,MAAM,CAAED,UAAU,CAACJ,OAAQ,CAAC;IAC9CC,SAAS,CAACK,IAAI,CAAEF,UAAU,CAACG,QAAS,CAAC;EACtC,CAAE,CAAC;;EAEH;EACAN,SAAS,GAAGA,SAAS,CAACO,MAAM,CAAED,QAAQ,IAAIA,QAAQ,IAAI,CAAE,CAAC;EAEzD,OAAO;IACNR,KAAK,EAAEA,KAAK;IACZC,OAAO,EAAEA,OAAO;IAChBO,QAAQ,EAAEN,SAAS,CAACQ,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC,GAAGC,IAAI,CAACC,GAAG,CAAE,GAAGV,SAAU;EAChE,CAAC;AACF","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"matchTextWithTransliteration.js","names":["map","addWordBoundary","stripSpaces","transliterate","transliterateWP","replaceTurkishIsMemoized","getLanguage","toRegex","keyword","language","RegExp","text","locale","keywordRegex","turkishMappings","x","join","matches","match","replace","transliterateKeyword","transliterateKeywordRegex","transliterateMatches","combinedArray","concat","transliterateWPKeyword","transliterateWPKeywordRegex","transliterateWPMatches"],"sources":["../../../../src/languageProcessing/helpers/match/matchTextWithTransliteration.js"],"sourcesContent":["import { map } from \"lodash\";\nimport addWordBoundary from \"../word/addWordboundary.js\";\nimport stripSpaces from \"../sanitize/stripSpaces.js\";\nimport transliterate from \"../transliterate/transliterate.js\";\nimport transliterateWP from \"../transliterate/transliterateWPstyle.js\";\nimport { replaceTurkishIsMemoized } from \"../transliterate/specialCharacterMappings\";\nimport { getLanguage } from \"../../index\";\n\n/**\n * Creates a regex from the keyword with included wordboundaries.\n *\n * @param {string} keyword  The keyword to create a regex from.\n * @param {string} language The language used to determine the word boundary.\n *\n * @returns {RegExp} Regular expression of the keyword with word boundaries.\n */\nconst toRegex = function( keyword, language ) {\n\tkeyword = addWordBoundary( keyword, false, \"\", language );\n\treturn new RegExp( keyword, \"ig\" );\n};\n\n/**\n * Matches a string with and without transliteration.\n * @param {string} text The text to match.\n * @param {string} keyword The keyword to match in the text.\n * @param {string} locale The locale used for transliteration.\n * @returns {Array} All matches from the original as the transliterated text and keyword.\n */\nexport default function( text, keyword, locale ) {\n\tconst language = getLanguage( locale );\n\tlet keywordRegex = toRegex( keyword, language );\n\n\tif ( language === \"tr\" ) {\n\t\tconst turkishMappings = replaceTurkishIsMemoized( keyword );\n\t\tkeywordRegex = new RegExp( turkishMappings.map( x => addWordBoundary( x ) ).join( \"|\" ), \"ig\" );\n\t}\n\tconst matches = text.match( keywordRegex ) || [];\n\n\ttext = text.replace( keywordRegex, \"\" );\n\n\tconst transliterateKeyword = transliterate( keyword, locale );\n\tconst transliterateKeywordRegex = toRegex( transliterateKeyword, language );\n\tconst transliterateMatches = text.match( transliterateKeywordRegex ) || [];\n\tlet combinedArray = matches.concat( transliterateMatches );\n\n\tconst transliterateWPKeyword = transliterateWP( keyword, locale );\n\n\tif ( ! ( transliterateWPKeyword === transliterateKeyword ) ) {\n\t\tconst transliterateWPKeywordRegex = toRegex( transliterateWPKeyword, language );\n\t\tconst transliterateWPMatches = text.match( transliterateWPKeywordRegex ) || [];\n\n\t\tcombinedArray = combinedArray.concat( transliterateWPMatches );\n\t}\n\n\treturn map( combinedArray, function( match ) {\n\t\treturn stripSpaces( match );\n\t} );\n}\n"],"mappings":"AAAA,SAASA,GAAG,QAAQ,QAAQ;AAC5B,OAAOC,eAAe;AACtB,OAAOC,WAAW;AAClB,OAAOC,aAAa;AACpB,OAAOC,eAAe;AACtB,SAASC,wBAAwB;AACjC,SAASC,WAAW;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,OAAO,GAAG,SAAAA,CAAUC,OAAO,EAAEC,QAAQ,EAAG;EAC7CD,OAAO,GAAGP,eAAe,CAAEO,OAAO,EAAE,KAAK,EAAE,EAAE,EAAEC,QAAS,CAAC;EACzD,OAAO,IAAIC,MAAM,CAAEF,OAAO,EAAE,IAAK,CAAC;AACnC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUG,IAAI,EAAEH,OAAO,EAAEI,MAAM,EAAG;EAChD,MAAMH,QAAQ,GAAGH,WAAW,CAAEM,MAAO,CAAC;EACtC,IAAIC,YAAY,GAAGN,OAAO,CAAEC,OAAO,EAAEC,QAAS,CAAC;EAE/C,IAAKA,QAAQ,KAAK,IAAI,EAAG;IACxB,MAAMK,eAAe,GAAGT,wBAAwB,CAAEG,OAAQ,CAAC;IAC3DK,YAAY,GAAG,IAAIH,MAAM,CAAEI,eAAe,CAACd,GAAG,CAAEe,CAAC,IAAId,eAAe,CAAEc,CAAE,CAAE,CAAC,CAACC,IAAI,CAAE,GAAI,CAAC,EAAE,IAAK,CAAC;EAChG;EACA,MAAMC,OAAO,GAAGN,IAAI,CAACO,KAAK,CAAEL,YAAa,CAAC,IAAI,EAAE;EAEhDF,IAAI,GAAGA,IAAI,CAACQ,OAAO,CAAEN,YAAY,EAAE,EAAG,CAAC;EAEvC,MAAMO,oBAAoB,GAAGjB,aAAa,CAAEK,OAAO,EAAEI,MAAO,CAAC;EAC7D,MAAMS,yBAAyB,GAAGd,OAAO,CAAEa,oBAAoB,EAAEX,QAAS,CAAC;EAC3E,MAAMa,oBAAoB,GAAGX,IAAI,CAACO,KAAK,CAAEG,yBAA0B,CAAC,IAAI,EAAE;EAC1E,IAAIE,aAAa,GAAGN,OAAO,CAACO,MAAM,CAAEF,oBAAqB,CAAC;EAE1D,MAAMG,sBAAsB,GAAGrB,eAAe,CAAEI,OAAO,EAAEI,MAAO,CAAC;EAEjE,IAAK,EAAIa,sBAAsB,KAAKL,oBAAoB,CAAE,EAAG;IAC5D,MAAMM,2BAA2B,GAAGnB,OAAO,CAAEkB,sBAAsB,EAAEhB,QAAS,CAAC;IAC/E,MAAMkB,sBAAsB,GAAGhB,IAAI,CAACO,KAAK,CAAEQ,2BAA4B,CAAC,IAAI,EAAE;IAE9EH,aAAa,GAAGA,aAAa,CAACC,MAAM,CAAEG,sBAAuB,CAAC;EAC/D;EAEA,OAAO3B,GAAG,CAAEuB,aAAa,EAAE,UAAUL,KAAK,EAAG;IAC5C,OAAOhB,WAAW,CAAEgB,KAAM,CAAC;EAC5B,CAAE,CAAC;AACJ","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"matchTextWithWord.js","names":["stripSomeTags","stripSpaces","removePunctuation","unifyAllSpaces","unifyWhitespace","matchStringWithTransliteration","normalize","normalizeQuotes","map","text","wordToMatch","locale","matchWordCustomHelper","matches","keyword","positions","indexOf","count","length","position","Math","min"],"sources":["../../../../src/languageProcessing/helpers/match/matchTextWithWord.js"],"sourcesContent":["/** @module stringProcessing/matchTextWithWord */\n\nimport stripSomeTags from '../sanitize/stripNonTextTags.js';\nimport stripSpaces from '../sanitize/stripSpaces.js';\nimport removePunctuation from '../sanitize/removePunctuation.js';\nimport {unifyAllSpaces as unifyWhitespace} from '../sanitize/unifyWhitespace.js';\nimport matchStringWithTransliteration from './matchTextWithTransliteration.js';\nimport {normalize as normalizeQuotes} from '../sanitize/quotes.js';\nimport {map} from 'lodash';\n\n/**\n * Returns the number of matches in a given string\n *\n * @param {string}      text                    The text to use for matching the wordToMatch.\n * @param {string}      wordToMatch             The word to match in the text.\n * @param {string}      locale   \t\t\t\tThe locale used for transliteration.\n * @param {function}    matchWordCustomHelper  \tThe helper function to match word in text.\n *\n * @returns {Object} An array with all matches of the text, the number of the matches, and the lowest number of positions of the matches.\n */\nexport default function(text, wordToMatch, locale, matchWordCustomHelper) {\n  text = stripSomeTags(text);\n  text = unifyWhitespace(text);\n  text = normalizeQuotes(text);\n\n  wordToMatch = normalizeQuotes(wordToMatch);\n  let matches = matchWordCustomHelper\n    ? matchWordCustomHelper(text, wordToMatch)\n    : matchStringWithTransliteration(text, wordToMatch, locale);\n  matches = map(matches, function(keyword) {\n    return stripSpaces(removePunctuation(keyword));\n  });\n\n  // Create an array of positions of matches to determine where in the text the wordToMatch occurred first.\n  const positions = map(matches, function(keyword) {\n    return text.indexOf(keyword);\n  });\n\n  return {\n    count: matches.length,\n    matches: matches,\n    position: positions.length === 0 ? -1 : Math.min(...positions)\n  };\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,aAAa;AACpB,OAAOC,WAAW;AAClB,OAAOC,iBAAiB;AACxB,SAAQC,cAAc,IAAIC,eAAe;AACzC,OAAOC,8BAA8B;AACrC,SAAQC,SAAS,IAAIC,eAAe;AACpC,SAAQC,GAAG,QAAO,QAAQ;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAASC,IAAI,EAAEC,WAAW,EAAEC,MAAM,EAAEC,qBAAqB,EAAE;EACxEH,IAAI,GAAGT,aAAa,CAACS,IAAI,CAAC;EAC1BA,IAAI,GAAGL,eAAe,CAACK,IAAI,CAAC;EAC5BA,IAAI,GAAGF,eAAe,CAACE,IAAI,CAAC;EAE5BC,WAAW,GAAGH,eAAe,CAACG,WAAW,CAAC;EAC1C,IAAIG,OAAO,GAAGD,qBAAqB,GAC/BA,qBAAqB,CAACH,IAAI,EAAEC,WAAW,CAAC,GACxCL,8BAA8B,CAACI,IAAI,EAAEC,WAAW,EAAEC,MAAM,CAAC;EAC7DE,OAAO,GAAGL,GAAG,CAACK,OAAO,EAAE,UAASC,OAAO,EAAE;IACvC,OAAOb,WAAW,CAACC,iBAAiB,CAACY,OAAO,CAAC,CAAC;EAChD,CAAC,CAAC;;EAEF;EACA,MAAMC,SAAS,GAAGP,GAAG,CAACK,OAAO,EAAE,UAASC,OAAO,EAAE;IAC/C,OAAOL,IAAI,CAACO,OAAO,CAACF,OAAO,CAAC;EAC9B,CAAC,CAAC;EAEF,OAAO;IACLG,KAAK,EAAEJ,OAAO,CAACK,MAAM;IACrBL,OAAO,EAAEA,OAAO;IAChBM,QAAQ,EAAEJ,SAAS,CAACG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC,GAAGE,IAAI,CAACC,GAAG,CAAC,GAAGN,SAAS;EAC/D,CAAC;AACH","ignoreList":[]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"getClausesSplitOnStopWords.js","names":["forEach","isEmpty","map","stripSpaces","sanitizeMatches","matches","match","splitOnStopWords","sentence","stopwords","clauses","stopword","clause","split","push","startIndex","indexOf","endIndex","length","substring","splitOnStopCharacter","stopCharacter","i","createClauseObjects","options","clauseObjects","foundAuxiliaries","regexes","auxiliaryRegex","Clause","getClausesSplitOnStopWords","stopwordRegex","stopCharacterRegex"],"sources":["../../../../../../src/languageProcessing/helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords.js"],"sourcesContent":["import { forEach, isEmpty, map } from \"lodash\";\n\nimport stripSpaces from \"../../../sanitize/stripSpaces.js\";\n\n/**\n * Strips spaces from the auxiliary matches.\n *\n * @param {Array} matches A list with matches of auxiliaries.\n * @returns {Array} A list with matches with spaces removed.\n */\nfunction sanitizeMatches( matches ) {\n\treturn map( matches, function( match ) {\n\t\treturn stripSpaces( match );\n\t} );\n}\n\n/**\n * Splits sentences into clauses based on stopwords.\n *\n * @param {string} sentence The sentence to split.\n * @param {Array} stopwords The array with matched stopwords.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopWords( sentence, stopwords ) {\n\tconst clauses = [];\n\n\t// Split the sentence on each found stopword and push this part in an array.\n\tforEach( stopwords, function( stopword ) {\n\t\tconst clause = sentence.split( stopword );\n\t\tif ( ! isEmpty( clause[ 0 ] ) ) {\n\t\t\tclauses.push( clause[ 0 ] );\n\t\t}\n\t\tconst startIndex = sentence.indexOf( stopword );\n\t\tconst endIndex = sentence.length;\n\t\tsentence = stripSpaces( sentence.substring( startIndex, endIndex ) );\n\t} );\n\n\t// Push the remainder of the sentence in the clauses array.\n\tclauses.push( sentence );\n\treturn clauses;\n}\n\n/**\n *\n * Splits sentences into clauses based on stopCharacter.\n *\n * @param {string}  sentence        The sentence to split.\n * @param {regex}   stopCharacter   The stop characters regex.\n *\n * @returns {Array} The array with clauses.\n */\nfunction splitOnStopCharacter( sentence, stopCharacter ) {\n\tconst clauses = sentence.split( stopCharacter );\n\n\t// Strip space in the beginning of the clause, if any.\n\tfor ( let i = 0; i < clauses.length; i++ ) {\n\t\tif ( clauses[ i ][ 0 ] === \" \" ) {\n\t\t\tclauses[ i ] = clauses[ i ].substring( 1, clauses[ i ].length );\n\t\t}\n\t}\n\treturn clauses;\n}\n\n/**\n * Creates clauses based on split sentences.\n\n * @param {Array}   clauses   The array with clauses.\n * @param {Object}  options    The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with sentence parts.\n */\nfunction createClauseObjects( clauses, options ) {\n\tconst clauseObjects = [];\n\tforEach( clauses, function( clause ) {\n\t\tconst foundAuxiliaries = sanitizeMatches( clause.match( options.regexes.auxiliaryRegex || [] ) );\n\t\t// If a clause doesn't have an auxiliary, we don't need it, so it can be filtered out.\n\t\tif ( foundAuxiliaries.length !== 0 ) {\n\t\t\tclauseObjects.push( new options.Clause( clause, foundAuxiliaries ) );\n\t\t}\n\t} );\n\treturn clauseObjects;\n}\n\n/**\n * Splits the sentence into clauses based on stopwords.\n *\n * @param {string} sentence The text to split into clauses.\n * @param {Object} options The language-specific regexes and Clause class.\n *\n * @returns {Array} The array with clauses.\n */\nfunction getClausesSplitOnStopWords( sentence, options ) {\n\tconst auxiliaryRegex = options.regexes.auxiliaryRegex;\n\t// First check if there is an auxiliary in the sentence.\n\tif ( sentence.match( auxiliaryRegex ) === null ) {\n\t\treturn [];\n\t}\n\n\tlet clauses;\n\tconst stopwords = sentence.match( options.regexes.stopwordRegex ) || [];\n\t// Split sentences based on stop words\n\tclauses = splitOnStopWords( sentence, stopwords );\n\n\t// \tSplit sentences based on stop characters, only if the regex is available and if the sentence is not yet split from the previous check\n\tif ( typeof( options.regexes.stopCharacterRegex ) !== \"undefined\" && clauses.length === 1 ) {\n\t\tclauses = splitOnStopCharacter( sentence, options.regexes.stopCharacterRegex );\n\t}\n\n\treturn createClauseObjects( clauses, options );\n}\n\nexport default getClausesSplitOnStopWords;\n"],"mappings":"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","ignoreList":[]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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