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

package/src/parse/build/private/combineIntoImplicitParagraphs.js

@@ -0,0 +1,130 @@
+import isPhrasingContent from "./isPhrasingContent";
+import { Paragraph } from "../../structure";
+import { isEmpty } from "lodash";
+import SourceCodeLocation from "../../structure/SourceCodeLocation";
+
+/**
+ * Checks whether a node is inter-element whitespace.
+ *
+ * @see https://html.spec.whatwg.org/#inter-element-whitespace
+ *
+ * @param {Object} node The node to check.
+ *
+ * @returns {boolean} Whether the node is inter-element whitespace.
+ */
+function isInterElementWhitespace( node ) {
+	return node.name === "#text" && node.value && node.value.match( /^[\n\s]+$/g );
+}
+
+/**
+ * Checks whether a node has any children.
+ *
+ * @param {Object} node The node to check.
+ *
+ * @returns {boolean} Whether the node has any children.
+ */
+function hasChildren( node ) {
+	return node && node.childNodes.length > 0;
+}
+
+/**
+ * Updates the source code location of an implicit paragraph based on its children.
+ * @param {Paragraph} implicitParagraph The implicit paragraph to update.
+ * @returns {void}
+ */
+const updateImplicitParagraphLocation = ( implicitParagraph ) => {
+	const [ firstChild ] = implicitParagraph.childNodes.slice( 0 );
+	const [ lastChild ] = implicitParagraph.childNodes.slice( -1 );
+	if ( ( firstChild.sourceCodeRange || firstChild.sourceCodeLocation ) && ( lastChild.sourceCodeRange || lastChild.sourceCodeLocation ) ) {
+		const startOffset = firstChild.sourceCodeRange ? firstChild.sourceCodeRange.startOffset : firstChild.sourceCodeLocation.startOffset;
+		const endOffset = lastChild.sourceCodeRange ? lastChild.sourceCodeRange.endOffset : lastChild.sourceCodeLocation.endOffset;
+		implicitParagraph.sourceCodeLocation = new SourceCodeLocation( { startOffset: startOffset, endOffset: endOffset } );
+	}
+};
+
+/**
+ * Checks whether the current node is part of a double line break.
+ * @param {Node} currentNode The current node.
+ * @param {Node} prevNode The previous node (if available).
+ * @param {Node} nextNode The next node (if available).
+ * @returns {boolean} Whether the current node is part of a double line break
+ */
+const isPartOfDoubleBreak = ( currentNode, prevNode, nextNode ) => {
+	const prevNodeIsBreak = prevNode && prevNode.name === "br";
+	const nextNodeIsBreak = nextNode && nextNode.name === "br";
+	return currentNode.name === "br" && ( prevNodeIsBreak || nextNodeIsBreak );
+};
+
+/**
+ * Combines series of consecutive phrasing content ("inline" tags like `a` and `span`, and text) into implicit paragraphs.
+ *
+ * @see https://html.spec.whatwg.org/#paragraphs
+ *
+ * @param {Array} nodes The nodes to combine where able to.
+ * @param {Object} parentSourceCodeLocation This parent node's location in the source code, from parse5.
+ *
+ * @returns {Array} The combined nodes.
+ */
+function combineIntoImplicitParagraphs( nodes, parentSourceCodeLocation = {} ) {
+	const newNodes = [];
+	let currentSourceCodeLocation = {};
+	// For implicit paragraphs, strip off the start and end tag information from the parent's source code location.
+	if ( isEmpty( parentSourceCodeLocation ) ) {
+		const firstNode = nodes[ 0 ];
+		const lastNode = nodes[ nodes.length - 1 ];
+
+		if ( firstNode && lastNode && firstNode.sourceCodeLocation && lastNode.sourceCodeLocation ) {
+			currentSourceCodeLocation = new SourceCodeLocation( {
+				startOffset: firstNode.sourceCodeLocation.startOffset,
+				endOffset: lastNode.sourceCodeLocation.endOffset,
+			} );
+		}
+	} else {
+		currentSourceCodeLocation = new SourceCodeLocation( {
+			startOffset: parentSourceCodeLocation.startTag
+				? parentSourceCodeLocation.startTag.endOffset
+				: parentSourceCodeLocation.startOffset,
+			endOffset: parentSourceCodeLocation.endTag
+				? parentSourceCodeLocation.endTag.startOffset
+				: parentSourceCodeLocation.endOffset,
+		} );
+	}
+
+	let implicitParagraph = Paragraph.createImplicit( {}, [], currentSourceCodeLocation );
+	nodes.forEach( ( node, index, allNodes ) => {
+		const prevNode = 0 !== index && allNodes[ index - 1 ];
+		const nextNode = allNodes.length - 1 !== index && allNodes[ index + 1 ];
+
+		if ( isPhrasingContent( node.name ) && ! isInterElementWhitespace( node ) && ! isPartOfDoubleBreak( node, prevNode, nextNode ) ) {
+			// If the node is phrasing content, add it to the implicit paragraph.
+			implicitParagraph.childNodes.push( node );
+		} else {
+			// If the node is not phrasing content, this means that the implicit paragraph has ended.
+			if ( hasChildren( implicitParagraph ) ) {
+				// If the implicit paragraph has children this means an implicit paragraph was created:
+				// end the current implicit paragraph and start a new one.
+
+				// But before pushing, we need to update the source code location of the implicit paragraph based on its child nodes.
+				updateImplicitParagraphLocation( implicitParagraph );
+
+				// Update the startOffset of the next implicit paragraph to be the end of the current node.
+				if ( node.sourceCodeLocation ) {
+					currentSourceCodeLocation.startOffset = node.sourceCodeLocation.endOffset;
+				}
+
+				newNodes.push( implicitParagraph );
+				implicitParagraph = Paragraph.createImplicit( {}, [], currentSourceCodeLocation );
+			}
+			newNodes.push( node );
+		}
+	} );
+
+	if ( hasChildren( implicitParagraph ) ) {
+		updateImplicitParagraphLocation( implicitParagraph );
+
+		newNodes.push( implicitParagraph );
+	}
+	return newNodes;
+}
+
+export default combineIntoImplicitParagraphs;

