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

package/src/languageProcessing/researches/findTransitionWords.js

@@ -0,0 +1,123 @@
+import createRegexFromDoubleArray from "../helpers/regex/createRegexFromDoubleArray.js";
+import getSentences from "../helpers/sentence/getSentences.js";
+import { normalizeSingle as normalizeSingleQuotes } from "../helpers/sanitize/quotes.js";
+import { isWordInSentence as matchWordInSentence } from "../helpers/word/matchWordInSentence.js";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+
+import { flattenDeep } from "lodash";
+import { filterShortcodesFromHTML } from "../helpers";
+
+let regexFromDoubleArray = null;
+let regexFromDoubleArrayCacheKey = "";
+
+/**
+ * Memoizes the createRegexFromDoubleArray with the twoPartTransitionWords.
+ *
+ * @param {Array} twoPartTransitionWords The array containing two-part transition words.
+ *
+ * @returns {RegExp} The RegExp to match text with a double array.
+ */
+function getRegexFromDoubleArray( twoPartTransitionWords ) {
+	const cacheKey = flattenDeep( twoPartTransitionWords ).join( "" );
+	if ( regexFromDoubleArrayCacheKey !== cacheKey || regexFromDoubleArray === null ) {
+		regexFromDoubleArrayCacheKey = cacheKey;
+		regexFromDoubleArray = createRegexFromDoubleArray( twoPartTransitionWords );
+	}
+	return regexFromDoubleArray;
+}
+
+/**
+ * Matches the sentence against two part transition words.
+ *
+ * @param {string} sentence The sentence to match against.
+ * @param {Array} twoPartTransitionWords The array containing two-part transition words.
+ * @returns {Array} The found transitional words.
+ */
+const matchTwoPartTransitionWords = function( sentence, twoPartTransitionWords ) {
+	sentence = normalizeSingleQuotes( sentence );
+	const twoPartTransitionWordsRegex = getRegexFromDoubleArray( twoPartTransitionWords );
+	return sentence.match( twoPartTransitionWordsRegex );
+};
+
+/**
+ * Matches the sentence against transition words.
+ *
+ * @param {string} sentence The sentence to match against.
+ * @param {Array} transitionWords The array containing transition words.
+ * @returns {Array} The found transitional words.
+ */
+const matchTransitionWords = function( sentence, transitionWords ) {
+	sentence = normalizeSingleQuotes( sentence );
+	return transitionWords.filter( word => matchWordInSentence( word, sentence ) );
+};
+
+/**
+ * Checks the passed sentences to see if they contain transition words.
+ *
+ * @param {Array} sentences The sentences to match against.
+ * @param {Array} transitionWords The array containing transition words.
+ * @param {Array} twoPartTransitionWords The array containing two part transition words.
+ * @param {function} matchTransitionWordsHelper The language-specific helper function to match transition words in a sentence.
+ *
+ * @returns {Array} Array of sentence objects containing the complete sentence and the transition words.
+ */
+const checkSentencesForTransitionWords = function( sentences, transitionWords, twoPartTransitionWords, matchTransitionWordsHelper ) {
+	const results = [];
+
+	sentences.forEach( sentence => {
+		if ( twoPartTransitionWords ) {
+			const twoPartMatches = matchTwoPartTransitionWords( sentence, twoPartTransitionWords );
+
+			if ( twoPartMatches !== null ) {
+				results.push( {
+					sentence: sentence,
+					transitionWords: twoPartMatches,
+				} );
+
+				return;
+			}
+		}
+
+		const transitionWordMatches = matchTransitionWordsHelper
+			? matchTransitionWordsHelper( sentence, transitionWords )
+			: matchTransitionWords( sentence, transitionWords );
+
+		if ( transitionWordMatches.length !== 0 ) {
+			results.push( {
+				sentence: sentence,
+				transitionWords: transitionWordMatches,
+			} );
+		}
+	} );
+
+	return results;
+};
+
+/**
+ * Checks how many sentences from a text contain at least one transition word or two-part transition word
+ * that are defined in the transition words config and two part transition words config.
+ *
+ * @param {Paper} paper The Paper object to get text from.
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {object} An object with the total number of sentences in the text
+ *                   and the total number of sentences containing one or more transition words.
+ */
+export default function( paper, researcher ) {
+	const matchTransitionWordsHelper = researcher.getHelper( "matchTransitionWordsHelper" );
+	const transitionWords = researcher.getConfig( "transitionWords" );
+	const twoPartTransitionWords = researcher.getConfig( "twoPartTransitionWords" );
+	const memoizedTokenizer = researcher.getHelper( "memoizedTokenizer" );
+
+	let text = paper.getText();
+	text = removeHtmlBlocks( text );
+	text = filterShortcodesFromHTML( text, paper._attributes && paper._attributes.shortcodes );
+	const sentences = getSentences( text, memoizedTokenizer );
+	const sentenceResults = checkSentencesForTransitionWords( sentences, transitionWords, twoPartTransitionWords, matchTransitionWordsHelper );
+
+	return {
+		totalSentences: sentences.length,
+		sentenceResults: sentenceResults,
+		transitionWordSentences: sentenceResults.length,
+	};
+}

