axyseo 2.0.0-alpha.0.0.19 → 2.0.0-alpha.0.0.2

package/src/languageProcessing/helpers/word/includesIndex.js

@@ -0,0 +1,30 @@
+import { forEach, includes, isEmpty } from "lodash";
+
+/**
+ * Checks whether a given word is directly preceded by a word from a list of words.
+ *
+ * @param {Array} precedingWords    The array of objects with matches and indices.
+ * @param {number} matchIndex       The index of the word for which to check whether it's preceded by one of the other words.
+ * @param {boolean} addSpace        True if a space should be added.
+ *
+ * @returns {boolean} Returns true if the match is preceded by a given word, otherwise returns false.
+ */
+export default function( precedingWords, matchIndex, addSpace = true ) {
+	/*
+	1 if there is a space between the match and the preceding word
+	(because the end word boundary is not included in the match).
+	0 if the preceding word is a contraction.
+	*/
+	const space = addSpace ? 1 : 0;
+
+	if ( isEmpty( precedingWords ) ) {
+		return false;
+	}
+
+	const precedingWordsEndIndices = [];
+	forEach( precedingWords, function( precedingWord ) {
+		const precedingWordsEndIndex = precedingWord.index + precedingWord.match.length + space;
+		precedingWordsEndIndices.push( precedingWordsEndIndex );
+	} );
+	return includes( precedingWordsEndIndices, matchIndex );
+}

package/src/languageProcessing/helpers/word/indices.js

@@ -0,0 +1,146 @@
+import { isUndefined, forEach } from "lodash";
+import stripSpaces from "../sanitize/stripSpaces.js";
+import { isWordInSentence as matchWordInSentence, characterInBoundary } from "./matchWordInSentence.js";
+
+/**
+ * Returns the indices of a string in a text. If it is found multiple times, it will return multiple indices.
+ *
+ * @param {string} word The word to find in the text.
+ * @param {string} text The text to check for the given word.
+ *
+ * @returns {Array} All indices found.
+ */
+function getIndicesByWord( word, text ) {
+	let startIndex = 0;
+	const searchStringLength = word.length;
+	let index;
+	const indices = [];
+	while ( ( index = text.indexOf( word, startIndex ) ) > -1 ) {
+		// Check if the previous and next character are word boundaries to determine if a complete word was detected
+		const isPreviousCharacterWordBoundary = characterInBoundary( text[ index - 1 ] ) || index === 0;
+
+		const isNextCharacterWordBoundary = characterInBoundary( text[ index + searchStringLength ] ) ||
+			( text.length === index + searchStringLength );
+
+		if ( isPreviousCharacterWordBoundary && isNextCharacterWordBoundary ) {
+			indices.push(
+				{
+					index: index,
+					match: word,
+				}
+			);
+		}
+		startIndex = index + searchStringLength;
+	}
+	return indices;
+}
+
+/**
+ * Matches string with an array, returns the word and the index it was found on.
+ *
+ * @param {Array} words The array with strings to match.
+ * @param {string} text The text to match the strings from the array to.
+ *
+ * @returns {Array} The array with words, containing the index of the match and the matched string.
+ * Returns an empty array if none are found.
+ */
+const getIndicesByWordList = function( words, text ) {
+	let matchedWords = [];
+
+	forEach( words, function( word ) {
+		word = stripSpaces( word );
+		if ( ! matchWordInSentence( word, text ) ) {
+			return;
+		}
+		matchedWords = matchedWords.concat( getIndicesByWord( word, text ) );
+	} );
+	return matchedWords;
+};
+
+/**
+ * Sorts the array on the index property of each entry.
+ *
+ * @param {Array} indices The array with indices.
+ *
+ * @returns {Array} The sorted array with indices.
+ */
+const sortIndices = function( indices ) {
+	return indices.sort( function( a, b ) {
+		return ( a.index - b.index );
+	} );
+};
+
+/**
+ * Filters duplicate entries if the indices overlap.
+ *
+ * @param {Array} indices The array with indices to be filtered.
+ *
+ * @returns {Array} The filtered array.
+ */
+const filterIndices = function( indices ) {
+	indices = sortIndices( indices );
+	const filtered = [];
+	for ( let i = 0; i < indices.length; i++ ) {
+		// If the next index is within the range of the current index and the length of the word, remove it
+		// This makes sure we don't match combinations twice, like "even though" and "though".
+		if ( ! isUndefined( indices[ i + 1 ] ) && indices[ i + 1 ].index < indices[ i ].index + indices[ i ].match.length ) {
+			filtered.push( indices[ i ] );
+
+			// Adds 1 to i, so we skip the next index that is overlapping with the current index.
+			i++;
+			continue;
+		}
+		filtered.push( indices[ i ] );
+	}
+	return filtered;
+};
+
+/**
+ * Matches string with an array, returns the word and the index it was found on, and sorts the match instances based on
+ * the index property of the match.
+ *
+ * @param {Array} words The array with strings to match.
+ * @param {string} text The text to match the strings from the array to.
+ *
+ * @returns {Array} The array with words, containing the index of the match and the matched string.
+ * Returns an empty array if none are found.
+ */
+const getIndicesByWordListSorted = function( words, text ) {
+	let matchedWords = [];
+
+	forEach( words, function( word ) {
+		word = stripSpaces( word );
+		if ( ! matchWordInSentence( word, text ) ) {
+			return matchedWords;
+		}
+		matchedWords = matchedWords.concat( getIndicesByWord( word, text ) );
+	} );
+
+	matchedWords = matchedWords.sort( function( a, b ) {
+		if ( a.index < b.index ) {
+			return -1;
+		}
+		if ( a.index > b.index ) {
+			return 1;
+		}
+		return 0;
+	} );
+
+	return matchedWords;
+};
+
+export {
+	getIndicesByWord,
+	getIndicesByWordList,
+	filterIndices,
+	sortIndices,
+	getIndicesByWordListSorted,
+};
+
+export default {
+	getIndicesByWord,
+	getIndicesByWordList,
+	filterIndices,
+	sortIndices,
+	getIndicesByWordListSorted,
+};