package/src/parse/build/private/filterBeforeTokenizing.js

@@ -0,0 +1,32 @@
+import { isEmpty } from "lodash";
+import { canBeChildOfParagraph as excludeFromAnalysis } from "./alwaysFilterElements";
+
+/**
+ * Removes all child nodes from nodes that we want to exclude from the analysis, and that can be children of a paragraph
+ * or heading.
+ *
+ * The child nodes are removed because we don't want to include any text between those nodes in the analysis.
+ * If we don't remove them here, the text between those nodes will be considered as part of the paragraph's
+ * inner text and will be tokenized.
+ *
+ * These changes are only necessary for elements that can be children of paragraphs or headings. For example, we also
+ * don't want to analyze content in between `blockquote` tags, but these cannot be children of paragraphs/headings.
+ * Because of that, they wouldn't interfere with tokenizing the text inside paragraphs and headings and calculating
+ * the positions.
+ *
+ * @param {Node} node The node to check.
+ *
+ * @returns {Node} The filtered out node that's ready to be tokenized.
+ */
+export function filterBeforeTokenizing( node ) {
+	if ( excludeFromAnalysis.includes( node.name ) ) {
+		node.childNodes = [];
+	}
+
+	// Recursively filters the node's children.
+	if ( ! isEmpty( node.childNodes ) ) {
+		node.childNodes.map( filterBeforeTokenizing );
+	}
+
+	return node;
+}

package/src/parse/build/private/filterHelpers.js

@@ -0,0 +1,44 @@
+/**
+ * Filter helpers for the html tree filter.
+ * All helpers are functions that return a callback with the element as the only argument.
+ */
+
+
+/**
+ * Creates a callback that checks if an element has a specific name.
+ *
+ * @param {string} name The name to check.
+ *
+ * @returns {function(*)} A function that returns true if the element has a specific name.
+ */
+export function elementHasName( name ) {
+	return ( element ) => {
+		return element.name === name;
+	};
+}
+
+/**
+ * Creates a callback that checks the class of an element.
+ *
+ * @param {string} className The classname to filter out.
+ *
+ * @returns {function(*): boolean} A function that returns true if a Node has a certain class.
+ */
+export function elementHasClass( className ) {
+	return ( blockElement ) => {
+		return !! blockElement.attributes.class && blockElement.attributes.class.has( className );
+	};
+}
+
+/**
+ * Creates a callback that checks if an element has a certain ID.
+ *
+ * @param {string} id The ID we want to check against.
+ *
+ * @returns {function(*): boolean}  A function that returns true if an element has a certain ID.
+ */
+export function elementHasID( id ) {
+	return ( element ) => {
+		return element.attributes.id === id;
+	};
+}