package/src/languageProcessing/researches/functionWordsInKeyphrase.js

@@ -0,0 +1,44 @@
+import { filter, includes, isEmpty } from "lodash";
+import getWords from "../helpers/word/getWords";
+import processExactMatchRequest from "../helpers/match/processExactMatchRequest";
+import { WORD_BOUNDARY_WITH_HYPHEN } from "../../config/wordBoundariesWithoutPunctuation";
+
+/**
+ * Checks if the keyphrase contains of function words only.
+ *
+ * @param {object} paper The paper containing the keyword.
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {boolean} Whether the keyphrase contains of content words only.
+ */
+export default function( paper, researcher ) {
+	const functionWords = researcher.getConfig( "functionWords" );
+
+	// A helper to get words from the keyphrase for languages that don't use the default way.
+	const getWordsCustomHelper = researcher.getHelper( "getWordsCustomHelper" );
+	const keyphrase = paper.getKeyword();
+
+	// Return false if there are double quotes around the keyphrase.
+	if ( processExactMatchRequest( keyphrase ).exactMatchRequested ) {
+		return false;
+	}
+
+	/*
+     * We use a word boundary regex that includes whitespaces, en-dashes, and hyphens for all languages.
+     * This means that we also consider keyphrases that consist of function words separated by hyphens (e.g. 'two-year-old')
+     * as containing only function words. Since many hyphenated phrases can also be written without hyphens, this way the
+     * behavior for hyphenated phrases matches the behavior for unhyphenated phrases.
+     * In Indonesian we normally don't want to treat hyphens as word boundaries, but in this case it makes sense because
+     * in Indonesian you can also have function words seperated by hyphens (e.g. 'dua-lima').
+     * As a downside, single function words containing hyphens (e.g. 'vis-à-vis') won't be automatically matched, but we
+     * are solving this by adding each word from such function words as separate entries in the function words lists.
+     */
+	let keyphraseWords = getWordsCustomHelper ? getWordsCustomHelper( keyphrase )
+		: getWords( keyphrase, WORD_BOUNDARY_WITH_HYPHEN );
+
+	keyphraseWords = filter( keyphraseWords, function( word ) {
+		return ( ! includes( functionWords, word.trim().toLocaleLowerCase() ) );
+	} );
+
+	return isEmpty( keyphraseWords );
+}

package/src/languageProcessing/researches/getAnchorsWithKeyphrase.js