package/src/languageProcessing/helpers/word/markWordsInSentences.js

@@ -0,0 +1,173 @@
+import matchWords from "../match/matchTextWithArray";
+import arrayToRegex from "../regex/createRegexFromArray";
+import addMark from "../../../markers/addMarkSingleWord";
+import Mark from "../../../values/Mark";
+import { escapeRegExp } from "lodash";
+import getAnchorsFromText from "../link/getAnchorsFromText";
+import { SINGLE_QUOTES_ARRAY, SINGLE_QUOTES_REGEX } from "../sanitize/quotes";
+
+// Regex to deconstruct an anchor into open tag, content and close tag.
+const anchorDeconstructionRegex = /(<a[\s]+[^>]+>)([^]*?)(<\/a>)/;
+
+/**
+ * Deconstructs an anchor to the opening tag and the content. The content is the anchor text.
+ * We don't return the closing tag since the value would always be the same, i.e. </a>.
+ *
+ * @param {string} anchor An anchor of the shape <a ...>...</a>.
+ *
+ * @returns {object} An object containing the opening tag and the content.
+ */
+export const deConstructAnchor = function( anchor ) {
+	// The const array mirrors the anchorDeconstructionRegex, using a comma to access the first element without a name.
+	const [ , openTag, content ] = anchor.match( anchorDeconstructionRegex );
+	return {
+		openTag: openTag,
+		content: content,
+	};
+};
+
+/**
+ * Reconstructs an anchor from an openTag, the content, and the closing tag.
+ *
+ * @param {string} openTag The opening tag of the anchor. Must be of the shape <a ...>.
+ * @param {string} content The text of the anchor.
+ *
+ * @returns {string} An anchor.
+ */
+export const reConstructAnchor = function( openTag, content ) {
+	return `${openTag}${content}</a>`;
+};
+
+
+/**
+ * Gets the anchors and marks the anchors' text if the words are found in it.
+ *
+ * @param {string} sentence The sentence to retrieve the anchors from.
+ * @param {RegExp} wordsRegex The regex of the words.
+ *
+ * @returns {Object} The anchors and the marked anchors.
+ */
+const getMarkedAnchors = function( sentence, wordsRegex ) {
+	// Retrieve the anchors.
+	const anchors = getAnchorsFromText( sentence );
+	// For every anchor, apply the markings only to the anchor tag.
+	const markedAnchors = anchors.map( anchor => {
+		// Retrieve the open tag and the content/anchor text.
+		const { openTag, content } = deConstructAnchor( anchor );
+
+		// Apply the marking to the anchor text if there is a match.
+		const markedAnchorText = content.replace( wordsRegex, ( x ) => addMark( x ) );
+
+		// Create a new anchor tag with a (marked) anchor text.
+		return reConstructAnchor( openTag, markedAnchorText );
+	} );
+
+	return { anchors, markedAnchors };
+};
+
+/**
+ * Adds marks to a sentence and merges marks if those are only separated by a space
+ * (e.g., if highlighting words "ballet" and "shoes" in a sentence "I have a lot of ballet shoes and other paraphernalia."
+ * the marks will be put around "ballet shoes" together, not "`ballet` `shoes`".)
+ *
+ * @param {string}    sentence               The sentence to mark words in.
+ * @param {[string]}  wordsFoundInSentence   The words to mark in the sentence.
+ * @param {function}  matchWordCustomHelper  The language-specific helper function to match word in text.
+ *
+ * @returns {string} The sentence with marks.
+ */
+export const collectMarkingsInSentence = function( sentence, wordsFoundInSentence, matchWordCustomHelper ) {
+	const allWordsFound = [];
+	wordsFoundInSentence.forEach( word => {
+		// Check if the word in `wordsFoundInSentence` contains single quote(s).
+		const matchedSingleQuotes = word.match( SINGLE_QUOTES_REGEX );
+		if ( matchedSingleQuotes ) {
+			/*
+			 * If yes, make all different combinations of the word with different types of single quotes in the array.
+			 * Later, a regex will be created for all words that were found in the sentence including their variations.
+			 *
+			 * For example:
+			 * `wordsFoundInSentence`: [ "red", "panda’s" ]
+			 * For the word "panda’s", we'll create the following variations:
+			 * "panda's", "panda‘s", "panda’s", "panda‛s", "panda`s", "panda‹s", "panda›s"
+			 * And those variations will be added to `allWordsFound`.
+			 */
+			SINGLE_QUOTES_ARRAY.forEach( singleQuote => {
+				matchedSingleQuotes.forEach( matchedSingleQuote => {
+					allWordsFound.push( escapeRegExp( word.replace( new RegExp( matchedSingleQuote, "g" ), singleQuote ) ) );
+				} );
+			} );
+		} else {
+			allWordsFound.push( escapeRegExp( word ) );
+		}
+	} );
+
+	// If a language has a custom helper to match words, we disable the word boundary when creating the regex.
+	const wordsRegex = matchWordCustomHelper ? arrayToRegex( allWordsFound, true ) : arrayToRegex( allWordsFound );
+
+	// Retrieve the anchors and mark the anchors' text if the words are found in the anchors' text.
+	const { anchors, markedAnchors } = getMarkedAnchors( sentence, wordsRegex );
+
+	let markup = sentence.replace( wordsRegex, function( x ) {
+		return addMark( x );
+	} );
+
+	/**
+	 * In 'markup', we apply the markings also inside the anchor's attribute if there is a match, on top of
+	 * marking the anchor's text.
+	 * The step below is to replace the incorrectly marked anchors with the marked anchors that we want:
+	 * where the markings are only applied in the anchor's text.
+	 */
+	if ( anchors.length > 0 ) {
+		const markupAnchors = getAnchorsFromText( markup );
+		for ( let i = 0; i < markupAnchors.length; i++ ) {
+			markup = markup.replace( markupAnchors[ i ], markedAnchors[ i ] );
+		}
+	}
+
+	/*
+	 * If two marks are separated by only a space, remove the closing tag of the first mark and the opening tag of the
+	 * second mark so that the two marks can be combined into one.
+	 */
+	return ( markup.replace( new RegExp( "</yoastmark> <yoastmark class='yoast-text-mark'>", "ig" ), " " ) );
+};
+
+/**
+ * Adds marks to a sentence.
+ *
+ * @param {string}      sentence                The sentence in which we want to apply highlighting.
+ * @param {Array}       wordsFoundInSentence    The words to highlight in a sentence.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ * @returns {Mark[]}  The array of Mark objects of each sentence.
+ */
+export function markWordsInASentence( sentence, wordsFoundInSentence, matchWordCustomHelper ) {
+	return [ new Mark( {
+		original: sentence,
+		marked: collectMarkingsInSentence( sentence, wordsFoundInSentence, matchWordCustomHelper ),
+	} ) ];
+}
+
+/**
+ * Adds marks to an array of sentences.
+ *
+ * @param {[string]}    wordsToMark The words to mark.
+ * @param {[string]}    sentences   The sentences in which to mark these words.
+ * @param {string}      locale      The locale.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ *
+ * @returns {[string]} The sentences with marks.
+ */
+export function markWordsInSentences( wordsToMark, sentences, locale, matchWordCustomHelper ) {
+	let wordsFoundInSentence = [];
+	let markings = [];
+
+	sentences.forEach( function( sentence ) {
+		wordsFoundInSentence = matchWords( sentence, wordsToMark, locale, matchWordCustomHelper ).matches;
+
+		if ( wordsFoundInSentence.length > 0 ) {
+			markings = markings.concat( markWordsInASentence( sentence, wordsFoundInSentence, matchWordCustomHelper ) );
+		}
+	} );
+
+	return markings;
+}