package/src/parse/build/private/filterTree.js

@@ -0,0 +1,42 @@
+import { Paragraph } from "../../structure";
+
+/**
+ * Checks if a node should be kept or discarded.
+ * @param {Node} 		node 		A node.
+ * @param {Function[]} 	filters 	An array of filter callbacks.
+ * @returns {boolean} True if the node should be kept, false if the node should be discarded.
+ */
+function shouldRemoveNode( node, filters ) {
+	// Always keep text nodes.
+	if ( node.name === "#text" ) {
+		return false;
+	}
+
+	// If any of the filters returns true, the node will be discarded.
+	return filters.some( filter => filter( node ) );
+}
+
+/**
+ * A recursive function that removes all nodes based on an array of filters.
+ * @param {Node} 		node 		A node. (Could be the entire tree.)
+ * @param {Function[]} 	filters 	An array of callbacks. If a callback returns true, the node is discarded.
+ * @returns {Node|undefined} A Node with all undesired subtrees removed.
+ */
+export default function filterTree( node, filters ) {
+	// Returns undefined when the node should be disregarded.
+	if ( shouldRemoveNode( node, filters ) ) {
+		return;
+	}
+
+	// Recursively filters the node's children.
+	if ( node.childNodes ) {
+		node.childNodes = node.childNodes.filter( childNode => filterTree( childNode, filters ) );
+
+		// Drops implicit paragraphs if all their child nodes have been removed.
+		if ( node.childNodes.length === 0 && node instanceof Paragraph && node.isImplicit ) {
+			return;
+		}
+	}
+
+	return node;
+}

package/src/parse/build/private/getTextElementPositions.js

