axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.5

package/src/languageProcessing/researches/getWordForms.js

@@ -1,204 +0,0 @@
-import { normalizeSingle } from "../helpers/sanitize/quotes";
-import { collectStems, StemOriginalPair } from "../helpers/morphology/buildTopicStems";
-
-import { escapeRegExp, flattenDeep } from "lodash";
-import getAllWordsFromPaper from "../helpers/morphology/getAllWordsFromPaper";
-import parseSynonyms from "../helpers/sanitize/parseSynonyms";
-
-/**
- * A stem with accompanying forms.
- *
- * @param {string}      stem    The word stem.
- * @param {string[]}    forms   The word forms for the stem.
- *
- * @constructor
- */
-function StemWithForms( stem, forms ) {
-	this.stem = stem;
-	this.forms = forms;
-}
-
-/**
- * A result for all topic forms.
- *
- * @param {Array[]} keyphraseForms  All keyphrase forms.
- * @param {Array[]} synonymsForms   All synonym forms.
- * @constructor
- */
-function Result( keyphraseForms = [], synonymsForms = [] ) {
-	this.keyphraseForms = keyphraseForms;
-	this.synonymsForms = synonymsForms;
-}
-
-/**
- * Takes a stem-original pair and returns the accompanying forms for the stem that were found in the paper. Additionally
- * adds a sanitized version of the original word and (for specific languages) creates basic word forms.
- *
- * @param {StemOriginalPair}    stemOriginalPair            The stem-original pair for which to get forms.
- * @param {StemWithForms[]}     paperWordsGroupedByStems    All word forms in the paper grouped by stem.
- * @param {Function|null}       createBasicWordForms        A function to create basic word forms (if available).
- *
- * @returns {string[]} All forms found in the paper for the given stem, plus a sanitized version of the original word.
- */
-function replaceStemWithForms( stemOriginalPair, paperWordsGroupedByStems, createBasicWordForms ) {
-	const matchingStemFormPair = paperWordsGroupedByStems.find( element => element.stem === stemOriginalPair.stem );
-	const originalSanitized = normalizeSingle( escapeRegExp( stemOriginalPair.original ) );
-
-	const forms = matchingStemFormPair
-		? [ originalSanitized, ...matchingStemFormPair.forms ]
-		: [ originalSanitized ];
-
-	// Add extra forms for languages for which we have basic word form support.
-	if ( createBasicWordForms ) {
-		forms.push( ...createBasicWordForms( stemOriginalPair.original ) );
-	}
-
-	/*
-	 * Return original and found or created forms.
-	 * Only return original if no matching forms were found in the text and no forms could be created.
-	 */
-	return [ ... new Set( forms ) ];
-}
-
-/**
- * Extracts the stems from all keyphrase and synonym stems.
- *
- * @param {TopicPhrase}   keyphrase  A topic phrase.
- * @param {TopicPhrase[]} synonyms   An array of topic phrases.
- *
- * @returns {string[]} All word stems of they keyphrase and synonyms.
- */
-function extractStems( keyphrase, synonyms ) {
-	const keyphraseStemsOnly = keyphrase.stemOriginalPairs.length === 0
-		? []
-		: keyphrase.getStems();
-
-	const synonymsStemsOnly = synonyms.length === 0
-		? []
-		: synonyms.map( topicPhrase => topicPhrase.getStems() );
-
-	return ( [ ...keyphraseStemsOnly, ...flattenDeep( synonymsStemsOnly ) ] );
-}
-
-/**
- * Constructs the result with forms for a topic phrase (i.e., a keyphrase or a synonym).
- *
- * @param {TopicPhrase}     topicPhrase              The topic phrase for which to construct the result.
- * @param {StemWithForms[]} paperWordsGroupedByStems All word forms in the paper grouped by stem.
- * @param {Function|null}   createBasicWordForms     A function to create basic word forms (if available).
- *
- * @returns {Array.<string[]>} The word forms for a given topic phrase, grouped by original topic phrase word.
- */
-function constructTopicPhraseResult( topicPhrase, paperWordsGroupedByStems, createBasicWordForms ) {
-	// Empty result for an empty topic phrase.
-	if ( topicPhrase.stemOriginalPairs.length === 0 ) {
-		return [];
-	}
-
-	if ( topicPhrase.exactMatch ) {
-		return [ [ topicPhrase.stemOriginalPairs[ 0 ].stem ] ];
-	}
-
-	return topicPhrase.stemOriginalPairs.map( function( stemOriginalPair ) {
-		return replaceStemWithForms( stemOriginalPair, paperWordsGroupedByStems, createBasicWordForms );
-	} );
-}
-
-/**
- * Gets all matching word forms for the keyphrase and synonyms. Stems are either collected from
- * the paper or, for specific languages, directly created.
- *
- * @param {string}          keyphrase               	The keyphrase.
- * @param {string[]}        synonyms                	The synonyms.
- * @param {string[]}        allWordsFromPaper       	All words found in the paper.
- * @param {string[]}        functionWords           	The function words for a given language (if available).
- * @param {Function|null}   stemmer                 	A stemmer (if available).
- * @param {Function|null}   createBasicWordForms    	A function to create basic word forms (if available).
- * @param {boolean}   		areHyphensWordBoundaries	Whether hyphens should be treated as word boundaries.
-
- * @returns {Object} Object with an array of keyphrase forms and an array of arrays of synonyms forms, based on the forms
- * found in the text or created forms.
- */
-function getWordForms( keyphrase, synonyms, allWordsFromPaper, functionWords, stemmer, createBasicWordForms, areHyphensWordBoundaries ) {
-	const topicPhrases     = collectStems( keyphrase, synonyms, stemmer, functionWords, areHyphensWordBoundaries );
-	const keyphraseStemmed = topicPhrases.keyphraseStems;
-	const synonymsStemmed  = topicPhrases.synonymsStems;
-
-	// Return an empty result when no keyphrase and synonyms have been set.
-	if ( keyphraseStemmed.stemOriginalPairs.length === 0 && synonymsStemmed.length === 0 ) {
-		return new Result();
-	}
-
-	// Return exact match if all topic phrases contain exact match. Forms don't need to be built in that case.
-	const allTopicPhrases = [ keyphraseStemmed, ...synonymsStemmed ];
-
-	if ( allTopicPhrases.every( topicPhrase => topicPhrase.exactMatch === true ) ) {
-		return new Result(
-			[ [ keyphraseStemmed.stemOriginalPairs[ 0 ].stem ] ],
-			synonymsStemmed.map( synonym => [ [ synonym.stemOriginalPairs[ 0 ].stem ] ]
-			)
-		);
-	}
-
-	// Get all stems from the keyphrase and synonyms.
-	const topicStemsFlat = [ ... new Set( extractStems( keyphraseStemmed, synonymsStemmed ) ) ];
-
-	/*
-	 * Get all words from the paper text, title, meta description and slug.
-	 * Filter duplicates and function words.
-	 */
-	const paperWords = [ ... new Set( allWordsFromPaper.filter( word => ! functionWords.includes( word ) ) ) ];
-
-	// Add stems to words from the paper, filter out all forms that aren't in the keyphrase or synonyms and order alphabetically.
-	const paperWordsWithStems = paperWords
-		.map( word => new StemOriginalPair( stemmer( word ), word ) )
-		.filter( stemOriginalPair => topicStemsFlat.includes( stemOriginalPair.stem ) )
-		.sort( ( a, b ) => a.stem.localeCompare( b.stem ) );
-
-	// Group word-stem pairs from the paper by stems.
-	const paperWordsGroupedByStems = paperWordsWithStems.reduce( function( accumulator, stemOriginalPair ) {
-		const lastItem = accumulator[ accumulator.length - 1 ];
-
-		if ( accumulator.length === 0 || lastItem.stem !== stemOriginalPair.stem ) {
-			accumulator.push( new StemWithForms( stemOriginalPair.stem, [ stemOriginalPair.original ] ) );
-		} else {
-			lastItem.forms.push( stemOriginalPair.original );
-		}
-
-		return accumulator;
-	}, [] );
-
-	return new Result(
-		constructTopicPhraseResult( keyphraseStemmed, paperWordsGroupedByStems, createBasicWordForms ),
-		synonymsStemmed.map( synonym => constructTopicPhraseResult( synonym, paperWordsGroupedByStems, createBasicWordForms ) )
-	);
-}
-
-/**
- * Gets all matching word forms for the keyphrase and synonyms.
- *
- * @param {Paper}       paper       	The paper.
- * @param {Researcher}  researcher  	The researcher.
- *
- * @returns {Object} Object with an array of keyphrase forms and an array of arrays of synonyms forms, based on the forms
- * found in the text or created forms.
- */
-export default function( paper, researcher ) {
-	const functionWords = researcher.getConfig( "functionWords" );
-	const stemmer = researcher.getHelper( "getStemmer" )( researcher );
-	const createBasicWordForms = researcher.getHelper( "createBasicWordForms" );
-	const language = researcher.getConfig( "language" );
-	/*
-	 * Whether we want to split words on hyphens depends on the language.
-	 * In all languages apart from Indonesian, we consider hyphens as word boundaries. But in Indonesian, hyphens are used
-	 * to form plural forms of nouns, e.g. 'buku' is the singular form for 'book' and 'buku-buku' is the plural form.
-	 * This is why we don't split words on hyphens in Indonesian and we consider 'buku-buku' as one word rather than two.
-	 */
-	const areHyphensWordBoundaries = researcher.getConfig( "areHyphensWordBoundaries" );
-
-	const allWordsFromPaper = getAllWordsFromPaper( paper, areHyphensWordBoundaries ).map( word => word.toLocaleLowerCase( language ) );
-	const keyphrase = paper.getKeyword().toLocaleLowerCase( language ).trim();
-	const synonyms = parseSynonyms( paper.getSynonyms().toLocaleLowerCase( language ).trim() );
-
-	return getWordForms( keyphrase, synonyms, allWordsFromPaper, functionWords, stemmer, createBasicWordForms, areHyphensWordBoundaries );
-}