package/src/languageProcessing/helpers/word/matchWordInSentence.js

@@ -0,0 +1,61 @@
+import wordBoundariesFactory from "../../../config/wordBoundaries.js";
+const wordBoundaries = wordBoundariesFactory();
+import { escapeRegExp, includes } from "lodash";
+import addWordBoundary from "./addWordboundary.js";
+
+/**
+ * Checks whether a character is present in the list of word boundaries.
+ *
+ * @param {string} character The character to look for.
+ * @returns {boolean} Whether or not the character is present in the list of word boundaries.
+ */
+const characterInBoundary = function( character ) {
+	return includes( wordBoundaries, character );
+};
+
+/**
+ * Checks whether a word is present in a sentence.
+ *
+ * @param {string} word The word to search for in the sentence.
+ * @param {string} sentence The sentence to look through.
+ * @returns {boolean} Whether or not the word is present in the sentence.
+ */
+const isWordInSentence = function( word, sentence ) {
+	// To ensure proper matching, make everything lowercase.
+	word = word.toLocaleLowerCase();
+	sentence = sentence.toLocaleLowerCase();
+
+	// Escape regex in word, since we use regex characters like in abbreviations ("e.g.").
+	const wordWithBoundaries = addWordBoundary( escapeRegExp( word ) );
+	let occurrenceStart = sentence.search( new RegExp( wordWithBoundaries, "ig" ) );
+	// Return false if no match has been found.
+	if ( occurrenceStart === -1 ) {
+		return false;
+	}
+	/*
+	If there is a word boundary before the matched word, the regex includes this word boundary in the match.
+	This means that occurrenceStart is the index of the word boundary before the match. Therefore 1 has to
+	be added to occurrenceStart, except when there is no word boundary before the match (i.e. at the start
+	of a sentence).
+	 */
+	if ( occurrenceStart > 0 ) {
+		occurrenceStart += 1;
+	}
+	const occurrenceEnd = occurrenceStart + word.length;
+
+	// Check if the previous and next character are word boundaries to determine if a complete word was detected
+	const previousCharacter = characterInBoundary( sentence[ occurrenceStart - 1 ] ) || occurrenceStart === 0;
+	const nextCharacter = characterInBoundary( sentence[ occurrenceEnd ] ) || occurrenceEnd === sentence.length;
+
+	return ( ( previousCharacter ) && ( nextCharacter ) );
+};
+
+export {
+	characterInBoundary,
+	isWordInSentence,
+};
+
+export default {
+	characterInBoundary,
+	isWordInSentence,
+};