@@ -0,0 +1,184 @@
+import { Paragraph } from "../../structure";
+import { canBeChildOfParagraph as excludeFromAnalysis } from "./alwaysFilterElements";
+
+/**
+ * Gets the start and end positions of all descendant nodes' tags and stores them in an array.
+ * Each object in the array represents an opening or closing tag for nodes that have tags, or the full node for nodes
+ * without tags (such as 'comment' nodes).
+ * The startOffset and endOffset properties of the objects correspond to the start and end positions of the tags, or the
+ * start and end positions of the full node for nodes without tags.
+ * Extracting this data into a separate array makes it easier to work with it (e.g. sort it and loop over it).
+ *
+ * @param {Node[]} descendantNodes	The descendant nodes to get positions from.
+ *
+ * @returns {SourceCodeRange[]}	An array of the locations of each start and end tag in the source code, or the start and
+ * 								end locations of the full node for nodes without tags.
+ *
+ */
+function getDescendantPositions( descendantNodes ) {
+	const descendantTagPositions = [];
+	descendantNodes.forEach( ( node ) => {
+		/*
+		 * For nodes whose content we don't want to analyze, we should add the length of the full node to the array, to
+		 * still take into account the whole element's length when calculating positions.
+		 */
+		if ( excludeFromAnalysis.includes( node.name ) ) {
+			descendantTagPositions.push( node.sourceCodeLocation );
+		} else {
+			if ( node.sourceCodeLocation.startTag ) {
+				const startRange = {
+					startOffset: node.sourceCodeLocation.startTag.startOffset,
+					endOffset: node.sourceCodeLocation.startTag.endOffset,
+				};
+				/*
+				 * Here, we need to account for the fact that earlier (in innerText.js), we treated a <br> as a newline character.
+				 * Therefore, we need to subtract 1 from the endOffset to not count it twice.
+				 */
+				if ( node.name === "br" ) {
+					startRange.endOffset = startRange.endOffset - 1;
+				}
+				descendantTagPositions.push( startRange );
+			}
+			/*
+			 * Check whether node has an end tag before adding it to the array.
+			 * Some nodes, such as the 'img' node, only have a start tag.
+			 */
+			if ( node.sourceCodeLocation.endTag ) {
+				descendantTagPositions.push( node.sourceCodeLocation.endTag );
+			}
+		}
+	} );
+	// Sort the tag position objects by the start tag position in ascending order.
+	descendantTagPositions.sort( ( a, b ) => a.startOffset - b.startOffset );
+
+	return descendantTagPositions;
+}
+
+/**
+ * Adjusts the end position of the text element to account for descendant node tags that overlap with the text element.
+ * We want to add the length of tags that are directly preceding the start of the text, or that are between the start
+ * and end of the text, to the end position of the text element.
+ * For example, if the text is "<span><em>Hello</em>, world!</span>", the length of all tags except for the closing
+ * </span> tag should be added to the end position of the sentence.
+ *
+ * @param {SourceCodeRange[]}	descendantTagPositions	The positions of the descendant nodes' tags.
+ * @param {number}				textElementStart		The start position of a text element.
+ * @param {number}				textElementEnd			The end position of a text element.
+ *
+ * @returns {number}	The adjusted end position of the text element.
+ */
+function adjustElementEnd( descendantTagPositions, textElementStart, textElementEnd ) {
+	/*
+	 * If the start position of a descendant's node tag is between the start and end position of the text element, or is
+	 * the same as the start position of the text element, add the tag's length to the end position of the text element.
+	 */
+	descendantTagPositions.forEach( ( position ) => {
+		if ( position.startOffset >= textElementStart && position.startOffset < textElementEnd ) {
+			textElementEnd += ( position.endOffset - position.startOffset );
+		}
+	} );
+
+	return textElementEnd;
+}
+
+/**
+ * Adjusts the start position of the text element to exclude descendant node tags at the beginning of the text element.
+ * For example, the start position of the text element `<span>Hello!</span>`
+ * should be adjusted to start at the `H`, not at the start tag of the opening `<span>` tag.
+ * @param {SourceCodeRange[]} descendantTagPositions The positions of the descendant nodes' tags.
+ * @param {Number} textElementStart The start position of a text element.
+ *
+ * @returns {Number} The adjusted start position of the text element.
+ */
+function adjustTextElementStart( descendantTagPositions, textElementStart ) {
+	/*
+	 * If the start position of a descendant's node tag is between the start and end position of the text element, or is
+	 * the same as the start/end position of the text element, add the tag's length to the end position of the text element.
+	 */
+	descendantTagPositions.forEach( ( position ) => {
+		if ( position.startOffset === textElementStart ) {
+			textElementStart += ( position.endOffset - position.startOffset );
+		}
+	} );
+
+	return textElementStart;
+}
+
+/**
+ * Retrieves the initial start offset for the first text element.
+ * Normally, that is the end offset of the start tag of the parent node.
+ * In case of implicit paragraphs, we use the start offset of the node as a whole.
+ *
+ * @param {Paragraph|Heading} node The node to retrieve the start position from.
+ * @returns {number} The start offset for the first text element.
+ */
+const getTextElementStart = ( node ) => {
+	return node instanceof Paragraph && node.isImplicit
+		? node.sourceCodeLocation.startOffset
+		: node.sourceCodeLocation.startTag.endOffset;
+};
+
+/**
+ * Gets the start and end positions of text elements (sentences or tokens) in the source code.
+ *
+ * @param {Paragraph|Heading} 		node  			The paragraph or heading node.
+ * @param {Sentence[]|Token[]} 		textElements 	The sentences or tokens in the node.
+ * @param {number} 					startOffset 	The start position of the node in the source code.
+ * Defaults to -1 which signals that it should not be used.
+ *
+ * @returns {Sentence[]|Token[]} The sentences or tokens, with their positions in the source code.
+ */
+export default function getTextElementPositions( node, textElements, startOffset = -1 ) {
+	// We cannot calculate positions if there are no text elements, or if we don't know the node's source code location.
+	if (  textElements.length === 0 || ! node.sourceCodeLocation ) {
+		return textElements;
+	}
+
+	/*
+	 * Set the (initial) start offset of the first text element.
+	 * If the start offset has been provided (in the case of Tokens), use that.
+	 * Otherwise, determine the start offset from the parent Paragraph or Heading node.
+	 */
+	let textElementStart = startOffset >= 0 ? startOffset : getTextElementStart( node );
+
+	let textElementEnd;
+	let descendantTagPositions = [];
+
+	/*
+	 * Check if the node has any descendant nodes that have a sourceCodeLocation property (all nodes other than Text nodes
+	 * should have this property). If such nodes exist, store the positions of each node's opening and closing tags in
+	 * an array. These positions will have to be taken into account when calculating the position of the text elements.
+	 */
+	if ( node.findAll ) {
+		const descendantNodes = node.findAll( descendantNode => descendantNode.sourceCodeLocation, true );
+		if ( descendantNodes.length > 0 ) {
+			descendantTagPositions = getDescendantPositions( descendantNodes );
+		}
+	}
+
+	textElements.forEach( ( textElement ) => {
+		// Set the end position to the start position + the length of the textElement.
+		textElementEnd = textElementStart + textElement.text.length;
+
+		/*
+		 * If there are descendant tags, possibly adjust the textElementEnd and textElementStart.
+		 * The textElementEnd should be adjusted to include the length of any descendant tags until the end of the text, in
+		 * addition to the length of the text itself. Descendant tags AFTER the end of the text should not be included.
+		 * The textElementStart should be adjusted so that it is where the actual text starts, not including any descendant
+		 * tags preceding the text.
+		 */
+		if ( descendantTagPositions.length > 0 ) {
+			textElementEnd = adjustElementEnd( descendantTagPositions, textElementStart, textElementEnd );
+
+			textElementStart = adjustTextElementStart( descendantTagPositions, textElementStart );
+		}
+
+		// Add the start and end positions to the textElement object.
+		textElement.sourceCodeRange = { startOffset: textElementStart, endOffset: textElementEnd };
+
+		// Start position of the next textElement is the end position of current textElement.
+		textElementStart = textElementEnd;
+	} );
+
+	return textElements;
+}

