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

package/src/languageProcessing/languages/tr/config/transitionWords.js

@@ -0,0 +1,42 @@
+/** @module config/transitionWords */
+
+export const singleWords = [ "fakat", "halbuki", "hatta", "üstelik", "ancak", "oysa", "sonuçta", "yalnız", "çünkü", "oysaki", "kısacası", "özetle",
+	"böylelikle", "ama", "lakin", "ayrıca", "açıkcası", "yani", "sonucunda", "böylece", "kısaca", "veya", "veyahut", "zira", "öyleyse",
+	"sonrasında", "ardından", "vakıa", "gerçi", "karşın", "tümüyle", "bütünüyle", "tamamıyla", "genelde", "diğer", "başka", "önce",
+	"öncesinde", "sonra", "yanısıra", "ama", "muhakkak", "kesinlikle", "şüphesiz", "elbet", "elbette", "kuşkusuz", "başlıca", "bilakis", "aksine",
+	"tersine", "devamında", "özellikle", "bilhassa", "nihayet", "nihayetinde", "neticede", "ayrıyeten", "dahası", "çoğunlukla", "genellikle",
+	"genelde", "dolayısıyla", "gelgelelim", "aslında", "doğrusu", "mamafih", "binaenaleyh", "evvelce", "önceden", "şöylelikle", "örneğin", "mesela",
+	"nitekim", "mademki", "şimdi", "halihazırda", "i̇laveten", "aynen", "nazaran", "nedeniyle", "yüzünden", "umumiyetle", "ekseriye", "amacıyla",
+	"gayesiyle", "velhasıl", "ezcümle", "özetlersek", "etraflıca", "tafsilatlı", "genişçe", "bilfiil", "filhakika", "evvela", "i̇lkin", "en önce",
+	"birincisi", "i̇kincisi", "üçüncüsü", "sonuncusu", "tıpkı", "topyekun", "hem", "kah", "ister", "ya", "gerekse", "sayesinde", "sebebiyle",
+	"üzere", "göre", "uyarınca", "halen", "gerçekten", "madem", "yoksa" ];
+
+export const multipleWords = [ "o halde", "bundan böyle", "demek ki", "ne yazık ki", "görüldüğü gibi", "i̇lk olarak", "son olarak", "ne var ki",
+	"buna rağmen", "yine de", "başka bir deyişle", "açıklamak gerekirse", "özetlemek gerekirse", "kısaca söylemek gerekirse", "görüldüğü gibi",
+	"ve bunun gibi", "halbu ki", "buna göre", "ona göre", "ek olarak", "her ne kadar", "velev ki", "olmakla beraber", "bile olsa", "i̇le beaber",
+	"i̇le birlikte", "her şeye rağmen", "bütün yanlarıyla", "bütün yönleriyle", "ele alacak olursak", "baştan sona", "diğer bir", "başka bir",
+	"daha önce", "daha sonra", "bundan başka", "bunun yanında", "bunun yanı sıra", "bununla birlikte", "buna ilaveten", "bunun dışında", "elbette ki",
+	"muhakkak ki", "belli başlı", "karşılaştırmak gerekirse", "karşılaştırmalı olarak", "aynı zamanda", "sonuç olarak", "diğer taraftan",
+	"diğer bir taraftan", "buna karşılık", "tam tersine", "buna bağlı olarak", "buna parelel olarak", "i̇kinci olarak", "üçüncü olarak",
+	"aynı derecede", "eşit olarak", "başta olmak üzere", "en sonunda", "açık bir şekilde", "ana hatlarıyla", "genel itibariyle", "genel anlamda",
+	"genel olarak", "bunun için", "bu nedenle", "bundan dolayı", "bu sebeple", "dolayısı ile", "her halükarda", "aynı biçimde", "aynı şekilde",
+	"bu esnada", "bu arada", "hal böyleyken", "bağlı kalmaksızın", "açık olarak", "belli ki", "ayrıntılı olarak", "bundan önce", "sözün kısası",
+	"az ve öz bir şekilde", "tüm ayrıntılarıyla", "bu şekilde", "o yüzden", "bu sayede", "buradan hareketle", "buna mukabil", "en önemlisi",
+	"her şeyden önce", "esas olarak", "hepsinden önce", "hepsinden öte", "hepsinden ötesi", "her şeyin üzerinde", "her şeyin ötesinde",
+	"hepsinden önemlisi", "asıl önemlisi", "her şeyi hesaba katarak", "bütün olarak", "her şey göz önüne alındığında", "pararel olarak",
+	"diğer bir nokta", "diğer açıdan", "öyle ya da böyle", "doğrusunu söylemek gerekirse", "i̇şin doğrusu", "aslına bakılırsa", "gerçek şu ki",
+	"hattı zatında", "aslına bakıldığında", "aslına bakarsak", "i̇şin aslı", "sonuç itibariyle", "örnek olarak", "örneleyecek olursak",
+	"görülebileceği gibi", "görülebileceği üzere", "görüldüğü üzere", "söylendiği gibi", "söylenildiği gibi", "söylediği gibi", "söylediğim gibi",
+	"olduğu kadar", "önceden belirtildiği gibi", "önceden söylendiği gibi", "yukarıda gösterildiği gibi", "eninde sonunda", "önünde sonunda",
+	"şu anda", "bu sırada", "bununla beraber", "bu noktada", "bunun ışığında", "bunların ışığında", "aşikar olarak", "aynı sebeple", "bir de",
+	"doğru da olsa", "doğru bile olsa", "öyle bile olsa", "öyle de olsa", "i̇le ilgili", "olsa bile", "eğer ki", "olsa dahi", "ondan dolayı",
+	"o sebepten dolayı", "bu yüzden", "onun için", "esas itibarıyla", "aynı sebepten dolayı", "bu amaçla", "zaman zaman", "arada sırada",
+	"dönem dönem", "arada bir", "diyelim ki", "farz edelim ki", "farz edersek", "kısaca söylecek olursak", "tek kelimeyle", "birkaç kelimeyle",
+	"sözün özü", "en nihayetinde", "uzun uzadıya", "her iki durumda da", "özü itibariyle", "amacı ile", "olması için", "başka bir ifadeyle",
+	"diğer bir deyişle", "i̇lk önce", "bir yandan", "bir taraftan", "hatırlatmak gerekirse", "bu bağlamda", "gel gelelim", "her şey hesaba katılırsa",
+	"bütüne bakıldığında", "belirtildiği gibi", "bir başka ifadeyle", "lafı toparlamak gerekirse", "bu düşünceyle", "bu maksatla", "bu doğrultuda",
+	"bu niyetle", "ne de", "ya da", "aksi durumda", "bu durum", "olup olmadığı", "diğer yandan", "öte yandan", "ne olursa olsun" ];
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;

