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

package/src/languageProcessing/researches/keywordCountInUrl.js

@@ -0,0 +1,57 @@
+/** @module researches/keywordCountInSlug */
+import parseSlug from "../helpers/url/parseSlug";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString.js";
+import { cloneDeep } from "lodash";
+
+/**
+ * Matches the keyword in the slug. Replaces all dashes and underscores with whitespaces and uses whitespace as word boundary.
+ *
+ * @param {Paper} paper the Paper object to use in this count.
+ * @param {Researcher} researcher The Researcher object containing all available researches.
+ *
+ * @returns {{keyphraseLength: int, percentWordMatches: int}} The length of the keyphrase and the percentage of keyphrase forms that has been found.
+ */
+function keywordCountInSlug( paper, researcher ) {
+	/*
+	 * We want to override the `areHyphensWordBoundaries` config value from the researcher so that it is `true` for all
+	 * languages. This is because slugs usually use hyphens (or underscores) as word boundaries. So if only the slug is
+	 * split on hyphens and not the keyphrase forms, some keyphrase forms won't be found in the slug.
+	 */
+	const languageResearcher = cloneDeep( researcher );
+	languageResearcher.addConfig( "areHyphensWordBoundaries", true );
+	const topicForms = languageResearcher.getResearch( "morphology" );
+
+	const parsedSlug = parseSlug( paper.getSlug() );
+	const locale = paper.getLocale();
+
+	const keyphraseInSlug = findTopicFormsInString( topicForms, parsedSlug, false, locale, false );
+
+	return {
+		keyphraseLength: topicForms.keyphraseForms.length,
+		percentWordMatches: keyphraseInSlug.percentWordMatches,
+	};
+}
+
+/**
+ * Matches the keyword in the slug.
+ * keywordCountInUrl was the previous name for keywordCountInSlug (hence the name of this file).
+ * We keep (and expose) this research for backwards compatibility.
+ *
+ * @deprecated Since version 18.7. Use keywordCountInSlug instead.
+ *
+ * @param {Paper} paper the Paper object to use in this count.
+ * @param {Researcher} researcher The Researcher object containing all available researches.
+ *
+ * @returns {{keyphraseLength: int, percentWordMatches: int}} The length of the keyphrase and the percentage of keyphrase forms that has been found.
+ */
+function keywordCountInUrl( paper, researcher ) {
+	console.warn( "This function is deprecated, use keywordCountInSlug instead." );
+	return keywordCountInSlug( paper, researcher );
+}
+
+export {
+	keywordCountInSlug,
+	keywordCountInUrl,
+};
+
+export default keywordCountInSlug;

package/src/languageProcessing/researches/matchKeywordInSubheadings.js

@@ -0,0 +1,62 @@
+import { getSubheadingContentsTopLevel } from "../helpers/html/getSubheadings";
+import stripSomeTags from "../helpers/sanitize/stripNonTextTags";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+import { filterShortcodesFromHTML } from "../helpers";
+
+/**
+ * Computes the amount of subheadings reflecting the topic.
+ *
+ * @param {Object}      topicForms      The main key phrase and its synonyms to check.
+ * @param {string[]}    subheadings     The subheadings to check.
+ * @param {boolean}     useSynonyms     Whether to match synonyms or only main keyphrase.
+ * @param {string}      locale          The current locale.
+ * @param {Array}       functionWords	The function words list.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ *
+ * @returns {number} The amount of subheadings reflecting the topic.
+ */
+const numberOfSubheadingsReflectingTopic = function( topicForms, subheadings, useSynonyms, locale, functionWords, matchWordCustomHelper ) {
+	return subheadings.filter( subheading => {
+		const matchedTopicForms = findTopicFormsInString( topicForms, subheading, useSynonyms, locale, matchWordCustomHelper );
+
+		if ( functionWords.length === 0 ) {
+			return matchedTopicForms.percentWordMatches === 100;
+		}
+		return matchedTopicForms.percentWordMatches > 50;
+	} ).length;
+};
+
+/**
+ * Checks if there are any h2 or h3 subheadings in the text and if they have the keyphrase or synonyms in them.
+ *
+ * @param {Object}     paper      The paper object containing the text and keyword.
+ * @param {Researcher} researcher The researcher object.
+ *
+ * @returns {Object} The result object.
+ */
+export default function matchKeywordInSubheadings( paper, researcher ) {
+	const functionWords = researcher.getConfig( "functionWords" );
+
+	// A custom helper to match word in text.
+	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
+
+
+	let text = paper.getText();
+	text = removeHtmlBlocks( text );
+	text = filterShortcodesFromHTML( text, paper._attributes && paper._attributes.shortcodes );
+	text = stripSomeTags( text );
+	const topicForms = researcher.getResearch( "morphology" );
+	const locale = paper.getLocale();
+	const result = { count: 0, matches: 0, percentReflectingTopic: 0 };
+	const useSynonyms = true;
+	const subheadings = getSubheadingContentsTopLevel( text );
+
+	if ( subheadings.length !== 0 ) {
+		result.count = subheadings.length;
+		result.matches = numberOfSubheadingsReflectingTopic( topicForms, subheadings, useSynonyms, locale, functionWords, matchWordCustomHelper );
+		result.percentReflectingTopic = result.matches / result.count * 100;
+	}
+
+	return result;
+}