package/src/languageProcessing/helpers/word/splitIntoTokens.js

@@ -0,0 +1,46 @@
+import createPunctuationTokens from "./createPunctuationTokens";
+
+/*
+*  The following regex is used to split a text into tokens.
+ * The regex matches word separators. A word separator is either a whitespace, a slash, a
+ * tab, a non-breaking space, a hyphen, an en-dash or an em-dash.
+ * Opening and closing square brackets are added to deal correctly with shortcodes downstream.
+ * The regex is used to split a text into tokens.
+ * Do not add punctuation marks to this regex, as they are handled separately inside `createPunctuationTokens()`.
+ * The word separator explicitly only contains characters that split two words and not a word and a space.
+ * - A space is a word separator because it separates two words if it occurs between them. For example: "foo bar"
+ * - A tab is a word separator because it separates two words if it occurs between them. For example: "foo	bar"
+ * - A non-breaking space (u00A0) is a word separator because it separates two words if it occurs between them. For example: "foo\u00A0bar".
+ * - An en-dash (u2013), an em-dash (u2014), and a hyphen (u002d) are word separators because they separate two words if they occur between them.
+ *   For example: "foo–bar".
+ * Note that   is added here as #nbsp; -- we transform the & to # to prevent parse5 from converting it to a space and messing up highlighting.
+ */
+const WORD_SEPARATORS_REGEX = /([\s\t\u00A0\u2013\u2014\u002d[\]]|#nbsp;)/;
+
+/**
+ * Tokenizes a text similarly to `getWords`, but in a way that's suitable for the HTML parser.
+ * 1. It does not normalize whitespace.
+ * This operation is too risky for the HTML parser because it may throw away characters and as a result, the token positions are corrupted.
+ * 2. It does not remove punctuation marks but keeps them.
+ *
+ * This algorithm splits the text by word separators: tokens that are the border between two words.
+ * This algorithm separates punctuation marks from words and keeps them as separate tokens.
+ * It only splits them off if they appear at the start or the end of a word.
+ *
+ * @param {string} text The text to tokenize.
+ *
+ * @returns {string[]} 	An array of tokens.
+ */
+const splitIntoTokens = ( text ) => {
+	if ( ! text ) {
+		return [];
+	}
+
+	// Split the sentence string into tokens. Those tokens are unrefined as they may contain punctuation.
+	const rawTokens = text.split( WORD_SEPARATORS_REGEX ).filter( x => x !== "" );
+
+	// Remove punctuation from the beginning and end of word tokens, and make them into separate tokens.
+	return createPunctuationTokens( rawTokens );
+};
+
+export default splitIntoTokens;

package/src/languageProcessing/index.js

@@ -0,0 +1,91 @@
+import replaceDiacritics from './helpers/transliterate/replaceDiacritics';
+import transliterate from './helpers/transliterate/transliterate';
+import createRegexFromArray from './helpers/regex/createRegexFromArray';
+import imageInText from './helpers/image/imageInText';
+import stripSpaces from './helpers/sanitize/stripSpaces';
+import baseStemmer from './helpers/morphology/baseStemmer';
+import getWords from './helpers/word/getWords';
+import AbstractResearcher from './AbstractResearcher';
+import flattenSortLength from './helpers/morphology/flattenSortLength';
+import indices from './helpers/word/indices';
+import buildFormRule from './helpers/morphology/buildFormRule';
+import createRulesFromArrays, {
+  createSingleRuleFromArray
+} from './helpers/morphology/createRulesFromArrays';
+import matchRegularParticiples from './helpers/passiveVoice/periphrastic/matchRegularParticiples';
+import directPrecedenceException from './helpers/passiveVoice/periphrastic/directPrecedenceException';
+import precedenceException from './helpers/passiveVoice/periphrastic/precedenceException';
+import nonDirectPrecedenceException from './helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/nonDirectParticiplePrecedenceException';
+import findMatchingEndingInArray from './helpers/morphology/findMatchingEndingInArray';
+import * as regexHelpers from './helpers/morphology/regexHelpers';
+import * as exceptionListHelpers from './helpers/morphology/exceptionListHelpers';
+import * as stemHelpers from './helpers/morphology/stemHelpers';
+import * as values from './values';
+import areWordsInSentence from './helpers/word/areWordsInSentence';
+import getClauses from './helpers/passiveVoice/periphrastic/getClauses';
+import getClausesSplitOnStopWords from './helpers/passiveVoice/periphrastic/freeAuxiliaryParticipleOrder/getClausesSplitOnStopWords';
+import {
+  stripFullTags as stripHTMLTags,
+  stripBlockTagsAtStartEnd
+} from './helpers/sanitize/stripHTMLTags';
+import sanitizeString from './helpers/sanitize/sanitizeString';
+import {unifyAllSpaces} from './helpers/sanitize/unifyWhitespace';
+import removePunctuation from './helpers/sanitize/removePunctuation';
+import normalizeHTML from './helpers/html/normalizeHTML';
+import countMetaDescriptionLength from './helpers/word/countMetaDescriptionLength';
+import getLanguage from './helpers/language/getLanguage';
+import getSentences from './helpers/sentence/getSentences';
+import {getFieldsToMark} from './helpers/html/getFieldsToMark';
+import {normalizeSingle} from './helpers/sanitize/quotes';
+import parseSynonyms from './helpers/sanitize/parseSynonyms';
+import {mergeListItems} from './helpers/sanitize/mergeListItems';
+import {findWordFormsInString} from './helpers/match/findKeywordFormsInString';
+import {collectMarkingsInSentence, markWordsInSentences} from './helpers/word/markWordsInSentences';
+import * as helpers from './helpers';
+import * as researches from './researches';
+
+export {
+  AbstractResearcher,
+  transliterate,
+  replaceDiacritics,
+  createRegexFromArray,
+  imageInText,
+  stripSpaces,
+  baseStemmer,
+  getWords,
+  flattenSortLength,
+  indices,
+  buildFormRule,
+  createRulesFromArrays,
+  createSingleRuleFromArray,
+  matchRegularParticiples,
+  directPrecedenceException,
+  precedenceException,
+  nonDirectPrecedenceException,
+  findMatchingEndingInArray,
+  regexHelpers,
+  exceptionListHelpers,
+  stemHelpers,
+  areWordsInSentence,
+  values,
+  getClauses,
+  getClausesSplitOnStopWords,
+  stripHTMLTags,
+  stripBlockTagsAtStartEnd,
+  countMetaDescriptionLength,
+  sanitizeString,
+  removePunctuation,
+  getLanguage,
+  getSentences,
+  getFieldsToMark,
+  unifyAllSpaces,
+  normalizeHTML,
+  collectMarkingsInSentence,
+  normalizeSingle,
+  parseSynonyms,
+  mergeListItems,
+  findWordFormsInString,
+  markWordsInSentences,
+  helpers,
+  researches
+};

package/src/languageProcessing/languages/_default/Researcher.js

@@ -0,0 +1,34 @@
+import {languageProcessing} from '../../../index';
+const {AbstractResearcher} = languageProcessing;
+
+// All helpers
+import getStemmer from './helpers/getStemmer';
+
+/**
+ * The researcher contains all the researches, helpers, data, and config.
+ */
+export default class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+
+    // Deletes researches that are not available for languages that we haven't supported yet.
+    delete this.defaultResearches.getFleschReadingScore;
+    delete this.defaultResearches.getPassiveVoiceResult;
+    delete this.defaultResearches.getSentenceBeginnings;
+    delete this.defaultResearches.findTransitionWords;
+    delete this.defaultResearches.functionWordsInKeyphrase;
+
+    Object.assign(this.config, {
+      functionWords: []
+    });
+
+    Object.assign(this.helpers, {
+      getStemmer
+    });
+  }
+}

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

