axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.21

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

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

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

@@ -1,44 +0,0 @@
-/**
- * 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

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

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

@@ -1,9 +0,0 @@
-
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,151 +0,0 @@
-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 );
-}