@@ -0,0 +1,227 @@
+import { flatten, uniq } from "lodash";
+import filterWordsFromArray from "../helpers/word/filterWordsFromArray";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString";
+import getWords from "../helpers/word/getWords";
+import matchTextWithArray from "../helpers/match/matchTextWithArray";
+import parseSynonyms from "../helpers/sanitize/parseSynonyms";
+import processExactMatchRequest from "../helpers/match/processExactMatchRequest";
+import urlHelper from "../helpers/url/url.js";
+import { WORD_BOUNDARY_WITH_HYPHEN, WORD_BOUNDARY_WITHOUT_HYPHEN } from "../../config/wordBoundariesWithoutPunctuation";
+
+let functionWords = [];
+
+/**
+ * Checks whether the anchor's link is a relative fragment or the same as the site url/domain.
+ * Relative fragment links always point to the page itself.
+ *
+ * @param {String} anchorLink       The link anchor.
+ * @param {String} siteUrlOrDomain  The site URL or domain of the paper.
+ *
+ * @returns {boolean} Whether the anchor's link is a relative fragment or the same as the site url/domain.
+ */
+function isLinkingToSelf( anchorLink, siteUrlOrDomain ) {
+	return Boolean( urlHelper.areEqual( anchorLink, siteUrlOrDomain ) || urlHelper.isRelativeFragmentURL( anchorLink ) );
+}
+
+/**
+ * Gets the anchors whose url is not linking at the current site url/domain.
+ *
+ * @param {Array}   anchors         An array with all anchors from the paper.
+ * @param {String}  siteUrlOrDomain The site URL or domain of the paper.
+ *
+ * @returns {Array} The array of all anchors whose url is not linking at the current site url/domain.
+ */
+function getAnchorsLinkingToSelf( anchors, siteUrlOrDomain ) {
+	const anchorsLinkingToSelf = anchors.map( function( anchor ) {
+		const anchorLink = anchor.attributes.href;
+		// Return false if there is no href attribute.
+		return anchorLink ? isLinkingToSelf( anchorLink, siteUrlOrDomain ) : false;
+	} );
+
+	return  anchors.filter( ( anchor, index ) => ! anchorsLinkingToSelf[ index ] );
+}
+
+/**
+ * Gets the anchors with text that contains all content words of the topic (i.e. keyphrase or synonyms).
+ *
+ * @param {Array}       anchors         An array with all anchors from the paper
+ * @param {Object}      topicForms      The object with topicForms. It contains all forms of the keyphrase and synonyms.
+ * @param {String}      locale          The locale of the paper.
+ * @param {Function}    matchWordCustomHelper The helper function to match word in text.
+ *
+ * @returns {String[]} The array of all anchors with text that contains all content words of the keyphrase or synonyms.
+ */
+function getAnchorsContainingTopic( anchors, topicForms, locale, matchWordCustomHelper ) {
+	const anchorsContainingTopic = anchors.map( function( anchor ) {
+		// Only retrieve the anchor's text. This is because we only use the anchor text for the following check.
+		const anchorText = anchor.innerText();
+		return findTopicFormsInString( topicForms, anchorText, true, locale, matchWordCustomHelper  ).percentWordMatches === 100;
+	} );
+
+	return anchors.filter( ( anchor, index ) => anchorsContainingTopic[ index ] );
+}
+
+/**
+ * Gets the anchors with text that has the same content words as the keyphrase or synonyms.
+ *
+ * @param {Array}       anchors             		An array with all anchors from the paper.
+ * @param {Object}      topicForms          		The object with topicForms. It contains all forms of the keyphrase and synonyms.
+ * @param {string}      locale              		The locale of the paper.
+ * @param {Object}      customHelpers       		An object containing custom helpers.
+ * @param {Object[]}    exactMatchRequest   		An array of objects containing the keyphrase and information on whether
+ * 													the exact match has been requested.
+ * @param {boolean}	 	areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
+ *
+ * @returns {Array} The array of all anchors with text that has the same content words as the keyphrase/synonyms.
+ */
+function getAnchorsWithSameTextAsTopic( anchors, topicForms, locale, customHelpers, exactMatchRequest, areHyphensWordBoundaries  ) {
+	const matchWordCustomHelper = customHelpers.matchWordCustomHelper;
+	const getWordsCustomHelper = customHelpers.getWordsCustomHelper;
+
+	// Prepare keyphrase and synonym forms for comparison with anchors.
+	const keyphraseAndSynonymsWords = [ flatten( topicForms.keyphraseForms ) ];
+	const synonymsForms = topicForms.synonymsForms;
+	synonymsForms.forEach( form => keyphraseAndSynonymsWords.push( flatten( form ) ) );
+
+	// The variable that will save all the anchors with text that has the same content words as the keyphrase/synonyms.
+	const anchorsContainedInTopic = [];
+
+	anchors.forEach( function( currentAnchor ) {
+		const currentAnchorText = currentAnchor.innerText();
+
+		/*
+        * For keyphrase matching, we want to split words on hyphens and en-dashes, except for languages where hyphens shouldn't
+        * be treated as word boundaries. Currently, the latter only applies to Indonesian, where hyphens are used to create plural forms of nouns,
+        * such as "buku-buku" being a plural form of "buku". We want to treat forms like "buku-buku" as one word, so we shouldn't
+        * split words on hyphens in Indonesian.
+        * For languages where hyphens are treated as word boundaries we pass a custom word boundary regex string to the getWords helper
+        * that includes whitespaces, hyphens (u002d), and en-dashes (u2013). Otherwise, we pass a word boundary regex that only includes
+        * whitespaces and en-dashes.
+        */
+		let anchorWords;
+		if ( getWordsCustomHelper ) {
+			anchorWords = uniq( getWordsCustomHelper( currentAnchorText ) );
+		} else if ( areHyphensWordBoundaries ) {
+			anchorWords = uniq( getWords( currentAnchorText, WORD_BOUNDARY_WITH_HYPHEN ) );
+		} else {
+			anchorWords = uniq( getWords( currentAnchorText, WORD_BOUNDARY_WITHOUT_HYPHEN ) );
+		}
+
+		/*
+		 * Filter function words out of the anchor text.
+		 * If the anchor text contains only function words, we keep them.
+		 */
+		const filteredAnchorWords = filterWordsFromArray( anchorWords, functionWords );
+		if ( filteredAnchorWords.length > 0 ) {
+			anchorWords = filteredAnchorWords;
+		}
+
+		exactMatchRequest.forEach( request => {
+			/*
+			 * Check a) if the exact match is requested for the keyphrase, and
+			 * b) if every content word in the anchor text is included in the keyphrase or synonym.
+			 */
+			if ( request.exactMatchRequested &&
+				anchorWords.every( anchorWord => request.keyphrase.includes( anchorWord ) ) ) {
+				anchorsContainedInTopic.push( true );
+			}
+		} );
+
+		// Check if every word in the anchor text is also present in the keyphrase/synonym.
+		for ( let i = 0; i < keyphraseAndSynonymsWords.length; i++ ) {
+			const topicForm =  keyphraseAndSynonymsWords[ i ];
+
+			if ( anchorWords.every( anchorWord => matchTextWithArray( anchorWord, topicForm, locale, matchWordCustomHelper ).count > 0 ) ) {
+				anchorsContainedInTopic.push( true );
+				break;
+			}
+		}
+	} );
+
+	return anchors.filter( ( anchor, index ) => anchorsContainedInTopic[ index ] );
+}
+
+/**
+ * Checks whether the content words of the anchor text are the same as the content words of the keyphrase or synonym.
+ * Also includes different word forms if the morphology is available.
+ *
+ * @param {Paper}       paper       The paper to research.
+ * @param {Researcher}  researcher  The researcher to use.
+ *
+ * @returns {Object} The amount of anchor texts whose content words are the same as the keyphrase or synonyms' content words.
+ */
+export default function( paper, researcher ) {
+	functionWords = researcher.getConfig( "functionWords" );
+
+	const areHyphensWordBoundaries = researcher.getConfig( "areHyphensWordBoundaries" );
+
+	const result = {
+		anchorsWithKeyphrase: [],
+		anchorsWithKeyphraseCount: 0,
+	};
+	// STEP 1.
+	// If the paper's text is empty, return empty result.
+	if ( paper.getText() === "" ) {
+		return result;
+	}
+
+	// STEP 2.
+	const keyphrase = paper.getKeyword();
+	/*
+	 * If no keyphrase is set, return empty result.
+	 * This is a conscious decision where we won't assess the paper if the keyphrase is not set.
+	 * This includes a case where only the synonym is set but not the keyphrase.
+	 */
+	if ( keyphrase === "" ) {
+		return result;
+	}
+	/*
+	 * When the keyphrase is set, also retrieve the synonyms and save them in "topics" array.
+	 * Eventually, the term topics here refers to either keyphrase or synonyms.
+	 */
+	const originalTopics = parseSynonyms( paper.getSynonyms() );
+	originalTopics.push( keyphrase );
+
+	// Retrieve the anchors.
+	let anchors = paper.getTree().findAll( treeNode => treeNode.name === "a" );
+	/*
+	 * We get the site's URL (e.g., https://yoast.com) or domain (e.g., yoast.com) from the paper.
+	 * In case of WordPress, the variable is a URL. In case of Shopify, it is a domain.
+	 */
+	const siteUrlOrDomain = paper.getPermalink();
+
+	// STEP 3.
+	// Get the anchors with urls that are not linking to the current site url/domain.
+	anchors = getAnchorsLinkingToSelf( anchors, siteUrlOrDomain );
+	// If all anchor urls are linking to the current site url/domain, return empty result.
+	if ( anchors.length === 0 ) {
+		return result;
+	}
+
+	const locale = paper.getLocale();
+	const topicForms = researcher.getResearch( "morphology" );
+	const customHelpers = {
+		matchWordCustomHelper: researcher.getHelper( "matchWordCustomHelper" ),
+		getWordsCustomHelper: researcher.getHelper( "getWordsCustomHelper" ),
+	};
+
+	// STEP 4.
+	// Get the anchors with text that contains the keyphrase/synonyms' content words.
+	anchors = getAnchorsContainingTopic( anchors, topicForms, locale, customHelpers.matchWordCustomHelper );
+	// If all anchor texts do not contain the keyphrase/synonyms' content words, return empty result.
+	if ( anchors.length === 0 ) {
+		return result;
+	}
+
+	// STEP 5.
+	// Check if exact match is requested for every topic (keyphrase or synonym).
+	const isExactMatchRequested = originalTopics.map( originalTopic => processExactMatchRequest( originalTopic ) );
+	// Get the anchors with text that has the same content words as the keyphrase/synonyms.
+	anchors = getAnchorsWithSameTextAsTopic( anchors, topicForms, locale, customHelpers, isExactMatchRequested, areHyphensWordBoundaries );
+
+	return {
+		anchorsWithKeyphrase: anchors,
+		anchorsWithKeyphraseCount: anchors.length,
+	};
+}
+

