axyseo 2.0.0-alpha.0.0.20 → 2.0.0-alpha.0.0.4

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

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,145 @@
+/**
+ * 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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+/** @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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+/** @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

@@ -0,0 +1,32 @@
+/** @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

@@ -0,0 +1,32 @@
+/** @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

@@ -0,0 +1,101 @@
+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,
+};