package/src/languageProcessing/researches/h1s.js

@@ -1,10 +0,0 @@
-/**
- * Gets all H1s in a text, including their content and their position information.
- *
- * @param {Paper} paper The paper for which to get the H1s.
- *
- * @returns {number | null} An array with all H1s, their content and position.
- */
-export default function(paper) {
-  return paper.getH1Count();
-}

package/src/languageProcessing/researches/imageCount.js

@@ -1,16 +0,0 @@
-/** @module researches/imageInText */
-
-import getImagesInTree from "../helpers/image/getImagesInTree";
-
-/**
- * Checks the amount of images in the text.
- *
- * @param {Paper} paper The paper to check for images.
- *
- * @returns {number} The amount of found images.
- */
-export default function imageCount( paper ) {
-	const images = getImagesInTree( paper );
-
-	return images.length;
-}

package/src/languageProcessing/researches/index.js

@@ -1,5 +0,0 @@
-import getLongCenterAlignedTexts from './getLongCenterAlignedTexts';
-import wordComplexity from './wordComplexity';
-import keyphraseDistribution from './keyphraseDistribution';
-
-export {getLongCenterAlignedTexts, keyphraseDistribution, wordComplexity};

package/src/languageProcessing/researches/keyphraseDistribution.js

@@ -1,249 +0,0 @@
-import { flattenDeep, max, uniq as unique, zipWith } from "lodash";
-import { findWordFormsInString } from "../helpers/match/findKeywordFormsInString";
-import { markWordsInSentences } from "../helpers/word/markWordsInSentences";
-import getSentences from "../helpers/sentence/getSentences";
-import parseSynonyms from "../helpers/sanitize/parseSynonyms";
-import { mergeListItems } from "../helpers/sanitize/mergeListItems";
-import removeHtmlBlocks from "../helpers/html/htmlParser";
-import { filterShortcodesFromHTML } from "../helpers/sanitize/filterShortcodesFromTree";
-
-/**
- * Checks whether at least half of the content words from the topic are found within the sentence.
- * Assigns a score to every sentence following the following schema:
- * 9 if at least half of the content words from the topic are in the sentence,
- * 3 otherwise.
- *
- * @param {Array}  topic     The word forms of all content words in a keyphrase or a synonym.
- * @param {Array}  sentences An array of all sentences in the text.
- * @param {string} locale    The locale of the paper to analyse.
- * @param {function}    matchWordCustomHelper 	The language-specific helper function to match word in text.
- *
- * @returns {Array} The scores per sentence.
- */
-const computeScoresPerSentenceLongTopic = function( topic, sentences, locale, matchWordCustomHelper ) {
-	const sentenceScores = Array( sentences.length );
-
-	for ( let i = 0; i < sentences.length; i++ ) {
-		const foundInCurrentSentence = findWordFormsInString( topic, sentences[ i ], locale, matchWordCustomHelper );
-
-		if ( foundInCurrentSentence.percentWordMatches >= 50 ) {
-			sentenceScores[ i ] = 9;
-		} else {
-			sentenceScores[ i ] = 3;
-		}
-	}
-
-	return sentenceScores;
-};
-
-
-/**
- * Checks whether all content words from the topic are found within one sentence.
- * Assigns a score to every sentence following the following schema:
- * 9 if all content words from the topic are in the sentence,
- * 3 if not all content words from the topic were found in the sentence.
- *
- * @param {Array}  topic     The word forms of all content words in a keyphrase or a synonym.
- * @param {Array}  sentences An array of all sentences in the text.
- * @param {string} locale    The locale of the paper to analyse.
- * @param {function}    matchWordCustomHelper 	The language-specific helper function to match word in text.
- *
- * @returns {Array} The scores per sentence.
- */
-const computeScoresPerSentenceShortTopic = function( topic, sentences, locale, matchWordCustomHelper ) {
-	const sentenceScores = Array( sentences.length );
-
-	for ( let i = 0; i < sentences.length; i++ ) {
-		const currentSentence = sentences[ i ];
-		const foundInCurrentSentence = findWordFormsInString( topic, currentSentence, locale, matchWordCustomHelper );
-		if ( foundInCurrentSentence.percentWordMatches === 100 ) {
-			sentenceScores[ i ] = 9;
-		} else {
-			sentenceScores[ i ] = 3;
-		}
-	}
-	return sentenceScores;
-};
-
-/**
- * Maximizes scores: Give every sentence a maximal score that it got from analysis of all topics
- *
- * @param {Array} sentenceScores The scores for every sentence, as assessed per keyphrase and every synonym.
- *
- * @returns {Array} Maximal scores of topic relevance per sentence.
- */
-const maximizeSentenceScores = function( sentenceScores ) {
-	const sentenceScoresTransposed = sentenceScores[ 0 ].map( function( col, i ) {
-		return sentenceScores.map( function( row ) {
-			return row[ i ];
-		} );
-	} );
-
-	return sentenceScoresTransposed.map( function( scoresForOneSentence ) {
-		return max( scoresForOneSentence );
-	} );
-};
-
-
-/**
- * Computes the maximally long piece of text that does not include the topic.
- *
- * @param {Array} sentenceScores The array of scores per sentence.
- *
- * @returns {number} The maximum number of sentences that do not include the topic.
- */
-const getDistraction = function( sentenceScores ) {
-	const numberOfSentences = sentenceScores.length;
-	const allTopicSentencesIndices = [];
-
-	for ( let i = 0; i < numberOfSentences; i++ ) {
-		if ( sentenceScores[ i ] > 3 ) {
-			allTopicSentencesIndices.push( i );
-		}
-	}
-
-	const numberOfTopicSentences = allTopicSentencesIndices.length;
-
-	if ( numberOfTopicSentences === 0 ) {
-		return numberOfSentences;
-	}
-
-	/**
-	 * Add fake topic sentences at the very beginning and at the very end
-	 * to account for cases when the text starts or ends with a train of distraction.
-	 */
-	allTopicSentencesIndices.unshift( -1 );
-	allTopicSentencesIndices.push( numberOfSentences );
-
-	const distances = [];
-
-	for ( let i = 1; i < numberOfTopicSentences + 2; i++ ) {
-		distances.push( allTopicSentencesIndices[ i ] - allTopicSentencesIndices[ i - 1 ] - 1 );
-	}
-
-	return max( distances );
-};
-
-/**
- * Computes the per-sentence scores depending on the length of the topic phrase and maximizes them over all topic phrases.
- *
- * @param {Array}       sentences              The sentences to get scores for.
- * @param {Array}       topicFormsInOneArray   The topic phrases forms to search for in the sentences.
- * @param {string}      locale                 The locale to work in.
- * @param {Array}       functionWords           The function words list.
- * @param {function}    matchWordCustomHelper 	The language-specific helper function to match word in text.
- * @param {int}         topicLengthCriteria     The topic length criteria. The default value is 4, where a topic is considered short
- *                                              if it's less than 4 word long, and otherwise long.
- * @param {Array}       originalTopic           The array of the original form of the topic with function words filtered out.
- * @param {function}    wordsCharacterCount     The helper to calculate the characters length of all the words in the array.
- *
- * @returns {Object} An array with maximized score per sentence and an array with all sentences that do not contain the topic.
- */
-const getSentenceScores = function( sentences, topicFormsInOneArray, locale, functionWords, matchWordCustomHelper,
-	topicLengthCriteria = 4, originalTopic, wordsCharacterCount ) {
-	// Compute per-sentence scores of topic-relatedness.
-	const topicNumber = topicFormsInOneArray.length;
-
-	const sentenceScores = Array( topicNumber );
-
-	// For languages with function words apply either full match or partial match depending on topic length
-	if ( functionWords.length > 0 ) {
-		for ( let i = 0; i < topicNumber; i++ ) {
-			const topic = topicFormsInOneArray[ i ];
-			/*
-			 * If the helper to calculate the characters length of all the words in the array is available,
-			 * we use this helper to calculate the characters length of the original topic form.
-			 * We then use the result and compare it with the topicLengthCriteria.
-			 */
-			const topicLength = wordsCharacterCount ? wordsCharacterCount( originalTopic[ i ] ) : topic.length;
-			if ( topicLength < topicLengthCriteria ) {
-				sentenceScores[ i ] = computeScoresPerSentenceShortTopic( topic, sentences, locale, matchWordCustomHelper );
-			} else {
-				sentenceScores[ i ] = computeScoresPerSentenceLongTopic( topic, sentences, locale, matchWordCustomHelper );
-			}
-		}
-	} else {
-		// For languages without function words apply the full match always
-		for ( let i = 0; i < topicNumber; i++ ) {
-			const topic = topicFormsInOneArray[ i ];
-			sentenceScores[ i ] = computeScoresPerSentenceShortTopic( topic, sentences, locale, matchWordCustomHelper );
-		}
-	}
-
-	// Maximize scores: Give every sentence a maximal score that it got from analysis of all topics
-	const maximizedSentenceScores = maximizeSentenceScores( sentenceScores );
-
-	// Zip an array combining each sentence with the associated maximized score.
-	const sentencesWithMaximizedScores =  zipWith( sentences, maximizedSentenceScores, ( sentence, score ) => {
-		return { sentence, score };
-	} );
-
-	// Filter sentences that contain topic words for future highlights.
-	const sentencesWithTopic = sentencesWithMaximizedScores.filter( sentenceObject => sentenceObject.score > 3 );
-
-	return {
-		maximizedSentenceScores: maximizedSentenceScores,
-		sentencesWithTopic: sentencesWithTopic.map( sentenceObject => sentenceObject.sentence ),
-	};
-};
-
-
-/**
- * Determines which portions of the text did not receive a lot of content words from keyphrase and synonyms.
- *
- * @param {Paper}       paper               The paper to check the keyphrase distribution for.
- * @param {Researcher}  researcher          The researcher to use for analysis.
- *
- * @returns {Object} The scores of topic relevance per portion of text and an array of all word forms to highlight.
- */
-const keyphraseDistributionResearcher = function( paper, researcher ) {
-	const functionWords = researcher.getConfig( "functionWords" );
-	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
-	const getContentWordsHelper = researcher.getHelper( "getContentWords" );
-	const wordsCharacterCount = researcher.getResearch( "wordsCharacterCount" );
-	const memoizedTokenizer = researcher.getHelper( "memoizedTokenizer" );
-
-	// Custom topic length criteria for languages that don't use the default value to determine whether a topic is long or short.
-	const topicLengthCriteria = researcher.getConfig( "topicLength" ).lengthCriteria;
-
-	let text = paper.getText();
-	text = removeHtmlBlocks( text );
-	text = filterShortcodesFromHTML( text, paper._attributes && paper._attributes.shortcodes );
-	text = mergeListItems( text );
-	const sentences = getSentences( text, memoizedTokenizer );
-	const topicForms = researcher.getResearch( "morphology" );
-
-	const originalTopic = [];
-	if ( getContentWordsHelper ) {
-		originalTopic.push( getContentWordsHelper( paper.getKeyword() ) );
-		parseSynonyms( paper.getSynonyms() ).forEach( synonym => originalTopic.push( getContentWordsHelper( synonym ) ) );
-	}
-	const locale = paper.getLocale();
-	const topicFormsInOneArray = [ topicForms.keyphraseForms ];
-	topicForms.synonymsForms.forEach( function( synonym ) {
-		topicFormsInOneArray.push( synonym );
-	} );
-
-	const allTopicWords = unique( flattenDeep( topicFormsInOneArray ) ).sort( ( a, b ) => b.length - a.length );
-
-	// Get per-sentence scores and sentences that have topic.
-	const sentenceScores = getSentenceScores( sentences, topicFormsInOneArray, locale, functionWords, matchWordCustomHelper,
-		topicLengthCriteria, originalTopic, wordsCharacterCount );
-	const maximizedSentenceScores = sentenceScores.maximizedSentenceScores;
-	const maxLengthDistraction = getDistraction( maximizedSentenceScores );
-
-	return {
-		sentencesToHighlight: markWordsInSentences( allTopicWords, sentenceScores.sentencesWithTopic, locale, matchWordCustomHelper ),
-		keyphraseDistributionScore: maxLengthDistraction / sentences.length * 100,
-	};
-};
-
-export {
-	computeScoresPerSentenceShortTopic,
-	computeScoresPerSentenceLongTopic,
-	maximizeSentenceScores,
-	keyphraseDistributionResearcher,
-	getDistraction,
-};
-
-export default keyphraseDistributionResearcher;