package/src/languageProcessing/researches/getFleschReadingScore.js

@@ -0,0 +1,150 @@
+/** @module analyses/calculateFleschReading */
+
+import stripNumbers from "../helpers/sanitize/stripNumbers.js";
+import countSentences from "../helpers/sentence/countSentences.js";
+import countWords from "../helpers/word/countWords.js";
+import countSyllables from "../helpers/syllables/countSyllables.js";
+import { clamp, inRange } from "lodash";
+
+/**
+ * Calculates an average from a total and an amount
+ *
+ * @param {number} total The total.
+ * @param {number} amount The amount.
+ * @returns {number} The average from the total and the amount.
+ */
+const getAverage = function( total, amount ) {
+	return total / amount;
+};
+
+/**
+ * The Flesch reading ease difficulty.
+ * @readonly
+ * @enum {number}
+ */
+export const DIFFICULTY = {
+	NO_DATA: -1,
+	VERY_EASY: 0,
+	EASY: 1,
+	FAIRLY_EASY: 2,
+	OKAY: 3,
+	FAIRLY_DIFFICULT: 4,
+	DIFFICULT: 5,
+	VERY_DIFFICULT: 6,
+};
+
+/**
+ * Returns the Flesch reading ease difficulty based on the boundaries
+ * defined in the score configuration.
+ *
+ * @param {number} score The Flesch reading ease score.
+ * @param {Object} scoreConfiguration The score configuration.
+ *
+ * @returns {DIFFICULTY} The Flesch reading ease difficulty.
+ */
+function getDifficulty( score, scoreConfiguration ) {
+	if ( score >= scoreConfiguration.borders.veryEasy ) {
+		return DIFFICULTY.VERY_EASY;
+	} else if ( inRange( score, scoreConfiguration.borders.easy, scoreConfiguration.borders.veryEasy ) ) {
+		return DIFFICULTY.EASY;
+	} else if ( inRange( score, scoreConfiguration.borders.fairlyEasy, scoreConfiguration.borders.easy ) ) {
+		return DIFFICULTY.FAIRLY_EASY;
+	} else if ( inRange( score, scoreConfiguration.borders.okay, scoreConfiguration.borders.fairlyEasy ) ) {
+		return DIFFICULTY.OKAY;
+	} else if ( inRange( score, scoreConfiguration.borders.fairlyDifficult, scoreConfiguration.borders.okay ) ) {
+		return DIFFICULTY.FAIRLY_DIFFICULT;
+	} else if ( inRange( score, scoreConfiguration.borders.difficult, scoreConfiguration.borders.fairlyDifficult ) ) {
+		return DIFFICULTY.DIFFICULT;
+	}
+
+	return DIFFICULTY.VERY_DIFFICULT;
+}
+
+/**
+ * Retrieves the scoring configuration defining the boundaries to use to
+ * determine the Flesch reading ease difficulty.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Object} The language specific scoring configuration, or the default configuration if not available.
+ */
+function getConfiguration( researcher ) {
+	const languageSpecificConfig = researcher.getConfig( "fleschReadingEaseScores" );
+	const defaultConfig = {
+		borders: {
+			veryEasy: 90,
+			easy: 80,
+			fairlyEasy: 70,
+			okay: 60,
+			fairlyDifficult: 50,
+			difficult: 30,
+			veryDifficult: 0,
+		},
+		scores: {
+			veryEasy: 9,
+			easy: 9,
+			fairlyEasy: 9,
+			okay: 9,
+			fairlyDifficult: 6,
+			difficult: 3,
+			veryDifficult: 3,
+		},
+	};
+	return languageSpecificConfig ? languageSpecificConfig : defaultConfig;
+}
+
+/**
+ * This calculates the Flesch reading score for a given text.
+ *
+ * @param {Paper}       paper           The paper containing the text.
+ * @param {Researcher}  researcher      The researcher.
+ *
+ * @returns {{ score: number, difficulty: DIFFICULTY }} The Flesch reading score.
+ */
+export default function( paper, researcher ) {
+	const syllables = researcher.getConfig( "syllables" );
+	const memoizedTokenizer = researcher.getHelper( "memoizedTokenizer" );
+	const languageSpecificConfiguration = getConfiguration( researcher );
+
+	let text = paper.getText();
+	if ( text === "" ) {
+		// A score of -1 signals to the code down the line that no valid FRE was calculated.
+		return {
+			score: -1,
+			difficulty: DIFFICULTY.NO_DATA,
+		};
+	}
+
+	text = stripNumbers( text );
+
+	const numberOfSentences = countSentences( text, memoizedTokenizer );
+	const numberOfWords = countWords( text );
+
+	// Do not show the Flesch reading ease when there is not enough data for the FRE to make sense. Also used to prevent division by zero errors.
+	// A score of -1 signals to the code down the line that no valid FRE was calculated.
+	if ( numberOfSentences < 1 || numberOfWords <= 10 ) {
+		return {
+			score: -1,
+			difficulty: DIFFICULTY.NO_DATA,
+		};
+	}
+
+	const numberOfSyllables = countSyllables( text, syllables );
+	const averageWordsPerSentence = getAverage( numberOfWords, numberOfSentences );
+	const syllablesPer100Words = numberOfSyllables * ( 100 / numberOfWords );
+	const statistics = {
+		numberOfSentences,
+		numberOfWords,
+		numberOfSyllables,
+		averageWordsPerSentence,
+		syllablesPer100Words,
+	};
+
+	const getScore = researcher.getHelper( "fleschReadingScore" );
+
+	const score = clamp( getScore( statistics ), 0, 100 );
+
+	const difficulty = getDifficulty( score, languageSpecificConfiguration );
+
+	return { score, difficulty };
+}