package/src/languageProcessing/researches/metaDescriptionKeyword.js

@@ -0,0 +1,85 @@
+import matchWords from "../helpers/match/matchTextWithArray";
+import getSentences from "../helpers/sentence/getSentences";
+
+/**
+ * Replaces found keyword forms in the given description.
+ *
+ * @param {string}      description         The description to remove the matched keyword forms from.
+ * @param {Object[]}    matchedKeywordForms The matched keyword forms to remove from the description.
+ * @param {Number}      maxToRemove         The maximum amount of matches of each individual keyword to remove.
+ *
+ * @returns {string} The description with the keywords removed.
+ */
+const replaceFoundKeywordForms = function( description, matchedKeywordForms, maxToRemove ) {
+	// Replace matches so we do not match them for synonyms.
+	matchedKeywordForms.forEach( keywordForm =>
+		keywordForm.matches.slice( 0, maxToRemove ).forEach(
+			match => {
+				description = description.replace( match, "" );
+			}
+		)
+	);
+	return description;
+};
+
+/**
+ * Counts the number of full keyphrase matches in the given sentence. Takes synonyms into account.
+ * A full keyphrase is when all keywords in the keyphrase match.
+ *
+ * @param {string}      sentence        The sentence that needs to be analyzed.
+ * @param {Object}      topicForms      The keyphrase (and its optional synonyms') word forms.
+ * @param {string}      locale          The current locale.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ *
+ * @returns {Number} The number of matched keyphrases in the sentence.
+ */
+const matchPerSentence = function( sentence, topicForms, locale, matchWordCustomHelper ) {
+	// Focus keyphrase matches.
+	const matchesKeyphrase = topicForms.keyphraseForms.map( keywordForms => matchWords( sentence, keywordForms, locale, matchWordCustomHelper ) );
+	// Count the number of matches that contain every word in the entire keyphrase.
+	const fullKeyphraseMatches = Math.min( ...matchesKeyphrase.map( match => match.count ) );
+
+	// Replace all full keyphrase matches so we do not match them for synonyms.
+	sentence = replaceFoundKeywordForms( sentence, matchesKeyphrase, fullKeyphraseMatches );
+
+	// Keyphrase synonyms matches.
+	const fullSynonymsMatches = topicForms.synonymsForms.map(
+		synonymForms => {
+			// Synonym keyphrase matches.
+			const matches = synonymForms.map( keywordForms => matchWords( sentence, keywordForms, locale, matchWordCustomHelper ) );
+			// Count the number of matches that contain every word in the entire synonym keyphrase.
+			const fullSynonymMatches = Math.min( ...matches.map( match => match.count ) );
+			// Replace all full matches so we do not match them for other synonyms.
+			sentence = replaceFoundKeywordForms( sentence, matchesKeyphrase, fullSynonymMatches );
+			return fullSynonymMatches;
+		}
+	);
+
+	return [ fullKeyphraseMatches, ...fullSynonymsMatches ].reduce( ( sum, count ) => sum + count, 0 );
+};
+
+/**
+ * Counts the number of full keyphrase matches in the description.
+ *
+ * @param {Paper}       paper       The paper object containing the description.
+ * @param {Researcher}  researcher  The researcher object to gather researchers from.
+ *
+ * @returns {Number} The number of keyphrase matches for the entire description.
+ */
+export default function( paper, researcher ) {
+	const description = paper.getDescription();
+	const locale = paper.getLocale();
+
+	const topicForms = researcher.getResearch( "morphology" );
+	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
+	const memoizedTokenizer = researcher.getHelper( "memoizedTokenizer" );
+
+	const sentences = getSentences( description, memoizedTokenizer );
+
+	const sentenceMatches = sentences.map(
+		sentence => matchPerSentence( sentence, topicForms, locale, matchWordCustomHelper )
+	);
+
+	return sentenceMatches.reduce( ( sum, count ) => sum + count, 0 );
+}
+