package/src/parse/build/private/helpers/parseClassAttribute.js

@@ -0,0 +1,9 @@
+
+/**
+ * When splits a string of html classes into a set html classes.
+ * @param {string} classString The value of the class attribute.
+ * @returns {Set} A set containing all individual values of the class.
+ */
+export default function parseClassAttribute( classString ) {
+	return new Set( classString.split( " " ) );
+}

package/src/parse/build/private/isPhrasingContent.js

@@ -0,0 +1,28 @@
+/**
+ * Tag names of HTML elements that are considered phrasing content
+ * in the HTML content model.
+ *
+ * @see https://html.spec.whatwg.org/#phrasing-content
+ *
+ * @type {string[]}
+ */
+const phrasingContentTags = [
+	"b", "big", "i", "small", "tt", "abbr", "acronym", "cite", "code", "dfn", "em", "kbd", "strong",
+	"samp", "time", "var", "a", "bdo", "br", "img", "map", "object", "q", "script", "span", "sub", "sup", "button",
+	"input", "label", "select", "textarea",
+];
+
+/**
+ * Checks whether a node is considered phrasing content.
+ *
+ * @see https://html.spec.whatwg.org/#phrasing-content
+ *
+ * @param {string} nodeName The name/tag of the node to check if it is phrasing content.
+ *
+ * @returns {boolean} Whether the node is phrasing content.
+ */
+function isPhrasingContent( nodeName ) {
+	return phrasingContentTags.includes( nodeName ) || nodeName === "#text";
+}
+
+export default isPhrasingContent;

package/src/parse/build/private/parseBlocks.js