package/src/languageProcessing/researches/getKeywordDensity.js

@@ -0,0 +1,44 @@
+import getAllWordsFromTree from "../helpers/word/getAllWordsFromTree";
+
+/**
+ * Calculates the keyphrase density.
+ *
+ * @param {Paper} paper The paper containing keyphrase and text.
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {number} The keyphrase density.
+ */
+export default function getKeyphraseDensity( paper, researcher ) {
+	const getWordsCustomHelper = researcher.getHelper( "getWordsCustomHelper" );
+	let wordCount = 0;
+
+	// If there is a custom getWords helper, use its output for countWords.
+	if ( getWordsCustomHelper ) {
+		wordCount = getWordsCustomHelper( paper.getText() ).length;
+	} else {
+		wordCount = getAllWordsFromTree( paper ).length;
+	}
+
+	if ( wordCount === 0 ) {
+		return 0;
+	}
+
+	const keyphraseCount = researcher.getResearch( "getKeyphraseCount" );
+
+	return ( keyphraseCount.count / wordCount ) * 100;
+}
+
+/**
+ * Calculates the keyphrase density.
+ *
+ * @deprecated Use getKeyphraseDensity instead.
+ *
+ * @param {Paper} paper The paper containing keyphrase and text.
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {number} The keyphrase density.
+ */
+export function getKeywordDensity( paper, researcher ) {
+	console.warn( "This function is deprecated, use getKeyphraseDensity instead." );
+	return getKeyphraseDensity( paper, researcher );
+}