package/src/languageProcessing/researches/metaDescriptionLength.js

@@ -0,0 +1,12 @@
+import countMetaDescriptionLength from "../helpers/word/countMetaDescriptionLength";
+
+/**
+ * Count the meta description length.
+ *
+ * @param {Paper} paper The paper to check for images.
+ *
+ * @returns {number|*}  The meta description length.
+ */
+export default function metaDescriptionLength( paper ) {
+	return countMetaDescriptionLength( paper.getDate(), paper.getDescription() );
+}

package/src/languageProcessing/researches/pageTitleWidth.js

@@ -0,0 +1,11 @@
+/**
+ * Check the width of the title in pixels
+ * @param {Paper} paper The paper object containing the title width in pixels.
+ * @returns {number} The width of the title in pixels
+ */
+export default function( paper ) {
+	if ( paper.hasTitle() ) {
+		return paper.getTitleWidth();
+	}
+	return 0;
+}

package/src/languageProcessing/researches/readingTime.js

@@ -0,0 +1,82 @@
+import getLanguage from "../../languageProcessing/helpers/language/getLanguage";
+import wordCountInText from "./wordCountInText.js";
+import imageCount from "./imageCount.js";
+
+/**
+ * Calculates the expected reading time of a text.
+ *
+ * @param {Paper} paper The paper to calculate the reading time for.
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {number} The expected reading time in minutes for a given language.
+ */
+export default function( paper, researcher ) {
+	const language = getLanguage( paper.getLocale() );
+
+	// A helper to get words from the text for languages that don't use the default approach.
+	const customGetWords = researcher.getHelper( "getWordsCustomHelper" );
+	const countCharactersFromArray = researcher.getHelper( "wordsCharacterCount" );
+
+	/*
+	 * These numbers (both in `wordsPerMinute` and `charactersPerMinute`) are based on research into average reading times:
+	 * Susanne Trauzettel-Klosinski, Klaus Dietz, the IReST Study Group;
+	 * Standardized Assessment of Reading Performance: The New International Reading Speed Texts IReST.
+	 * Invest. Ophthalmol. Vis. Sci. 2012;53(9):5452-5461
+	 */
+	const wordsPerMinute = {
+		ar: 138,
+		cn: 158,
+		de: 179,
+		en: 228,
+		es: 218,
+		fi: 161,
+		fr: 195,
+		he: 187,
+		it: 188,
+		nl: 202,
+		pl: 166,
+		pt: 181,
+		ru: 184,
+		sl: 180,
+		sv: 199,
+		tr: 166,
+	};
+
+	const charactersPerMinute = {
+		ja: 357,
+	};
+
+
+	const wordsPerMinuteScore = wordsPerMinute[ language ];
+	const charactersPerMinuteScore = charactersPerMinute[ language ];
+
+	// The default approach of calculating the text length is by counting the words in the text.
+	let textLength = wordCountInText( paper ).count;
+	let minutesToReadText;
+
+	if ( charactersPerMinuteScore ) {
+		/*
+		 * If a language has a characters per minute score, we assume that the language also uses a character count helper
+		 * for retrieving the text length and a custom helper to get words from the text.
+		 */
+		textLength = countCharactersFromArray( customGetWords( paper.getText() ) );
+		minutesToReadText = textLength / charactersPerMinuteScore;
+	} else if ( wordsPerMinuteScore ) {
+		minutesToReadText = textLength / wordsPerMinuteScore;
+	} else {
+		// If the language is not on both lists, assign the average of all language-dependent reading times as the score.
+		const sumWordsPerMinute = Object.values( wordsPerMinute ).reduce( ( a, b ) => a + b );
+		const sumNumberOfLanguages = Object.keys( wordsPerMinute ).length;
+		minutesToReadText = textLength / ( sumWordsPerMinute / sumNumberOfLanguages );
+	}
+
+	const minutesPerImage = 0.2;
+	const numberOfImages = imageCount( paper );
+
+	/*
+	 * This formula is based on the average number of words a person is expected to read per minute,
+	 * plus extra time for each image in the text. It returns the expected reading time in whole minutes,
+	 * rounded up to the nearest minute.
+	 */
+	return Math.ceil( minutesToReadText + ( numberOfImages * minutesPerImage ) );
+}