package/src/languageProcessing/researches/keyphraseLength.js

@@ -1,17 +0,0 @@
-/**
- * Determines the length in words of the keyphrase.
- *
- * @param {Paper} paper 			The paper to research
- * @param {Researcher} researcher 	The researcher to use for analysis
- *
- * @returns {Object} The length of the keyphrase and the function words list.
- */
-export default function( paper, researcher ) {
-	const topicForms = researcher.getResearch( "morphology" );
-	const functionWords = researcher.getConfig( "functionWords" );
-
-	return {
-		keyphraseLength: topicForms.keyphraseForms.length,
-		functionWords: functionWords,
-	};
-}

package/src/languageProcessing/researches/keywordCount.js

@@ -1,134 +0,0 @@
-import { flatten, flattenDeep } from "lodash";
-import getSentencesFromTree from "../helpers/sentence/getSentencesFromTree";
-import { normalizeSingle } from "../helpers/sanitize/quotes";
-import getMarkingsInSentence from "../helpers/highlighting/getMarkingsInSentence";
-import matchWordFormsWithSentence from "../helpers/match/matchWordFormsWithSentence";
-import isDoubleQuoted from "../helpers/match/isDoubleQuoted";
-import { markWordsInASentence } from "../helpers/word/markWordsInSentences";
-import getSentences from "../helpers/sentence/getSentences";
-import { filterShortcodesFromHTML } from "../helpers";
-
-/**
- * Counts the occurrences of the keyphrase in the text and creates the Mark objects for the matches.
- *
- * @param {(Sentence|string)[]}	sentences			The sentences to check.
- * @param {Array}		keyphraseForms				The keyphrase forms.
- * @param {string}		locale						The locale used in the analysis.
- * @param {function}	matchWordCustomHelper		A custom helper to match words with a text.
- * @param {boolean}		isExactMatchRequested		Whether the exact matching is requested.
- * @param {function}	customSplitIntoTokensHelper	A custom helper to split sentences into tokens.
- *
- * @returns {{markings: Mark[], count: number}} The number of keyphrase occurrences in the text and the Mark objects of the matches.
- */
-export function countKeyphraseInText( sentences, keyphraseForms, locale, matchWordCustomHelper,
-									  isExactMatchRequested, customSplitIntoTokensHelper ) {
-	const result = { count: 0, markings: [] };
-
-	sentences.forEach( sentence => {
-		const matchesInSentence = keyphraseForms.map( wordForms => matchWordFormsWithSentence( sentence,
-			wordForms, locale, matchWordCustomHelper, isExactMatchRequested, customSplitIntoTokensHelper ) );
-
-		// A sentence has at least one full-match of the keyphrase if each word occurs at least once.
-		const isEachWordFound = matchesInSentence.every( wordForms => wordForms.count > 0 );
-
-		if ( isEachWordFound ) {
-			/*
-			 * Retrieve all the occurrences' count of each word of the keyphrase and save it in an array.
-			 * matches: [ [ { matches: ["red"], count: 1 } ], [ { matches: ["pandas"], count: 2 } ] ]
-			 * counts: [ 1, 2 ]
-			 */
-			const counts = matchesInSentence.map( match => match.count );
-			/*
-			 * The number of the full-match count is the lowest count of the occurrences.
-			 * counts: [ 1, 2 ]
-			 * totalMatchCount: 1
-			 *
-			 * From the example above, the full-match is 1, because one of the "pandas" occurrences is not accompanied by "red"
-			 * to be counted as a full-match.
-			 */
-			const totalMatchCount = Math.min( ...counts );
-			const foundWords = flattenDeep( matchesInSentence.map( match => match.matches ) );
-
-			let markings = [];
-
-			if ( matchWordCustomHelper ) {
-				// Currently, this check is only applicable for Japanese.
-				markings = markWordsInASentence( sentence, foundWords, matchWordCustomHelper );
-			} else {
-				markings = getMarkingsInSentence( sentence, foundWords );
-			}
-
-			result.count += totalMatchCount;
-			result.markings.push( markings );
-		}
-	} );
-
-	return result;
-}
-
-/**
- * Calculates the keyphrase count, takes morphology into account.
- *
- * @param {Paper}       paper       The paper containing keyphrase and text.
- * @param {Researcher}  researcher  The researcher.
- *
- * @returns {{count: number, markings: Mark[], keyphraseLength: number}} An object containing the keyphrase count, markings and the kephrase length.
- */
-export default function getKeyphraseCount( paper, researcher ) {
-	const result = { count: 0, markings: [], keyphraseLength: 0 };
-	const topicForms = researcher.getResearch( "morphology" );
-	let keyphraseForms = topicForms.keyphraseForms;
-	const keyphraseLength = keyphraseForms.length;
-
-	/*
-	 * Normalize single quotes so that word form with different type of single quotes can still be matched.
-	 * For example, "key‛word" should match "key'word".
-	 */
-	keyphraseForms = keyphraseForms.map( word => word.map( form => normalizeSingle( form ) ) );
-
-	if ( keyphraseLength === 0 ) {
-		return result;
-	}
-
-	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
-	const customSentenceTokenizer = researcher.getHelper( "memoizedTokenizer" );
-	const customSplitIntoTokensHelper = researcher.getHelper( "splitIntoTokensCustom" );
-	const locale = paper.getLocale();
-	const text = matchWordCustomHelper
-		? filterShortcodesFromHTML( paper.getText(), paper._attributes && paper._attributes.shortcodes )
-		: paper.getText();
-
-	// When the custom helper is available, we're using the sentences retrieved from the text for the analysis.
-	const sentences = matchWordCustomHelper ? getSentences( text, customSentenceTokenizer ) : getSentencesFromTree( paper );
-	// Exact matching is requested when the keyphrase is enclosed in double quotes.
-	const isExactMatchRequested = isDoubleQuoted( paper.getKeyword() );
-
-	/*
-	* Count the amount of keyphrase occurrences in the sentences.
-	* An occurrence is counted when all words of the keyphrase are contained within the sentence. Each sentence can contain multiple keyphrases.
-	* (e.g. "The apple potato is an apple and a potato." has two occurrences of the keyphrase "apple potato").
-	*/
-	const keyphraseFound = countKeyphraseInText( sentences, keyphraseForms, locale, matchWordCustomHelper,
-		isExactMatchRequested, customSplitIntoTokensHelper );
-
-	result.count = keyphraseFound.count;
-	result.markings = flatten( keyphraseFound.markings );
-	result.keyphraseLength = keyphraseLength;
-
-	return result;
-}
-
-/**
- * Calculates the keyphrase count, takes morphology into account.
- *
- * @deprecated Use getKeyphraseCount instead.
- *
- * @param {Paper}       paper       The paper containing keyphrase and text.
- * @param {Researcher}  researcher  The researcher.
- *
- * @returns {Object} An array of all the matches, markings and the keyphrase count.
- */
-export function keywordCount( paper, researcher ) {
-	console.warn( "This function is deprecated, use getKeyphraseCount instead." );
-	return getKeyphraseCount( paper, researcher );
-}