axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.21

package/src/languageProcessing/helpers/html/html.js

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

package/src/languageProcessing/helpers/html/htmlParser.js

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

package/src/languageProcessing/helpers/html/matchParagraphs.js

@@ -1,62 +0,0 @@
-import { filter, flatMap, map } from "lodash";
-
-import { getBlocks } from "./html";
-
-/**
- * Matches the paragraphs in <p>-tags and returns the text in them.
- *
- * @param {string} text The text to match paragraph in.
- *
- * @returns {array} An array containing all paragraphs texts.
- */
-const getParagraphsInTags = function( text ) {
-	let paragraphs = [];
-	// Matches everything between the <p> and </p> tags.
-	const regex = /<p(?:[^>]+)?>(.*?)<\/p>/ig;
-	let match;
-
-	while ( ( match = regex.exec( text ) ) !== null ) {
-		paragraphs.push( match );
-	}
-
-	// Returns only the text from within the paragraph tags.
-	paragraphs = map( paragraphs, function( paragraph ) {
-		return paragraph[ 1 ];
-	} );
-
-	return paragraphs.filter( paragraph => paragraph.length > 0 );
-};
-
-/**
- * Returns an array with all paragraphs from the text.
- *
- * @param {string} text The text to match paragraph in.
- *
- * @returns {Array} The array containing all paragraphs from the text.
- */
-export default function( text ) {
-	let paragraphs = getParagraphsInTags( text );
-
-	if ( paragraphs.length > 0 ) {
-		return paragraphs;
-	}
-
-	// If no <p> tags found, split on double linebreaks.
-	let blocks = getBlocks( text );
-
-	blocks = filter( blocks, function( block ) {
-		// Match explicit paragraph tags, or if a block has no HTML tags.
-		return 0 !== block.indexOf( "<h" );
-	} );
-
-	paragraphs = flatMap( blocks, function( block ) {
-		return block.split( "\n\n" );
-	} );
-
-	if ( paragraphs.length > 0 ) {
-		return paragraphs;
-	}
-
-	// If no paragraphs are found, return an array containing the entire text.
-	return [ text ];
-}

package/src/languageProcessing/helpers/html/normalizeHTML.js

@@ -1,16 +0,0 @@
-/**
- * Replaces single quotes around HTML attribute values with double quotes.
- * Double quotes are the standard, but we convert these to single quotes when parsing the HTML in `avadaseo` package.
- * Here, we change them back to double quotes so by parsing the HTML and then outputting it again.
- * Note that this function does more than just replacing single quotes with double quotes. It also restores corrupted HTML.
- * @param {string} str The input string.
- *
- * @returns {string} The string with single quotes around HTML attributes replaced with double quotes.
- */
-export default function( str ) {
-	const doc = new DOMParser().parseFromString( str, "text/html" );
-	const normalizedHTML = doc.body.innerHTML;
-
-	// Replace ` ` with an actual non breaking space (U+00A0).
-	return normalizedHTML.replace( / /g, "\u00A0" );
-}

package/src/languageProcessing/helpers/image/getAltAttribute.js