package/src/languageProcessing/researches/sentences.js

@@ -0,0 +1,20 @@
+import getSentences from "../helpers/sentence/getSentences";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+import { filterShortcodesFromHTML } from "../helpers";
+
+/**
+ * Returns the sentences from a paper.
+ *
+ * @param {Paper}   paper       The paper to analyze.
+ * @param {object}  researcher  The researcher.
+ *
+ * @returns {Array} Sentences found in the paper.
+ */
+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 );
+	return getSentences( text, memoizedTokenizer );
+}

package/src/languageProcessing/researches/videoCount.js

@@ -0,0 +1,32 @@
+/**
+ * Checks the amount of videos in the text, including embedded video iframes and specific video sources.
+ *
+ * @param {Paper} paper The paper to check for videos.
+ *
+ * @returns {number} The amount of found videos.
+ */
+export default function countVideoInText(paper) {
+  // Regular expression to match <video> tags.
+  const videoTag = /<video.*?<\/video>/gis;
+
+  // Regular expression to match <iframe> tags with video sources (YouTube, Vimeo, Shopify CDN, etc.).
+  const iframeVideoTag = /<iframe[^>]*src=["']https?:\/\/(?:www\.)?(youtube\.com|youtu\.be|vimeo\.com|cdn\.shopify\.com)[^"']*["'][^>]*>/gis;
+
+  // Regular expression to match any src attributes with common video file extensions.
+  const videoSrcTag = /src=["'].*?\.(mp4|webm|ogg|mov|m4v|avi|mkv|flv|wmv)(\?.*?)?["']/gis;
+
+  // Match occurrences of <video> tags in the text.
+  const videoMatches = paper.getText().match(videoTag) || [];
+
+  // Match occurrences of <iframe> tags with video sources in the text.
+  const iframeVideoMatches = paper.getText().match(iframeVideoTag) || [];
+
+  // Match occurrences of src attributes pointing to video files in the text.
+  const videoSrcMatches = paper.getText().match(videoSrcTag) || [];
+
+  // Combine all matches into a single set to remove duplicates.
+  const allMatches = new Set([...videoMatches, ...iframeVideoMatches, ...videoSrcMatches]);
+
+  // Return the unique count of all found matches.
+  return allMatches.size;
+}

package/src/languageProcessing/researches/wordComplexity.js

@@ -0,0 +1,129 @@
+import { flatMap, get } from "lodash";
+
+import getSentences from "../helpers/sentence/getSentences";
+import getWords from "../helpers/word/getWords";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+import { filterShortcodesFromHTML } from "../helpers";
+import { findTopicFormsInString } from "../helpers/match/findKeywordFormsInString";
+
+/**
+ * An object containing the results of the complex words research for a single sentence.
+ *
+ * The structure of the data is:
+ * @example
+ * {
+ * complexWords: ["word1", "word2", "word3" ],
+ * sentence: "the sentence"
+ * }
+ *
+ * @typedef {Object} 	ComplexWordsResult
+ * @property {string[]}	complexWords	The complex words in the sentence.
+ * @property {string}	sentence		The sentence.
+ */
+
+/**
+ * Retrieves all complex words in a sentence.
+ *
+ * @param {string} 		currentSentence	The current sentence.
+ * @param {Researcher} 	researcher		The researcher object.
+ * @param {Object}      topicForms       The object with word forms of all (content) words from the keyphrase and eventually synonyms,
+ * comes in a shape {
+ *                     keyphraseForms: [[ form1, form2, ... ], [ form1, form2, ... ]],
+ *                     synonymsForms: [
+ *                          [[ form1, form2, ... ], [ form1, form2, ... ]],
+ *                          [[ form1, form2, ... ], [ form1, form2, ... ]],
+ *                          [[ form1, form2, ... ], [ form1, form2, ... ]],
+ *                     ],
+ *                  }
+ *
+ * @returns {ComplexWordsResult} An object containing all complex words in a given sentence.
+ */
+const getComplexWords = function( currentSentence, researcher, topicForms ) {
+	const language = researcher.getConfig( "language" );
+	const checkIfWordIsComplex = researcher.getHelper( "checkIfWordIsComplex" );
+	const functionWords = researcher.getConfig( "functionWords" );
+	const wordComplexityConfig = researcher.getConfig( "wordComplexity" );
+	const checkIfWordIsFunction = researcher.getHelper( "checkIfWordIsFunction" );
+	const premiumData = get( researcher.getData( "morphology" ), language, false );
+
+	// Retrieve all words from the sentence.
+	let words = getWords( currentSentence );
+
+	// Filters out keyphrase forms (but not synonyms) because we consider them not to be complex.
+	const matchWordCustomHelper = researcher.getHelper( "matchWordCustomHelper" );
+	const foundTopicForms = findTopicFormsInString( topicForms, currentSentence, false, researcher.paper.getLocale(), matchWordCustomHelper );
+	words = words.filter( word => ! foundTopicForms.matches.includes( word ) );
+
+	// Filters out function words because function words are not complex.
+	// Words are converted to lowercase before processing to avoid excluding function words that start with a capital letter.
+	words = words.filter( word => ! ( checkIfWordIsFunction ? checkIfWordIsFunction( word ) : functionWords.includes( word ) ) );
+
+	const result = {
+		complexWords: [],
+		sentence: currentSentence,
+	};
+
+	if ( ! premiumData ) {
+		return result;
+	}
+
+	words.forEach( word => {
+		if ( checkIfWordIsComplex( wordComplexityConfig, word, premiumData ) ) {
+			result.complexWords.push( word );
+		}
+	} );
+
+	return result;
+};
+
+/**
+ * Calculates the percentage of the complex words compared to the total words in the text.
+ *
+ * @param {ComplexWordsResult[]}	complexWordsResults	The array of complex words results.
+ * @param {string[]} 				words    			The array of words retrieved from the text.
+ *
+ * @returns {number} The percentage of the complex words compared to the total words in the text.
+ */
+const calculateComplexWordsPercentage = function( complexWordsResults, words ) {
+	const totalComplexWords = flatMap( complexWordsResults, result => result.complexWords );
+	const percentage = ( totalComplexWords.length / words.length ) * 100;
+
+	// If the number is a decimal, round it to two numbers after the period, e.g. 5.12345 -> 5.12.
+	// This approach is inspired from this thread: https://stackoverflow.com/questions/11832914/how-to-round-to-at-most-2-decimal-places-if-necessary.
+	return +percentage.toFixed( 2 );
+};
+
+/**
+ * Gets the complex words from the sentences and calculates the percentage of complex words compared to the total words in the text.
+ * This is a research for the Word Complexity assessment. As such, this research is not part of the AbstractResearcher, and not bundled in Yoast SEO.
+ *
+ * @param {Paper}       paper       The Paper object to get the text from.
+ * @param {Researcher}  researcher  The researcher object.
+ *
+ * @returns {{complexWords: ComplexWordsResult[], percentage: number}}
+ * The complex words found and their percentage compared to the total words in the text.
+ */
+export default function wordComplexity( 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 );
+
+	const topicForms = researcher.getResearch( "morphology" );
+	// Find the complex words in each sentence.
+	let results = sentences.map( sentence => getComplexWords( sentence, researcher, topicForms ) );
+
+	// Remove sentences without complex words.
+	results = results.filter( result => result.complexWords.length !== 0 );
+
+	// Calculate the percentage of complex words in the text as a whole.
+	const words = getWords( text );
+	const percentage = calculateComplexWordsPercentage( results, words );
+
+	return {
+		complexWords: results,
+		percentage: percentage,
+	};
+}
+

