axyseo 2.0.0-alpha.0.0.4 → 2.0.0-alpha.0.0.6

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

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

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

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-/**
- * 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:
-	"هذا", "هذه", "ذلك", "تلك", "هذين", "هذان", "هتين", "هتان", "هؤلا", "أولائك", "هؤلاء",
-];
-
-