@@ -1,20 +0,0 @@
-import stripSpaces from "../sanitize/stripSpaces.js";
-
-/**
- * Checks for an alt attribute in the image and returns its content.
- *
- * @param {Node} imageNode Text string to match the alt attribute.
- * @returns {String} The contents of the alt attribute, empty if none is set.
- */
-export default function( imageNode ) {
-	let alt = "";
-
-	if ( imageNode.name === "img" ) {
-		alt = stripSpaces( imageNode.attributes.alt || "" );
-
-		alt = alt.replace( /"/g, "\"" );
-		alt = alt.replace( /'/g, "'" );
-	}
-
-	return alt;
-}

package/src/languageProcessing/helpers/image/getImagesInTree.js

@@ -1,16 +0,0 @@
-/**
- * Checks the tree for images.
- *
- * @param {Paper}       paper       The paper to check for images.
- *
- * @returns {Array} Array containing all images in the tree
- */
-export default function( paper ) {
-	const tree = paper.getTree();
-
-	if ( ! tree ) {
-		return [];
-	}
-
-	return tree.findAll( node => node.name === "img" );
-}

package/src/languageProcessing/helpers/image/imageInText.js

@@ -1,19 +0,0 @@
-/** @module stringProcessing/imageInText */
-
-import matchStringWithRegex from "../regex/matchStringWithRegex.js";
-
-/**
- * @returns {object} A precompiled regex for recognizing self closing image tags.
- */
-export const imageRegex = new RegExp( "<img(?:[^>]+)?>(</img>)*", "ig" );
-
-
-/**
- * Checks the text for images.
- *
- * @param {string} text The text string to check for images
- * @returns {Array} Array containing all types of found images
- */
-export default function( text ) {
-	return matchStringWithRegex( text, imageRegex );
-}

package/src/languageProcessing/helpers/index.js

@@ -1,12 +0,0 @@
-import { normalize } from "./sanitize/quotes";
-import { createShortcodeTagsRegex, filterShortcodesFromHTML } from "./sanitize/filterShortcodesFromTree";
-import processExactMatchRequest from "./match/processExactMatchRequest";
-import removeHtmlBlocks from "./html/htmlParser";
-
-export {
-	normalize,
-	removeHtmlBlocks,
-	filterShortcodesFromHTML,
-	createShortcodeTagsRegex,
-	processExactMatchRequest,
-};

package/src/languageProcessing/helpers/language/getLanguage.js

@@ -1,9 +0,0 @@
-/**
- * The function getting the language part of the locale.
- *
- * @param {string} locale The locale.
- * @returns {string} The language part of the locale.
- */
-export default function( locale ) {
-	return locale.split( "_" )[ 0 ];
-}

package/src/languageProcessing/helpers/link/checkNofollow.js

@@ -1,38 +0,0 @@
-/** @module stringProcessing/checkNofollow */
-
-// We use an external library, which can be found here: https://github.com/fb55/htmlparser2.
-import htmlparser from "htmlparser2";
-
-/**
- * Checks if a link has a `rel` attribute with a `nofollow` value. If it has, returns Nofollow, otherwise Dofollow.
- *
- * @param {string} anchorHTML The anchor HTML to check against.
- * @returns {string} Returns Dofollow or Nofollow.
- */
-export default function( anchorHTML ) {
-	let linkFollow = "Dofollow";
-
-	const parser = new htmlparser.Parser( {
-		/**
-		 * Detects if there is a `nofollow` value in the `rel` attribute of a link.
-		 *
-		 * @param {string} tagName The tag name.
-		 * @param {object} attributes The tag attributes with the names and values of each attribute found.
-		 * @returns {void}
-		 */
-		onopentag: function( tagName, attributes ) {
-			if ( tagName !== "a" || ! attributes.rel ) {
-				return;
-			}
-
-			if ( attributes.rel.toLowerCase().split( /\s/ ).includes( "nofollow" ) ) {
-				linkFollow = "Nofollow";
-			}
-		},
-	} );
-
-	parser.write( anchorHTML );
-	parser.end();
-
-	return linkFollow;
-}

package/src/languageProcessing/helpers/link/getAnchorsFromText.js

@@ -1,32 +0,0 @@
-/** @module stringProcessing/getAnchorsFromText */
-
-/**
- * Check for anchors in the text string and returns them in an array.
- *
- * @param {String} text The text to check for matches.
- *
- * @returns {Array} The matched links in text.
- */
-export default function( text ) {
-	let matches;
-
-	/*
-	  * Regex matches everything between <a> and </a>.
-	  *
-	  * There must be:
-	  * - at least one whitespace after the starting `<a`, otherwise it matches `<abbr` tags.
-	  * - followed by at least one not `>`, to match any attributes that are given.
-	  *   This could be one or zero (`*`), but an anchor tag without an `href` attribute does not make sense.
-	  *   The regex could be more precise here, by checking for the `href`, but this is less complex.
-	  * - losing tag of the opening tag `>`.
-	  * - content of the anchor tag. Any character, including line separators (`[\n\r\u2028\u2029]`).
-	  * - the closing anchor tag.
-	 */
-	matches = text.match( /<a[\s]+(?:[^>]+)>((?:.|[\n\r\u2028\u2029])*?)<\/a>/ig );
-
-	if ( matches === null ) {
-		matches = [];
-	}
-
-	return matches;
-}

package/src/languageProcessing/helpers/link/getLinkType.js

@@ -1,32 +0,0 @@
-/** @module stringProcess/getLinkType */
-
-import urlHelper from "../url/url";
-
-/**
- * Determines the type of link.
- *
- * @param {string} 	anchor 				String with anchor element.
- * @param {string} 	siteUrlOrDomain		URL or domain to match against.
- *
- * @returns {string} The link type (other, external or internal).
- */
-export default function( anchor, siteUrlOrDomain ) {
-	const anchorUrl = urlHelper.getFromAnchorTag( anchor );
-
-	/**
-	 * A link is "Other" if:
-	 * - The protocol is neither null, nor http, nor https.
-	 * - The link is a relative fragment URL (starts with #), because it won't navigate to another page.
-	 */
-	const protocol = urlHelper.getProtocol( anchorUrl );
-	if ( protocol && ! urlHelper.protocolIsHttpScheme( protocol ) ||
-		urlHelper.isRelativeFragmentURL( anchorUrl ) ) {
-		return "other";
-	}
-
-	if ( urlHelper.isInternalLink( anchorUrl, siteUrlOrDomain ) ) {
-		return "internal";
-	}
-
-	return "external";
-}

package/src/languageProcessing/helpers/match/findKeywordFormsInString.js

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