@@ -0,0 +1,11 @@
+import {languageProcessing} from '../../../index';
+const {baseStemmer} = languageProcessing;
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer() {
+  return baseStemmer;
+}

package/src/languageProcessing/languages/ar/Researcher.js

@@ -0,0 +1,46 @@
+import {languageProcessing} from '../../../index';
+const {AbstractResearcher} = languageProcessing;
+
+// All config
+import firstWordExceptions from './config/firstWordExceptions';
+import {all as functionWords} from './config/functionWords';
+import transitionWords from './config/transitionWords';
+import twoPartTransitionWords from './config/twoPartTransitionWords';
+import {PREFIXED_FUNCTION_WORDS_REGEX} from './config/prefixedFunctionWords';
+
+// All helpers
+import {createBasicWordForms} from './helpers/createBasicWordForms';
+import getStemmer from './helpers/getStemmer';
+import isPassiveSentence from './helpers/isPassiveSentence';
+
+/**
+ * The researcher contains all the researches, helpers, data, and config.
+ */
+export default class Researcher extends AbstractResearcher {
+  /**
+   * Constructor
+   * @param {Paper} paper The Paper object that is needed within the researches.
+   * @constructor
+   */
+  constructor(paper) {
+    super(paper);
+
+    delete this.defaultResearches.getFleschReadingScore;
+
+    Object.assign(this.config, {
+      language: 'ar',
+      passiveConstructionType: 'morphological',
+      firstWordExceptions,
+      functionWords,
+      transitionWords,
+      twoPartTransitionWords,
+      prefixedFunctionWordsRegex: PREFIXED_FUNCTION_WORDS_REGEX
+    });
+
+    Object.assign(this.helpers, {
+      createBasicWordForms,
+      getStemmer,
+      isPassiveSentence
+    });
+  }
+}

package/src/languageProcessing/languages/ar/config/firstWordExceptions.js

@@ -0,0 +1,14 @@
+/**
+ * Returns an array with exceptions for the sentence beginning researcher.
+ * @returns {Array} The array filled with exceptions.
+ */
+export default [
+	// Articles (those which are not prefixes):
+	"قليل", "بعض", "واحد",
+	// Numbers 1-10:
+	"واحد", "إثنان", "ثلاثة", "أربعة", "خمسة", "ستة", "سبعة", "ثمانية", "تسعة", "عشرة",
+	// Demonstrative pronouns:
+	"هذا", "هذه", "ذلك", "تلك", "هذين", "هذان", "هتين", "هتان", "هؤلا", "أولائك", "هؤلاء",
+];
+
+