ngx-dynamic-hooks
Version:
Automatically insert live Angular components into a dynamic string of content (based on their selector or any pattern of your choice) and render the result in the DOM.
410 lines • 71.2 kB
JavaScript
import { Injectable } from '@angular/core';
import { anchorAttrHookId, anchorAttrParseToken, anchorElementTag } from '../../constants/core';
import { matchAll } from '../utils/utils';
import * as i0 from "@angular/core";
import * as i1 from "../platform/autoPlatformService";
import * as i2 from "../utils/logger";
const findInElementsNodePlaceholder = '_ngx_dynamic_hooks_node_placeholder';
/**
* The service responsible for finding text hooks in the content and replacing them with component anchors
*/
export class TextHookFinder {
constructor(platformService, logger) {
this.platformService = platformService;
this.logger = logger;
}
/**
* Finds all text hooks in an existing element and creates the corresponding anchors
*
* @param element - The element to parse
* @param context - The current context object
* @param parsers - The parsers to use
* @param token - The current parse token
* @param options - The current ParseOptions
* @param hookIndex - The hookIndex object to fill
*/
findInElement(element, context, parsers, token, options, hookIndex) {
// Only bother looking for text hooks if there even are text hook parsers
for (const parser of parsers) {
if (typeof parser.findHooks === 'function') {
this.checkElement(element, context, parsers, token, options, hookIndex);
break;
}
}
}
/**
* Checks an individual element and travels it recursively
*
* @param element - The element to parse
* @param context - The current context object
* @param parsers - The parsers to use
* @param token - The current parse token
* @param options - The current ParseOptions
* @param hookIndex - The hookIndex object to fill
* @param extractedNodes - A recursively-used object holding all temporarily extracted nodes
*/
checkElement(element, context, parsers, token, options, hookIndex, extractedNodes = { counter: 0, nodes: {} }) {
let childNodes = this.platformService.getChildNodes(element);
// To find text hooks in an already existing node, first replace non-text child nodes with string placeholders, then concat all text content.
// This is so enclosing text hooks can be found even if they are separated by other elements
let collectedText = '';
const collectedNodes = {};
for (const childNode of childNodes) {
if (this.platformService.isTextNode(childNode)) {
collectedText += this.platformService.getTextContent(childNode);
}
else {
const nodeId = extractedNodes.counter++;
collectedText += `${findInElementsNodePlaceholder}__${nodeId}__`;
collectedNodes[nodeId] = childNode;
}
}
// Then check for text hooks
const prevHookCount = Object.keys(hookIndex).length;
const result = this.find(collectedText, context, parsers, token, options, hookIndex);
// If hooks were found, replace element content with result.content
if (Object.keys(hookIndex).length > prevHookCount) {
this.platformService.clearChildNodes(element);
this.platformService.setInnerContent(element, result.content);
childNodes = this.platformService.getChildNodes(element);
// Also add locally removed nodes to total extractedNodes
extractedNodes.nodes = { ...extractedNodes.nodes, ...collectedNodes };
}
// If still have extractedNodes, always look for their placeholders on every level (could be deeper than when they were extracted) and reinsert them
if (Object.keys(extractedNodes.nodes).length) {
for (const childNode of childNodes) {
if (this.platformService.isTextNode(childNode)) {
let text = this.platformService.getTextContent(childNode);
if (text) {
const matches = matchAll(text, new RegExp(`${findInElementsNodePlaceholder}__(\\d*)__`, 'g'));
// If placeholders found
if (matches.length) {
const textReplacementNodes = [];
let currentPos = 0;
// Split text node containing placeholder into nodes array with restored nodes
for (const match of matches) {
const textBefore = text.substring(currentPos, match.index);
const extractedNodeId = parseInt(match[1]);
if (textBefore) {
textReplacementNodes.push(this.platformService.createTextNode(textBefore));
}
if (extractedNodeId && extractedNodes.nodes[extractedNodeId]) {
textReplacementNodes.push(extractedNodes.nodes[extractedNodeId]);
delete extractedNodes.nodes[extractedNodeId];
}
currentPos = match.index + match[0].length;
}
const textRemaining = text.substring(currentPos);
if (textRemaining) {
textReplacementNodes.push(this.platformService.createTextNode(textRemaining));
}
// Replace text node with that array
const parent = this.platformService.getParentNode(childNode);
for (const replacementNode of textReplacementNodes) {
this.platformService.insertBefore(parent, replacementNode, childNode);
}
this.platformService.removeChild(parent, childNode);
// Update child nodes var
childNodes = this.platformService.getChildNodes(parent);
}
}
}
}
}
// Travel child nodes recursively
for (const childNode of childNodes) {
if (childNode.nodeType !== Node.TEXT_NODE) {
this.checkElement(childNode, context, parsers, token, options, hookIndex, extractedNodes);
}
}
}
/**
* Finds all text hooks in a string variable and creates the corresponding anchors
*
* @param content - The text to parse
* @param context - The current context object
* @param parsers - The parsers to use
* @param token - The current parse token
* @param options - The current ParseOptions
* @param hookIndex - The hookIndex object to fill
*/
find(content, context, parsers, token, options, hookIndex) {
if (content === '') {
return {
content: content,
hookIndex: hookIndex
};
}
// Convert input HTML entities?
if (options.convertHTMLEntities) {
content = this.convertHTMLEntities(content);
}
// Collect all parser results, sort by order of appearance
let parserResults = [];
for (const parser of parsers) {
if (typeof parser.findHooks === 'function') {
for (const hookPosition of parser.findHooks(content, context, options)) {
parserResults.push({ parser, hookPosition });
}
}
}
parserResults.sort((a, b) => a.hookPosition.openingTagStartIndex - b.hookPosition.openingTagStartIndex);
// Validate parser results
parserResults = this.validateHookPositions(parserResults, content, options);
// Process parser results
const selectorReplaceInstructions = [];
for (const pr of parserResults) {
const hookId = Object.keys(hookIndex).length + 1;
// Some info about this hook
const hookSegments = this.getHookSegments(pr.hookPosition, content);
// Prepare ReplaceInstructions array to replace all found hooks with anchor elements
selectorReplaceInstructions.push({
startIndex: pr.hookPosition.openingTagStartIndex,
endIndex: pr.hookPosition.openingTagEndIndex,
replacement: `<${anchorElementTag} ${anchorAttrHookId}="${hookId}" ${anchorAttrParseToken}="${token}">`
});
selectorReplaceInstructions.push({
startIndex: hookSegments.enclosing ? pr.hookPosition.closingTagStartIndex : pr.hookPosition.openingTagEndIndex,
endIndex: hookSegments.enclosing ? pr.hookPosition.closingTagEndIndex : pr.hookPosition.openingTagEndIndex,
replacement: `</${anchorElementTag}>`
});
// Enter hook into index
hookIndex[hookId] = {
id: hookId,
parser: pr.parser,
value: {
openingTag: hookSegments.openingTag,
closingTag: hookSegments.closingTag,
element: null,
elementSnapshot: null
},
data: null,
isLazy: false,
bindings: null,
previousBindings: null,
componentRef: null,
dirtyInputs: new Set(),
outputSubscriptions: {},
htmlEventSubscriptions: {}
};
// Remove tag artifacts (does not change parser results indexes)
if (hookSegments.enclosing && options.fixParagraphTags) {
const firstResult = this.removeTagArtifacts(hookSegments.textBefore, '<p>', '</p>', hookSegments.innerValue, '</p>', '<p>');
hookSegments.textBefore = firstResult.firstText;
hookSegments.innerValue = firstResult.secondText;
const secondResult = this.removeTagArtifacts(hookSegments.innerValue, '<p>', '</p>', hookSegments.textAfter, '</p>', '<p>');
hookSegments.innerValue = secondResult.firstText;
hookSegments.textAfter = secondResult.secondText;
content = hookSegments.textBefore + hookSegments.openingTag + hookSegments.innerValue + hookSegments.closingTag + hookSegments.textAfter;
}
}
// Finally replace hooks with anchors
// Process in backwards order, so no need to change indexes.
// Primarily sort by startIndex. If multiple startIndexes are identical (possible with a follow-up hook to a self-closing hook), secondarily sort by endIndex.
selectorReplaceInstructions.sort((a, b) => {
let sortResult = b.startIndex - a.startIndex;
if (sortResult === 0)
sortResult = b.endIndex - a.endIndex;
return sortResult;
});
for (const selectorReplaceInstruction of selectorReplaceInstructions) {
const textBeforeSelector = content.substring(0, selectorReplaceInstruction.startIndex);
const textAfterSelector = content.substring(selectorReplaceInstruction.endIndex);
content = textBeforeSelector + selectorReplaceInstruction.replacement + textAfterSelector;
}
return {
content: content,
hookIndex: hookIndex
};
}
/**
* Takes a HookPosition and returns the HookValue as well as the text surrounding it
*
* @param hookPosition - The HookPosition in question
* @param content - The source text for the HookPosition
*/
getHookSegments(hookPosition, content) {
const enclosing = (Number.isInteger(hookPosition.closingTagStartIndex) && Number.isInteger(hookPosition.closingTagEndIndex));
return {
enclosing: enclosing,
textBefore: content.substring(0, hookPosition.openingTagStartIndex),
openingTag: content.substring(hookPosition.openingTagStartIndex, hookPosition.openingTagEndIndex),
innerValue: enclosing ? content.substring(hookPosition.openingTagEndIndex, hookPosition.closingTagStartIndex) : null,
closingTag: enclosing ? content.substring(hookPosition.closingTagStartIndex, hookPosition.closingTagEndIndex) : null,
textAfter: enclosing ? content.substring(hookPosition.closingTagEndIndex) : content.substring(hookPosition.openingTagEndIndex)
};
}
/**
* Checks the combined parserResults and validates them. Invalid ones are removed.
*
* @param parserResults - The parserResults to check
* @param content - The content string
* @param options - The current ParseOptions
*/
validateHookPositions(parserResults, content, options) {
const checkedParserResults = [];
outerloop: for (const [index, parserResult] of parserResults.entries()) {
const enclosing = (Number.isInteger(parserResult.hookPosition.closingTagStartIndex) && Number.isInteger(parserResult.hookPosition.closingTagEndIndex));
const hookPos = parserResult.hookPosition;
// Check if hook is in itself well-formed
if (hookPos.openingTagStartIndex >= hookPos.openingTagEndIndex) {
this.logger.warn(['Text hook error: openingTagEndIndex has to be greater than openingTagStartIndex. Ignoring.', hookPos], options);
continue;
}
if (enclosing && hookPos.openingTagEndIndex > hookPos.closingTagStartIndex) {
this.logger.warn(['Text hook error: closingTagStartIndex has to be greater than openingTagEndIndex. Ignoring.', hookPos], options);
continue;
}
if (enclosing && hookPos.closingTagStartIndex >= hookPos.closingTagEndIndex) {
this.logger.warn(['Text hook error: closingTagEndIndex has to be greater than closingTagStartIndex. Ignoring.', hookPos], options);
continue;
}
// Check if hook overlaps with other hooks
const previousHooks = parserResults.slice(0, index);
innerloop: for (const previousHook of previousHooks) {
const prevHookPos = previousHook.hookPosition;
const prevIsEnclosing = (Number.isInteger(prevHookPos.closingTagStartIndex) && Number.isInteger(prevHookPos.closingTagEndIndex));
// Check if identical hook position
if (hookPos.openingTagStartIndex === prevHookPos.openingTagStartIndex &&
hookPos.openingTagEndIndex === prevHookPos.openingTagEndIndex &&
(!enclosing || !prevIsEnclosing || (hookPos.closingTagStartIndex === prevHookPos.closingTagStartIndex &&
hookPos.closingTagEndIndex === prevHookPos.closingTagEndIndex))) {
this.generateHookPosWarning('A text hook with the same position as another text hook was found. There may be multiple parsers looking for the same text pattern. Ignoring duplicates.', hookPos, prevHookPos, content, options);
continue outerloop;
}
// Opening tag must begin after previous opening tag has ended
if (hookPos.openingTagStartIndex < prevHookPos.openingTagEndIndex) {
this.generateHookPosWarning('Text hook error: Hook opening tag starts before previous hook opening tag ends. Ignoring.', hookPos, prevHookPos, content, options);
continue outerloop;
}
// Just need to check for collisions with previous closing tag now
// Opening tag must not overlap with previous closing tag
if (prevIsEnclosing && !(hookPos.openingTagEndIndex <= prevHookPos.closingTagStartIndex ||
hookPos.openingTagStartIndex >= prevHookPos.closingTagEndIndex)) {
this.generateHookPosWarning('Text hook error: Opening tag of hook overlaps with closing tag of previous hook. Ignoring.', hookPos, prevHookPos, content, options);
continue outerloop;
}
// Closing tag must not overlap with previous closing tag
if (prevIsEnclosing && enclosing && !(hookPos.closingTagEndIndex <= prevHookPos.closingTagStartIndex ||
hookPos.closingTagStartIndex >= prevHookPos.closingTagEndIndex)) {
this.generateHookPosWarning('Text hook error: Closing tag of hook overlaps with closing tag of previous hook. Ignoring.', hookPos, prevHookPos, content, options);
continue outerloop;
}
// Check if hooks are incorrectly nested, e.g. "<outer-hook><inner-hook></outer-hook></inner-hook>"
if (enclosing && prevIsEnclosing &&
hookPos.openingTagEndIndex <= prevHookPos.closingTagStartIndex &&
hookPos.closingTagStartIndex >= prevHookPos.closingTagEndIndex) {
this.generateHookPosWarning('Text hook error: The closing tag of a nested hook lies beyond the closing tag of the outer hook. Ignoring.', hookPos, prevHookPos, content, options);
continue outerloop;
}
}
// If everything okay, add to result array
checkedParserResults.push(parserResult);
}
return checkedParserResults;
}
/**
* Outputs a warning in the console when the positions of two hooks are invalid in some manner
*
* @param message - The error message
* @param hookPos - The first HookPosition
* @param prevHookPos - The second HookPosition
* @param content - The content string
* @param options - The current ParseOptions
*/
generateHookPosWarning(message, hookPos, prevHookPos, content, options) {
const prevHookSegments = this.getHookSegments(prevHookPos, content);
const hookSegments = this.getHookSegments(hookPos, content);
const prevHookData = {
openingTag: prevHookSegments.openingTag,
openingTagStartIndex: prevHookPos.openingTagStartIndex,
openingTagEndIndex: prevHookPos.openingTagEndIndex,
closingTag: prevHookSegments.closingTag,
closingTagStartIndex: prevHookPos.closingTagStartIndex,
closingTagEndIndex: prevHookPos.closingTagEndIndex
};
const hookData = {
openingTag: hookSegments.openingTag,
openingTagStartIndex: hookPos.openingTagStartIndex,
openingTagEndIndex: hookPos.openingTagEndIndex,
closingTag: hookSegments.closingTag,
closingTagStartIndex: hookPos.closingTagStartIndex,
closingTagEndIndex: hookPos.closingTagEndIndex
};
this.logger.warn([message + '\nFirst hook: ', prevHookData, '\nSecond hook:', hookData], options);
}
/**
* When using an enclosing hook that is spread over several lines in an HTML editor, p-elements tend to get ripped apart. For example:
*
* <p><app-hook></p>
* <h2>This is the hook content</h2>
* <p></app-hook></p>
*
* would cause the innerValue of app-hook to have a lone closing and opening p-tag (as their counterparts are outside of the hook).
* To clean up the HTML, this function removes a pair of these artifacts (e.g. <p> before hook, </p> inside hook) if BOTH are found.
* This is important as the HTML parser will otherwise mess up the intended HTML and sometimes even put what should be ng-content below the component.
*
* @param firstText - The text on one side of the hook
* @param firstArtifact - A string that should be removed from firstText...
* @param firstRemoveIfAfter - ...if it appears after the last occurrence of this string
* @param secondText - The text on the other side of the hook
* @param secondArtifact - A string that should be removed from secondText...
* @param secondRemoveIfBefore - ...if it appears before the first occurrence of this string
*/
removeTagArtifacts(firstText, firstArtifact, firstRemoveIfAfter, secondText, secondArtifact, secondRemoveIfBefore) {
let firstArtifactFound = false;
let secondArtifactFound = false;
// a) Look for first artifact
const firstArtifactIndex = firstText.lastIndexOf(firstArtifact);
const firstArtifactIfAfterIndex = firstText.lastIndexOf(firstRemoveIfAfter);
if ((firstArtifactIndex >= 0 && firstArtifactIfAfterIndex === -1) ||
(firstArtifactIndex > firstArtifactIfAfterIndex)) {
firstArtifactFound = true;
}
// b) Look for second artifact
const secondArtifactIndex = secondText.indexOf(secondArtifact);
const secondArtifactIfBeforeIndex = secondText.indexOf(secondRemoveIfBefore);
if (
// If startArtifact appears before startArtifactNotBefore
(secondArtifactIndex >= 0 && secondArtifactIfBeforeIndex === -1) ||
(secondArtifactIndex < secondArtifactIfBeforeIndex)) {
secondArtifactFound = true;
}
// If artifacts found on both sides, remove both by overwriting them with empty spaces (doesn't change index)
if (firstArtifactFound && secondArtifactFound) {
firstText = firstText.substring(0, firstArtifactIndex) + ' '.repeat(firstArtifact.length) + firstText.substring(firstArtifactIndex + firstArtifact.length);
secondText = secondText.substring(0, secondArtifactIndex) + ' '.repeat(secondArtifact.length) + secondText.substring(secondArtifactIndex + secondArtifact.length);
}
// Trim after artifacts removed
return {
firstText: firstText,
secondText: secondText
};
}
/**
* Converts all HTML entities to normal characters
*
* @param text - The text with the potential HTML entities
*/
convertHTMLEntities(text) {
const div = this.platformService.createElement('div');
const result = text.replace(/&[#A-Za-z0-9]+;/gi, (hmtlEntity) => {
// Replace invisible nbsp-whitespace with normal whitespace (not \u00A0). Leads to problems with JSON.parse() otherwise.
if (hmtlEntity === (' ')) {
return ' ';
}
this.platformService.setInnerContent(div, hmtlEntity);
return this.platformService.getTextContent(div);
});
return result;
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextHookFinder, deps: [{ token: i1.AutoPlatformService }, { token: i2.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextHookFinder, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextHookFinder, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.AutoPlatformService }, { type: i2.Logger }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textHookFinder.js","sourceRoot":"","sources":["../../../../../../projects/ngx-dynamic-hooks/src/lib/services/core/textHookFinder.ts"],"names":[],"mappings":"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","sourcesContent":["import { HookIndex } from '../../interfacesPublic';\nimport { HookParser, HookPosition } from '../../interfacesPublic';\nimport { Injectable } from '@angular/core';\nimport { AutoPlatformService } from '../platform/autoPlatformService';\nimport { anchorAttrHookId, anchorAttrParseToken, anchorElementTag } from '../../constants/core';\nimport { matchAll } from '../utils/utils';\nimport { ParseOptions } from '../settings/options';\nimport { Logger } from '../utils/logger';\n\nconst findInElementsNodePlaceholder = '_ngx_dynamic_hooks_node_placeholder';\n\n/**\n * An atomic replace instruction. Reads as: Replace the text from startIndex to endIndex with replacement.\n */\nexport interface ReplaceInstruction {\n  startIndex: number;\n  endIndex: number;\n  replacement: string;\n}\n\n/**\n * Stores a HookPosition along with the parser who found it\n */\nexport interface ParserFindHooksResult {\n  parser: HookParser;\n  hookPosition: HookPosition;\n}\n\n/**\n * Stores the HookValue as well as the text surrounding it\n */\nexport interface HookSegments {\n  enclosing: boolean;\n  textBefore: string;\n  openingTag: string;\n  innerValue: string|null;\n  closingTag: string|null;\n  textAfter: string;\n}\n\n/**\n * The service responsible for finding text hooks in the content and replacing them with component anchors\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class TextHookFinder {\n\n  constructor(private platformService: AutoPlatformService, private logger: Logger) {\n  }\n\n  /**\n   * Finds all text hooks in an existing element and creates the corresponding anchors\n   * \n   * @param element - The element to parse\n   * @param context - The current context object\n   * @param parsers - The parsers to use\n   * @param token - The current parse token\n   * @param options - The current ParseOptions\n   * @param hookIndex - The hookIndex object to fill\n   */\n  findInElement(element: any, context: any, parsers: HookParser[], token: string, options: ParseOptions, hookIndex: HookIndex) {\n    // Only bother looking for text hooks if there even are text hook parsers\n    for (const parser of parsers) {\n      if (typeof parser.findHooks === 'function') {\n        this.checkElement(element, context, parsers, token, options, hookIndex);\n        break;\n      }\n    }\n  }\n\n  /**\n   * Checks an individual element and travels it recursively\n   * \n   * @param element - The element to parse\n   * @param context - The current context object\n   * @param parsers - The parsers to use\n   * @param token - The current parse token\n   * @param options - The current ParseOptions\n   * @param hookIndex - The hookIndex object to fill \n   * @param extractedNodes - A recursively-used object holding all temporarily extracted nodes\n   */\n  checkElement(element: any, context: any, parsers: HookParser[], token: string, options: ParseOptions, hookIndex: HookIndex, extractedNodes: {counter: number, nodes: {[key: string]: any}} = {counter: 0, nodes: {}}, ) {\n    let childNodes = this.platformService.getChildNodes(element);\n\n    // To find text hooks in an already existing node, first replace non-text child nodes with string placeholders, then concat all text content.\n    // This is so enclosing text hooks can be found even if they are separated by other elements\n    let collectedText = '';\n    const collectedNodes: {[key: string]: any} = {};\n    for (const childNode of childNodes) {\n      if (this.platformService.isTextNode(childNode)) {\n        collectedText += this.platformService.getTextContent(childNode);\n      } else {\n        const nodeId = extractedNodes.counter++;\n        collectedText += `${findInElementsNodePlaceholder}__${nodeId}__`;\n        collectedNodes[nodeId] = childNode;\n      }\n    }\n\n    // Then check for text hooks\n    const prevHookCount = Object.keys(hookIndex).length;\n    const result = this.find(collectedText, context, parsers, token, options, hookIndex);\n\n    // If hooks were found, replace element content with result.content\n    if (Object.keys(hookIndex).length > prevHookCount) {\n      this.platformService.clearChildNodes(element);\n      this.platformService.setInnerContent(element, result.content);\n      childNodes = this.platformService.getChildNodes(element);\n\n      // Also add locally removed nodes to total extractedNodes\n      extractedNodes.nodes = {...extractedNodes.nodes, ...collectedNodes};\n    }\n\n    // If still have extractedNodes, always look for their placeholders on every level (could be deeper than when they were extracted) and reinsert them\n    if (Object.keys(extractedNodes.nodes).length) {\n      for (const childNode of childNodes) {\n        if (this.platformService.isTextNode(childNode)) {\n          let text = this.platformService.getTextContent(childNode);\n          if (text) {\n            const matches = matchAll(text, new RegExp(`${findInElementsNodePlaceholder}__(\\\\d*)__`, 'g'));\n\n            // If placeholders found\n            if (matches.length) {\n              const textReplacementNodes = [];\n              let currentPos = 0;\n\n              // Split text node containing placeholder into nodes array with restored nodes\n              for (const match of matches) {\n                const textBefore = text.substring(currentPos, match.index);\n                const extractedNodeId = parseInt(match[1]);\n\n                if (textBefore) {\n                  textReplacementNodes.push(this.platformService.createTextNode(textBefore));\n                }\n                if (extractedNodeId && extractedNodes.nodes[extractedNodeId]) {\n                  textReplacementNodes.push(extractedNodes.nodes[extractedNodeId]);\n                  delete extractedNodes.nodes[extractedNodeId];\n                }\n                \n                currentPos = match.index + match[0].length;\n              }\n              const textRemaining = text.substring(currentPos);\n              if (textRemaining) {\n                textReplacementNodes.push(this.platformService.createTextNode(textRemaining));\n              }\n\n              // Replace text node with that array\n              const parent = this.platformService.getParentNode(childNode);\n              for (const replacementNode of textReplacementNodes) {\n                this.platformService.insertBefore(parent, replacementNode, childNode);\n              }\n              this.platformService.removeChild(parent, childNode);\n\n              // Update child nodes var\n              childNodes = this.platformService.getChildNodes(parent);\n            }\n          }\n        }\n      }\n    }\n\n    // Travel child 