package/src/languageProcessing/researches/getLinkStatistics.js

@@ -0,0 +1,54 @@
+import checkNofollow from "../helpers/link/checkNofollow.js";
+import getAnchors from "../helpers/link/getAnchorsFromText.js";
+import getLinkType from "../helpers/link/getLinkType.js";
+
+/**
+ * Counts the links found in the text.
+ *
+ * @param {Paper} paper The paper object containing text, keyword and url.
+ *
+ * @returns {object} The object containing all linktypes.
+ * total: the total number of links found.
+ * internalTotal: the total number of links that are internal.
+ * internalDofollow: the internal links without a nofollow attribute.
+ * internalNofollow: the internal links with a nofollow attribute.
+ * externalTotal: the total number of links that are external.
+ * externalDofollow: the external links without a nofollow attribute.
+ * externalNofollow: the internal links with a dofollow attribute.
+ * otherTotal: all links that are not HTTP or HTTPS.
+ * otherDofollow: other links without a nofollow attribute.
+ * otherNofollow: other links with a nofollow attribute.
+ */
+export default function( paper ) {
+	const anchors = getAnchors( paper.getText() );
+	/*
+	 * We get the site's URL (e.g., https://yoast.com) or domain (e.g., yoast.com) from the paper.
+	 * In case of WordPress, the variable is a URL. In case of Shopify, it is a domain.
+	 */
+	const siteUrlOrDomain = paper.getPermalink();
+
+	const linkCount = {
+		total: anchors.length,
+		internalTotal: 0,
+		internalDofollow: 0,
+		internalNofollow: 0,
+		externalTotal: 0,
+		externalDofollow: 0,
+		externalNofollow: 0,
+		otherTotal: 0,
+		otherDofollow: 0,
+		otherNofollow: 0,
+	};
+
+	for ( let i = 0; i < anchors.length; i++ ) {
+		const currentAnchor = anchors[ i ];
+
+		const linkType = getLinkType( currentAnchor, siteUrlOrDomain );
+		const linkFollow = checkNofollow( currentAnchor );
+
+		linkCount[ linkType + "Total" ]++;
+		linkCount[ linkType + linkFollow ]++;
+	}
+
+	return linkCount;
+}

package/src/languageProcessing/researches/getLinks.js

@@ -0,0 +1,18 @@
+/** @module analyses/getLinkStatistics */
+
+import getAnchors from "../helpers/link/getAnchorsFromText.js";
+
+import { map } from "lodash";
+import url from "../helpers/url/url.js";
+
+/**
+ * Checks a text for anchors and returns the number found.
+ *
+ * @param {Object} paper The paper to get the text from.
+ * @returns {Array} An array with the anchors
+ */
+export default function( paper ) {
+	const anchors = getAnchors( paper.getText() );
+
+	return map( anchors, url.getFromAnchorTag );
+}