package/src/languageProcessing/researches/wordCountInText.js

@@ -0,0 +1,29 @@
+import wordCount from "../helpers/word/countWords.js";
+import removeHtmlBlocks from "../helpers/html/htmlParser";
+import { filterShortcodesFromHTML } from "../helpers";
+
+/**
+ * A result of the word count calculation.
+ *
+ * @typedef WordCountResult
+ * @param {number} count The number of words found in the text.
+ * @param {"word"} unit The unit used in the text length calculations, always "word".
+ */
+
+/**
+ * Count the words in the text.
+ *
+ * @param {Paper} paper The Paper object.
+ *
+ * @returns {WordCountResult} The number of words found in the text, plus "word" as the unit used in calculating the text length.
+ */
+export default function( paper ) {
+	let text = paper.getText();
+	text = removeHtmlBlocks( text );
+	text = filterShortcodesFromHTML( text, paper._attributes && paper._attributes.shortcodes );
+	return {
+		text: text,
+		count: wordCount( text ),
+		unit: "word",
+	};
+}

package/src/languageProcessing/values/Clause.js

@@ -0,0 +1,108 @@
+/**
+ * Sentence clause which should be checked for passiveness.
+ *
+ */
+class Clause {
+	/**
+	 * Constructs a clause object.
+	 *
+	 * @param {string} clauseText The text in the clause.
+	 * @param {Array} auxiliaries The auxiliaries in the clause.
+	 *
+	 * @constructor
+	 */
+	constructor( clauseText, auxiliaries ) {
+		this._clauseText = clauseText;
+		this._auxiliaries = auxiliaries;
+		this._isPassive = false;
+		this._participles = [];
+	}
+	/**
+	 * Returns the clause text.
+	 *
+	 * @returns {string} The clause text.
+	 */
+	getClauseText() {
+		return this._clauseText;
+	}
+
+	/**
+	 * Returns true if the clause is passive.
+	 *
+	 * @returns {boolean} Whether the clause is passive.
+	 */
+	isPassive() {
+		return this._isPassive;
+	}
+
+	/**
+	 * Returns the auxiliaries of the clause.
+	 *
+	 * @returns {Array} The auxiliaries present in the clause.
+	 */
+	getAuxiliaries() {
+		return this._auxiliaries;
+	}
+
+	/**
+	 * Sets the passiveness of the clause.
+	 *
+	 * @param {boolean} passive	 Whether the clause is passive.
+	 *
+	 * @returns {void}
+	 */
+	setPassive( passive ) {
+		this._isPassive = passive;
+	}
+
+	/**
+	 * Sets the participles.
+	 *
+	 * @param {Array} participles	The participles.
+	 *
+	 * @returns {void}
+	 */
+	setParticiples( participles ) {
+		this._participles = participles;
+	}
+
+	/**
+	 * Returns the found participles.
+	 *
+	 * @returns {Array} The participles
+	 */
+	getParticiples() {
+		return this._participles;
+	}
+
+	/**
+	 * Serializes the Clause instance to an object.
+	 *
+	 * @returns {Object} The serialized Clause.
+	 */
+	serialize() {
+		return {
+			_parseClass: "Clause",
+			clauseText: this._clauseText,
+			auxiliaries: this._auxiliaries,
+			isPassive: this._isPassive,
+			participles: this._participles,
+		};
+	}
+
+	/**
+	 * Parses the object to a Clause.
+	 *
+	 * @param {Object} serialized The serialized object.
+	 *
+	 * @returns {Clause} The parsed Clause.
+	 */
+	static parse( serialized ) {
+		const clause = new Clause( serialized.clauseText, serialized.auxiliaries );
+		clause.setPassive( serialized.isPassive );
+
+		return clause;
+	}
+}
+
+export default Clause;