@@ -0,0 +1,151 @@
+import { isUndefined } from "lodash";
+const blockTokenizer = /<!--\s+wp:([a-z][a-z0-9_-]*\/)?([a-z][a-z0-9_-]*)\s+({(?:(?=([^}]+|}+(?=})|(?!}\s+\/?-->)[^])*)\5|[^]*?)}\s+)?(\/)?-->/g;
+
+/**
+ * Get all the blocks including the inner blocks.
+ *
+ * @param {Paper} paper The paper to get all the blocks from.
+ *
+ * @returns {Object[]} An array of blocks.
+ */
+const getAllBlocks = ( paper ) => {
+	const blocks = paper._attributes.wpBlocks;
+	const flattenBlocks = [];
+	if ( ! ( blocks && blocks.length > 0 ) ) {
+		return [];
+	}
+	blocks.forEach( ( block ) => {
+		if ( block.innerBlocks.length > 0 ) {
+			const innerBlocks = block.innerBlocks;
+			flattenBlocks.push(
+				block, ...innerBlocks
+			);
+		} else {
+			flattenBlocks.push( block );
+		}
+	} );
+	return flattenBlocks;
+};
+
+
+/**
+ * Gets the offset of each block and set it to the tree.
+ *
+ * @param {Object[]}	blocks An array of blocks.
+ * @param {string}		text The text.
+ *
+ * @returns {void}
+ */
+export function updateBlocksOffset( blocks, text ) {
+	if ( blocks.length === 0 ) {
+		return;
+	}
+	blocks.forEach( ( currentBlock, index ) => {
+		const matches = blockTokenizer.exec( text );
+		if ( currentBlock.name === "core/freeform" ) {
+			const previousBlock = blocks[ index - 1 ];
+			if ( previousBlock ) {
+				const previousBlockEndOffset = previousBlock.endOffset;
+				const startedAt = previousBlockEndOffset + 2;
+				currentBlock.startOffset = startedAt;
+				currentBlock.endOffset = startedAt + currentBlock.blockLength;
+				currentBlock.contentOffset = startedAt;
+			} else {
+				currentBlock.startOffset = 0;
+				currentBlock.endOffset = 0 + currentBlock.blockLength;
+				currentBlock.contentOffset = 0;
+			}
+		} else {
+			if ( null === matches ) {
+				return;
+			}
+			const [ match ] = matches;
+			const startedAt = matches.index;
+			const length = match.length;
+			currentBlock.startOffset = startedAt;
+			currentBlock.endOffset = startedAt + currentBlock.blockLength;
+			currentBlock.contentOffset = startedAt + length + 1;
+		}
+
+		if ( currentBlock.innerBlocks && currentBlock.innerBlocks.length > 0 ) {
+			updateBlocksOffset( currentBlock.innerBlocks, text );
+		}
+	} );
+}
+
+
+/**
+ * Gets the client id for each block and set it to the child nodes.
+ * Additionally, when a node has an attribute with 'id' key, also set this id to the first.
+ *
+ * @param {Node}		rootNode The root node.
+ * @param {Object[]}	blocks An array of blocks.
+ * @param {string}		clientId The client id to set.
+ *
+ * @returns {void}
+ */
+function updateClientIdAndAttrIdForSubtree( rootNode, blocks, clientId ) {
+	if ( ! rootNode ) {
+		return;
+	}
+
+	let currentClientId = clientId;
+	if ( rootNode.sourceCodeLocation && ! isUndefined( rootNode.sourceCodeLocation.startOffset ) ) {
+		const foundBlock = blocks.find( block => block.contentOffset === rootNode.sourceCodeLocation.startOffset );
+		if ( foundBlock ) {
+			currentClientId = foundBlock.clientId;
+		}
+	}
+
+	// If the clientId is not undefined, also set this to the root node.
+	if ( currentClientId ) {
+		rootNode.clientId = currentClientId;
+	}
+
+	// If the node has children, update the clientId for them.
+	( rootNode.childNodes || [] ).forEach( ( node ) => {
+		if ( node.attributes && node.attributes.id ) {
+			/*
+			 * If the node's child has an attribute with 'id' key, also set this id to the first and third child node.
+			 * This step is specifically for parsing the Yoast blocks.
+			 *
+			 * For Yoast blocks, if a node has attribute with 'id' key, this means that this node represents a sub-block.
+			 * A sub-block has four child nodes:
+			 * 1. The first child node of the sub-block, represents the first section of that sub-block.
+			 *    - For example, in Yoast FAQ block, the first child node would represent the "question" section.
+			 * 2. The second child node of the sub-block, only contains a new line.
+			 * 3. The third child node of the sub-block, represents the second section of that sub-block.
+			 *    - For example, in Yoast FAQ block, the second child node would represent the "answer" section.
+			 * 4. The fourth child node of the sub-block, only contains a new line.
+			 */
+			if ( node.childNodes && node.childNodes.length > 3 ) {
+				node.childNodes[ 0 ].attributeId = node.attributes.id;
+				node.childNodes[ 0 ].isFirstSection = true;
+
+				node.childNodes[ 2 ].attributeId = node.attributes.id;
+				node.childNodes[ 2 ].isFirstSection = false;
+			}
+		}
+		updateClientIdAndAttrIdForSubtree( node, blocks, currentClientId );
+	} );
+}
+
+/**
+ * Parses blocks and updates the clientId for the subtree.
+ * Additionally, when a node has an attribute with 'id' key, also set this id to the first and third child node of that node.
+ *
+ * @param {Paper} paper The paper to parse.
+ * @param {Node} node	The node to parse.
+ *
+ * @returns {void}
+ */
+export default function( paper, node ) {
+	const blocks = paper._attributes.wpBlocks || [];
+	blockTokenizer.lastIndex = 0;
+	updateBlocksOffset( blocks, paper.getText() );
+
+	const rawBlocks = getAllBlocks( paper );
+
+	// eslint-disable-next-line no-undefined
+	updateClientIdAndAttrIdForSubtree( node, rawBlocks, undefined );
+}