package/src/languageProcessing/languages/tr/config/twoPartTransitionWords.js

@@ -0,0 +1,7 @@
+/** @module config/twoPartTransitionWords */
+
+/**
+ * Returns an array with two-part transition words to be used by the assessments.
+ * @returns {Array} The array filled with two-part transition words.
+ */
+export default [ [ "ne", "ne" ], [ "gerek", "gerek" ], [ "olsun", "olmasın" ] ];

package/src/languageProcessing/languages/tr/helpers/getStemmer.js

@@ -0,0 +1,22 @@
+import {get} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {baseStemmer} = languageProcessing;
+
+import determineStem from './internal/stem';
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer(researcher) {
+  const morphologyData = get(researcher.getData('morphology'), 'tr', false);
+
+  if (morphologyData) {
+    return word => determineStem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

package/src/languageProcessing/languages/tr/helpers/internal/stem.js

@@ -0,0 +1,20 @@
+import TurkishStemmer from '../../../vendor/turkishStemmer';
+
+/**
+ * Stems Turkish words.
+ *
+ * @param {string} word            The word to stem.
+ * @param {Object} morphologyData  The Turkish morphology data.
+ *
+ * @returns {string} The stemmed word.
+ */
+export default function stem(word, morphologyData) {
+  word = word.toLowerCase();
+  word = word.replace("'", '');
+
+  const stemmer = new TurkishStemmer(morphologyData);
+  stemmer.setCurrent(word);
+  stemmer.stem();
+
+  return stemmer.getCurrent();
+}

package/src/languageProcessing/languages/tr/helpers/isPassiveSentence.js

@@ -0,0 +1,43 @@
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+import passiveEndings from '../config/internal/passiveEndings';
+import {nonPassivesFullForms, nonPassiveStems} from '../config/internal/nonPassiveExceptions';
+
+/**
+ * Filters out words that are passive exceptions from an array.
+ *
+ * @param {string[]} matchedPassives     The words from the sentence that could be passives
+ *
+ * @returns {string[]}  The array of words with the non-passives filtered out
+ */
+const checkNonPassivesStemsList = function(matchedPassives) {
+  return matchedPassives.filter(passive =>
+    nonPassiveStems.some(stem =>
+      passiveEndings.some(function(ending) {
+        const pattern = new RegExp('^' + stem + ending + '$');
+        return !pattern.test(passive);
+      })
+    )
+  );
+};
+
+/**
+ * Checks the passed sentence to see if it contains passive verb forms and is not found in the non-passive full forms exception list.
+ *
+ * @param {string} sentence   The sentence to match against.
+ *
+ * @returns {Boolean}   Whether the sentence contains a Turkish verb passive voice.
+ */
+export default function isPassiveSentence(sentence) {
+  const words = getWords(sentence);
+
+  // We only check words that is longer than 5 letters
+  let matchedPassives = words.filter(word => word.length > 5);
+
+  // Filter out words that are passive exceptions from an array
+  matchedPassives = matchedPassives.filter(word => !nonPassivesFullForms.includes(word));
+  matchedPassives = checkNonPassivesStemsList(matchedPassives);
+
+  return matchedPassives.some(word => passiveEndings.some(ending => word.endsWith(ending)));
+}

package/src/languageProcessing/researches/altTagCount.js

@@ -0,0 +1,70 @@
+/** @module researches/imageAltTags */
+
+import imageAltAttribute from "../helpers/image/getAltAttribute";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString";
+import { isEmpty } from "lodash";
+import getImagesInTree from "../helpers/image/getImagesInTree";
+
+/**
+ * Matches the alt-tags in the images found in the text.
+ * Returns an object with the totals and different alt-tags.
+ *
+ * @param {Array}       imageNodes        		Array with all the image nodes in the text
+ * @param {Object}      topicForms          	The object with the keyphrase and the synonyms forms from the paper.
+ * @param {string}      locale              	The locale used for transliteration.
+ * @param {function}    matchWordCustomHelper 	A language-specific helper function to match word in text.
+ *
+ * @returns {object} altProperties Object with all alt-tags that were found.
+ */
+const matchAltProperties = function( imageNodes, topicForms, locale, matchWordCustomHelper ) {
+	const altProperties = {
+		noAlt: 0,
+		withAlt: 0,
+		withAltKeyword: 0,
+		withAltNonKeyword: 0,
+	};
+
+	imageNodes.forEach( imageNode => {
+		const alttag = imageAltAttribute( imageNode );
+
+		// If no alt-tag is set
+		if ( alttag === "" ) {
+			altProperties.noAlt++;
+			return;
+		}
+
+		// If no keyword is set, but the alt-tag is
+		if ( isEmpty( topicForms.keyphraseForms ) ) {
+			altProperties.withAlt++;
+			return;
+		}
+
+		// If the keyword is matched in the alt tag
+		const keywordMatchedInAltTag = findTopicFormsInString( topicForms, alttag, true, locale, matchWordCustomHelper );
+		if ( keywordMatchedInAltTag.percentWordMatches >= 50 ) {
+			altProperties.withAltKeyword++;
+			return;
+		}
+
+		altProperties.withAltNonKeyword++;
+	} );
+
+	return altProperties;
+};
+
+/**
+ * Checks the text for images, checks the type of each image and alt attributes for containing keywords
+ *
+ * @param {Paper}       paper       The paper to check for images.
+ * @param {Researcher}  researcher  The researcher to use for analysis.
+ *
+ * @returns {object} Object containing all types of found images
+ */
+export default function altTagCount( paper, researcher ) {
+	const images = getImagesInTree( paper );
+
+	const topicForms = researcher.getResearch( "morphology" );
+	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
+
+	return matchAltProperties( images, topicForms, paper.getLocale(), matchWordCustomHelper );
+}

package/src/languageProcessing/researches/countSentencesFromText.js

@@ -0,0 +1,19 @@
+import getSentences from "../helpers/sentence/getSentences";
+import sentencesLength from "../helpers/sentence/sentencesLength.js";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+import { filterShortcodesFromHTML } from "../helpers";
+
+/**
+ * Count sentences in the text.
+ * @param {Paper} paper The Paper object to get text from.
+ * @param {Researcher} 	researcher 	The researcher to use for analysis.
+ * @returns {Array} The sentences from the text.
+ */
+export default function( paper, researcher ) {
+	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 );
+	return sentencesLength( sentences, researcher );
+}

package/src/languageProcessing/researches/findKeyphraseInSEOTitle.js

@@ -0,0 +1,257 @@
+import { escapeRegExp, filter, includes, isEmpty, uniq } from "lodash";
+
+import wordMatch from "../helpers/match/matchTextWithWord.js";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString.js";
+import { stemPrefixedFunctionWords } from "../helpers/morphology/stemPrefixedFunctionWords.js";
+
+import processExactMatchRequest from "../helpers/match/processExactMatchRequest";
+import getWords from "../helpers/word/getWords";
+import { WORD_BOUNDARY_WITH_HYPHEN } from "../../config/wordBoundariesWithoutPunctuation";
+
+let functionWords = [];
+
+/**
+ * Strips all function words from the start of the given string.
+ *
+ * @param {string} str The string from which to strip the function words.
+ *
+ * @returns {boolean} Whether the string consists of function words only.
+ */
+const stripFunctionWordsFromStart = function( str ) {
+	str = str.toLocaleLowerCase();
+
+	/*
+ 	 * We use a word boundary regex that includes whitespaces, en-dashes, and hyphens for all languages.
+ 	 * This means that when we filter out function words from the beginning of the title, we also filter out words
+ 	 * separated by hyphens (e.g. 'three-piece'), as well as function words attached to a content word with a hyphen
+ 	 * (e.g. 'after' in 'after-school).
+ 	 * In Indonesian we normally don't want to treat hyphens as word boundaries, but in this case it makes sense because
+ 	 * an Indonesian title can also contain function words seperated by hyphens at the beginning of the title (e.g. 'dua'
+ 	 * and 'lima' in 'dua-lima ribuan').
+ 	 * As a downside, single function words containing hyphens (e.g. 'vis-à-vis') won't be filtered out, but we are solving this
+ 	 * by adding each word from such function words as separate entries in the function words lists.
+  	 */
+	let titleWords = getWords( str.toLocaleLowerCase(), WORD_BOUNDARY_WITH_HYPHEN );
+
+	// Strip all function words from the start of the string.
+	titleWords = filter( titleWords, function( word ) {
+		return ( ! includes( functionWords, word.trim().toLocaleLowerCase() ) );
+	} );
+
+	return isEmpty( titleWords );
+};
+
+/**
+ * Checks the position of the keyphrase in the SEO title.
+ *
+ * @param {string} title 		The SEO title of the paper.
+ * @param {number} position 	The position of the keyphrase in the SEO title.
+ *
+ * @returns {number} Potentially adjusted position of the keyphrase in the SEO title.
+ */
+const adjustPosition = function( title, position ) {
+	// Don't do anything if position is already 0.
+	if ( position === 0 ) {
+		return position;
+	}
+
+	// Don't do anything if no function words exist for this language.
+	if ( functionWords.length === 0 ) {
+		return position;
+	}
+
+	// Strip all function words from the beginning of the SEO title.
+	const titleBeforeKeyword = title.substring( 0, position );
+	if ( stripFunctionWordsFromStart( titleBeforeKeyword ) ) {
+		/*
+		 * Return position 0 if there are no words left in the SEO title before the keyword after filtering
+		 * the function words (such that "keyword" in "the keyword" is still counted as position 0).
+ 		 */
+		return 0;
+	}
+
+	return position;
+};
+
+/**
+ * Creates a cartesian product of the given arrays.
+ * This function is taken from: https://stackoverflow.com/questions/12303989/cartesian-product-of-multiple-arrays-in-javascript
+ *
+ * @param {array} arrays The arrays to create the cartesian product of.
+ *
+ * @returns {array} The cartesian product of the given arrays.
+ */
+function cartesian( ...arrays ) {
+	return arrays.reduce( ( a, b ) => a.flatMap( d => b.map( e => [ d, e ].flat() ) ) );
+}
+
+/**
+ * Finds the exact match of the keyphrase in the SEO title for languages that have prefixed function words.
+ *
+ * @param {object} matchesObject The object that contains an array of matched words of the keyphrase in SEO title and the position of the match.
+ * @param {string} keyphrase The keyphrase to find in the SEO title.
+ * @param {object} result The result object to store the results in.
+ * @param {RegExp} prefixedFunctionWordsRegex The function to stem the prefixed function words.
+ * @param {string} title The SEO title of the paper.
+ * @param {string} locale The locale of the paper.
+ *
+ * @returns {object} The new result object containing the results of the analysis.
+ */
+function findExactMatch( matchesObject, keyphrase, result, prefixedFunctionWordsRegex, title, locale ) {
+	let matchedPrefixedFunctionWords = [];
+	/*
+	For each matched word of the keyphrase, get the prefixed function word.
+	For example, for the matches array [ "القطط" ,"والوسيمة" ], the `matchedPrefixedFunctionWords` array will be [ "ال", "وال" ].
+	 */
+	matchesObject.matches.forEach( match => {
+		const { prefix: prefixedFunctionWord  } = stemPrefixedFunctionWords( match, prefixedFunctionWordsRegex );
+		matchedPrefixedFunctionWords.push( prefixedFunctionWord );
+	} );
+
+	// Split the keyphrase into words. For example, the keyphrase "قطط وسيمة" will be split into [ قطط", "وسيمة" ].
+	const splitKeyphrase = keyphrase.split( " " );
+	let keyphraseVariations = [];
+
+	// Add an empty string to the array to account for the case where the word is not prefixed, remove duplicates.
+	matchedPrefixedFunctionWords = uniq( matchedPrefixedFunctionWords.concat( [ "" ] ) );
+	/*
+	 Create an array of arrays, where each array contains each word of the keyphrase with function word prefixes attached.
+	 For example, when the split keyphrase is [ "قطط", "وسيمة" ] and the matchedPrefixedFunctionWords is [ "ال", "وال", "" ],
+	 the array would be: [ [ "والقطط","القطط", "قطط" ], [ "والوسيمة" ,"الوسيمة", "وسيمة" ] ].
+	 */
+	const arrays = [];
+	splitKeyphrase.forEach( word => {
+		arrays.push( matchedPrefixedFunctionWords.map( prefixedFunctionWord => prefixedFunctionWord + word ) );
+	} );
+	/*
+	Create the cartesian product of the created arrays: to create all possible combinations of the previously created arrays.
+	For example, the cartesian product of [ [ "والقطط","القطط", "قطط" ], [ "والوسيمة" ,"الوسيمة", "وسيمة" ] ] will be:
+	...[ [ "والقطط", "والوسيمة" ], [ "والقطط", "الوسيمة" ], [ "والقطط", "وسيمة" ], [ "القطط", "والوسيمة" ]]
+	 */
+	keyphraseVariations = cartesian( ...arrays );
+	// Turn the keyphrase combination array into strings. For example, [ "والقطط", "والوسيمة" ] will be turned into "والقطط والوسيمة".
+	keyphraseVariations = keyphraseVariations.map( variation => Array.isArray( variation ) ? variation.join( " " ) : variation );
+	keyphraseVariations.forEach( variation => {
+		// Check if the exact match of the keyphrase combination is found in the SEO title.
+		const foundMatch = wordMatch( title, variation, locale, false );
+		if ( foundMatch.count > 0 ) {
+			result.exactMatchFound = true;
+			// Adjust the position of the matched keyphrase if it's preceded by non-prefixed function words.
+			result.position = adjustPosition( title, foundMatch.position );
+		}
+	} );
+	/*
+	This check if to account for the case where an exact match of the keyphrase is not found in the SEO title,
+	but it's found in the position is 0.
+	 */
+	if ( matchesObject.position === 0 ) {
+		result.position = 0;
+	}
+	return result;
+}
+
+/**
+ * An object containing the results of the keyphrase in SEO title research.
+ *
+ * @typedef {Object} 	KeyphraseInSEOTitleResult
+ * @property {boolean}	exactMatchFound	Whether the exact match of the keyphrase was found in the SEO title.
+ * @property {boolean}	allWordsFound	Whether all content words from the keyphrase were found in the SEO title.
+ * @property {number}	position The position of the keyphrase in the SEO title.
+ * @property {boolean}	exactMatchKeyphrase Whether the exact match was requested.
+ */
+
+/**
+ * Checks if all content words from the keyphrase are found in the SEO title.
+ *
+ * @param {Paper} paper The Paper object that contains analysis data.
+ * @param {Researcher} researcher The language researcher.
+ * @param {string} keyword The keyword to find in the SEO title.
+ * @param {object} result The result object to store the results in.
+ * @param {RegExp} prefixedFunctionWordsRegex The researcher to use for analysis.
+ * @returns {object} The new result object containing the results of the analysis.
+ */
+function checkIfAllWordsAreFound( paper, researcher, keyword, result, prefixedFunctionWordsRegex ) {
+	const title = paper.getTitle();
+	const locale = paper.getLocale();
+	const topicForms = researcher.getResearch( "morphology" );
+
+	// Use only keyphrase (not the synonyms) to match topic words in the SEO title.
+	const useSynonyms = false;
+
+	const separateWordsMatched = findTopicFormsInString( topicForms, title, useSynonyms, locale, false );
+
+	if ( separateWordsMatched.percentWordMatches === 100 ) {
+		/*
+		If all words are found and the position of the found words is 0, we further check if the exact match is found
+		for languages with a helper to stem prefixed function words, e.g. definite article.
+		Our support for this type of language is currently only for Arabic and Hebrew.
+		For example, in Arabic, the word "المنزل" (the house) is written as "ال" (the) + "منزل" (house).
+		And in Hebrew, the word "הבית" (the house) is written as "ה" (the) + "בית" (house).
+		In the above case, when the keyphrase is "منزل", and the SEO title starts with "المنزل" in Arabic,
+		or when the keyphrase is "בית" and the SEO title is "הבית", we want to consider this as an exact match
+		and the position is 0 if it's found in the beginning of the SEO title.
+		This treatment is to align with the way we match the keyphrase in SEO title for other languages.
+		For example, in English, the keyphrase "house" is considered to be found in the SEO title "the house" at position 0.
+		 */
+		if ( prefixedFunctionWordsRegex ) {
+			const {
+				exactMatchFound,
+				position,
+			} = findExactMatch( separateWordsMatched, keyword, result, prefixedFunctionWordsRegex, title, locale );
+			result = {
+				...result,
+				exactMatchFound: exactMatchFound,
+				position: position,
+			};
+		}
+		result.allWordsFound = true;
+	}
+	return result;
+}
+
+/**
+ * Counts the occurrences of the keyword in the SEO title. Returns the result that contains information on
+ * (1) whether the exact match of the keyphrase was used in the SEO title,
+ * (2) whether all (content) words from the keyphrase were found in the SEO title,
+ * (3) at which position the exact match was found in the SEO title.
+ *
+ * @param {Object} paper 			The paper containing SEO title and keyword.
+ * @param {Researcher} researcher 	The researcher to use for analysis.
+ *
+ * @returns {KeyphraseInSEOTitleResult} An object containing the information on whether the keyphrase was matched in the SEO title and how.
+ */
+const findKeyphraseInSEOTitle = function( paper, researcher ) {
+	functionWords = researcher.getConfig( "functionWords" );
+
+	let keyword = escapeRegExp( paper.getKeyword() );
+	const title = paper.getTitle();
+	const locale = paper.getLocale();
+
+	let result = { exactMatchFound: false, allWordsFound: false, position: -1, exactMatchKeyphrase: false  };
+
+	// Check if the keyphrase is enclosed in double quotation marks to ensure that only exact matches are processed.
+	const exactMatchRequest = processExactMatchRequest( keyword );
+
+	if ( exactMatchRequest.exactMatchRequested ) {
+		keyword = exactMatchRequest.keyphrase;
+		result.exactMatchKeyphrase = true;
+	}
+
+	// Check if the exact match of the keyphrase is found in the SEO title.
+	const prefixedFunctionWordsRegex = researcher.getConfig( "prefixedFunctionWordsRegex" );
+	const keywordMatched = wordMatch( title, keyword, locale, false );
+
+	if ( keywordMatched.count > 0 && ! prefixedFunctionWordsRegex ) {
+		result.exactMatchFound = true;
+		result.allWordsFound = true;
+		result.position = adjustPosition( title, keywordMatched.position );
+
+		return result;
+	}
+
+	result = checkIfAllWordsAreFound( paper, researcher, keyword, result, prefixedFunctionWordsRegex );
+
+	return result;
+};
+
+export default findKeyphraseInSEOTitle;

package/src/languageProcessing/researches/findKeywordInFirstParagraph.js

@@ -0,0 +1,86 @@
+/** @module analyses/findKeywordInFirstParagraph */
+import { inRange, isEmpty } from "lodash";
+
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString.js";
+import { getParentNode } from "../helpers/sentence/getSentencesFromTree";
+import { createShortcodeTagsRegex } from "../helpers";
+
+
+/**
+ * Checks if the introductory paragraph contains keyphrase or synonyms.
+ * First splits the first paragraph by sentences. Finds the first paragraph which contains sentences e.g., not an image).
+ * (1) Tries to find all (content) words from the keyphrase or a synonym phrase within one sentence.
+ * If found all words within one sentence, returns an object with foundInOneSentence = true and keyphraseOrSynonym = "keyphrase"
+ * or "synonym".
+ * If it did not find all words within one sentence, goes ahead with matching the keyphrase with the entire first paragraph.
+ * (2) Tries to find all (content) words from the keyphrase or a synonym phrase within the paragraph.
+ * If found all words within the paragraph, returns an object with foundInOneSentence = false, foundInParagraph = true,
+ * and keyphraseOrSynonym = "keyphrase" or "synonym".
+ * If found not all words within the paragraph of nothing at all, returns an object with foundInOneSentence = false,
+ * foundInParagraph = false, and keyphraseOrSynonym = "".
+ *
+ * @param {Paper} paper The text to check for paragraphs.
+ * @param {Researcher} researcher The researcher to use for analysis.
+ *
+ * @returns {Object} Whether the keyphrase words were found in one sentence, whether the keyphrase words were found in
+ * the paragraph, whether a keyphrase or a synonym phrase was matched.
+ */
+export default function( paper, researcher ) {
+	let paragraphs = researcher.getResearch( "getParagraphs" );
+	// Filter captions from non-Classic editors.
+	paragraphs = paragraphs.filter( paragraph => {
+		const parentNode = getParentNode( paper, paragraph );
+		return ! ( paragraph.isImplicit && parentNode && parentNode.name === "figcaption" );
+	} );
+	// Filter captions from Classic editor and from classic block inside Block editor.
+	paragraphs = paragraphs.filter( paragraph => {
+		return ! ( paragraph.childNodes && paragraph.childNodes[ 0 ] &&
+			createShortcodeTagsRegex( [ "caption" ] ).test( paragraph.childNodes[ 0 ].value ) );
+	} );
+	 const firstParagraph = paragraphs[ 0 ];
+
+	const topicForms = researcher.getResearch( "morphology" );
+	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
+	const locale = paper.getLocale();
+	const startOffset = firstParagraph && firstParagraph.sourceCodeLocation.startOffset;
+
+	const mappedBlocks = paper._attributes.wpBlocks;
+	const filteredIntroductionBlock = mappedBlocks && mappedBlocks.filter( block => inRange( startOffset, block.startOffset, block.endOffset ) )[ 0 ];
+	const result = {
+		foundInOneSentence: false,
+		foundInParagraph: false,
+		keyphraseOrSynonym: "",
+		introduction: firstParagraph,
+		parentBlock: filteredIntroductionBlock || null,
+	};
+
+	if ( isEmpty( firstParagraph ) ) {
+		return result;
+	}
+
+	const sentences = firstParagraph.sentences.map( sentence => sentence.text );
+	// Use both keyphrase and synonyms to match topic words in the first paragraph.
+	const useSynonyms = true;
+
+	if ( ! isEmpty( sentences ) ) {
+		const firstResultSentence = sentences
+			.map( sentence => findTopicFormsInString( topicForms, sentence, useSynonyms, locale, matchWordCustomHelper ) )
+			.find( resultSentence => resultSentence.percentWordMatches === 100 );
+
+		if ( firstResultSentence ) {
+			result.foundInOneSentence = true;
+			result.foundInParagraph = true;
+			result.keyphraseOrSynonym = firstResultSentence.keyphraseOrSynonym;
+			return result;
+		}
+
+		const resultParagraph = findTopicFormsInString( topicForms, firstParagraph.innerText(), useSynonyms, locale, matchWordCustomHelper );
+		if ( resultParagraph.percentWordMatches === 100 ) {
+			result.foundInParagraph = true;
+			result.keyphraseOrSynonym = resultParagraph.keyphraseOrSynonym;
+			return result;
+		}
+	}
+
+	return result;
+}