occam-dom 5.0.14 → 5.1.1

package/lib/utilities/transform.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addNodeAfter: function() {
+        return addNodeAfter;
+    },
+    addNodesAfter: function() {
+        return addNodesAfter;
+    },
+    addTokensAfter: function() {
+        return addTokensAfter;
+    },
+    appendNode: function() {
+        return appendNode;
+    },
+    appendTokens: function() {
+        return appendTokens;
+    },
+    clonedTokensFromNodeAndTokens: function() {
+        return clonedTokensFromNodeAndTokens;
+    },
+    overwriteClonedNodeTokens: function() {
+        return overwriteClonedNodeTokens;
+    },
+    prependNode: function() {
+        return prependNode;
+    },
+    prependTokens: function() {
+        return prependTokens;
+    },
+    removeNode: function() {
+        return removeNode;
+    },
+    removeNodes: function() {
+        return removeNodes;
+    },
+    removeTokens: function() {
+        return removeTokens;
+    },
+    replaceNode: function() {
+        return replaceNode;
+    },
+    replaceNodes: function() {
+        return replaceNodes;
+    },
+    replaceTokens: function() {
+        return replaceTokens;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function appendNode(appendedNode, parentNode) {
+    var appendedChildNode = appendedNode; ///
+    parentNode.appendChildNode(appendedChildNode);
+}
+function prependNode(prependedNode, parentNode) {
+    var prependedChildNode = prependedNode; ///
+    parentNode.prependChildNode(prependedChildNode);
+}
+function removeNode(removedNode, parentNode) {
+    var removedChildNode = removedNode; ///
+    parentNode.removeChildNode(removedChildNode);
+}
+function removeNodes(removedNodes, parentNode) {
+    var removedChildNodes = removedNodes; ///
+    parentNode.removeChildNodes(removedChildNodes);
+}
+function replaceNode(replacementNode, replacedNode, parentNode) {
+    var replacedChildNode = replacedNode, replacementChildNode = replacementNode, replacementChildNodes = [
+        replacementChildNode
+    ];
+    parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+}
+function replaceNodes(replacementNodes, replacedNode, parentNode) {
+    var replacedChildNode = replacedNode, replacementChildNodes = replacementNodes; ///
+    parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);
+}
+function addNodeAfter(existingNode, addedNode, parentNode) {
+    var childNode = existingNode, index = parentNode.indexOfChildNode(childNode), addedChildNode = addedNode, startIndex = index + 1;
+    parentNode.addChildNode(addedChildNode, startIndex);
+}
+function addNodesAfter(existingNode, addedNodes, parentNode) {
+    var childNode = existingNode, index = parentNode.indexOfChildNode(childNode), addedChildNodes = addedNodes, startIndex = index + 1;
+    parentNode.addChildNodes(addedChildNodes, startIndex);
+}
+function appendTokens(appendedTokens, parentNode, tokens) {
+    var _tokens;
+    var node = parentNode, lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens), start = lastSignificantTokenIndex + 1, deleteCount = 0;
+    (_tokens = tokens).splice.apply(_tokens, [
+        start,
+        deleteCount
+    ].concat(_to_consumable_array(appendedTokens)));
+}
+function prependTokens(prependedTokens, parentNode, tokens) {
+    var _tokens;
+    var node = parentNode, firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, deleteCount = 0;
+    (_tokens = tokens).splice.apply(_tokens, [
+        start,
+        deleteCount
+    ].concat(_to_consumable_array(prependedTokens)));
+}
+function removeTokens(removedNode, tokens) {
+    var node = removedNode, firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens), lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1, deleteCount = end - start;
+    tokens.splice(start, deleteCount);
+}
+function replaceTokens(replacementTokens, replacedNode, tokens) {
+    var _tokens;
+    var node = replacedNode, firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens), lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1, deleteCount = end - start;
+    (_tokens = tokens).splice.apply(_tokens, [
+        start,
+        deleteCount
+    ].concat(_to_consumable_array(replacementTokens)));
+}
+function addTokensAfter(existingNode, addedTokens, tokens) {
+    var _tokens;
+    var node = existingNode, lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens), start = lastSignificantTokenIndex + 1, deleteCount = 0;
+    (_tokens = tokens).splice.apply(_tokens, [
+        start,
+        deleteCount
+    ].concat(_to_consumable_array(addedTokens)));
+}
+function overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens) {
+    var offset = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
+    var node = clonedNode; ///
+    overwriteNodeTokens(node, clonedTokens, tokens, offset);
+}
+function clonedTokensFromNodeAndTokens(node, tokens) {
+    var firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens), lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1;
+    tokens = tokens.slice(start, end); ///
+    var clonedTokens = tokens.map(function(token) {
+        var clonedToken = token.clone();
+        return clonedToken;
+    });
+    return clonedTokens;
+}
+function overwriteNodeTokens(node, clonedTokens, tokens, offset) {
+    var nodeTerminalNode = node.isTerminalNode();
+    if (nodeTerminalNode) {
+        var terminalNode = node; ///
+        overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);
+    } else {
+        var nonTerminalNode = node; ///
+        overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);
+    }
+}
+function overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {
+    var index, significantToken;
+    significantToken = terminalNode.getSignificantToken();
+    if (significantToken !== null) {
+        index = tokens.indexOf(significantToken);
+        index -= offset;
+        var clonedToken = clonedTokens[index];
+        significantToken = clonedToken; ///
+        terminalNode.setSignificantToken(significantToken);
+    }
+}
+function overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {
+    nonTerminalNode.forEachChildNode(function(childNode) {
+        var clonedNode = childNode; ///
+        overwriteNodeTokens(clonedNode, clonedTokens, tokens, offset);
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/transform.js"],"sourcesContent":["\"use strict\";\n\nexport function appendNode(appendedNode, parentNode) {\n  const appendedChildNode = appendedNode;  ///\n\n  parentNode.appendChildNode(appendedChildNode);\n}\n\nexport function prependNode(prependedNode, parentNode) {\n  const prependedChildNode = prependedNode;  ///\n\n  parentNode.prependChildNode(prependedChildNode);\n}\n\nexport function removeNode(removedNode, parentNode) {\n  const removedChildNode = removedNode; ///\n\n  parentNode.removeChildNode(removedChildNode);\n}\n\nexport function removeNodes(removedNodes, parentNode) {\n  const removedChildNodes = removedNodes; ///\n\n  parentNode.removeChildNodes(removedChildNodes);\n}\n\nexport function replaceNode(replacementNode, replacedNode, parentNode) {\n  const replacedChildNode = replacedNode,  ///\n        replacementChildNode = replacementNode, ///\n        replacementChildNodes = [\n          replacementChildNode\n        ];\n\n  parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);\n}\n\nexport function replaceNodes(replacementNodes, replacedNode, parentNode) {\n  const replacedChildNode = replacedNode,  ///\n        replacementChildNodes = replacementNodes; ///\n\n  parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);\n}\n\nexport function addNodeAfter(existingNode, addedNode, parentNode) {\n  const childNode = existingNode, ///\n        index = parentNode.indexOfChildNode(childNode),\n        addedChildNode = addedNode, ///\n        startIndex = index + 1;\n\n  parentNode.addChildNode(addedChildNode, startIndex);\n}\n\nexport function addNodesAfter(existingNode, addedNodes, parentNode) {\n  const childNode = existingNode, ///\n        index = parentNode.indexOfChildNode(childNode),\n        addedChildNodes = addedNodes, ///\n        startIndex = index + 1;\n\n  parentNode.addChildNodes(addedChildNodes, startIndex);\n}\n\nexport function appendTokens(appendedTokens, parentNode, tokens) {\n  const node = parentNode, ///\n        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),\n        start = lastSignificantTokenIndex + 1,\n        deleteCount = 0;\n\n  tokens.splice(start, deleteCount, ...appendedTokens);\n}\n\nexport function prependTokens(prependedTokens, parentNode, tokens) {\n  const node = parentNode, ///\n        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),\n        start = firstSignificantTokenIndex,\n        deleteCount = 0;\n\n  tokens.splice(start, deleteCount, ...prependedTokens);\n}\n\nexport function removeTokens(removedNode, tokens) {\n  const node = removedNode,  ///\n        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),\n        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),\n        start = firstSignificantTokenIndex, ///\n        end = lastSignificantTokenIndex + 1,\n        deleteCount = end - start;\n\n  tokens.splice(start, deleteCount);\n}\n\nexport function replaceTokens(replacementTokens, replacedNode, tokens) {\n  const node = replacedNode,  ///\n        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),\n        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),\n        start = firstSignificantTokenIndex, ///\n        end = lastSignificantTokenIndex + 1,\n        deleteCount = end - start;\n\n  tokens.splice(start, deleteCount, ...replacementTokens);\n}\n\nexport function addTokensAfter(existingNode, addedTokens, tokens) {\n  const node = existingNode,  ///\n        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),\n        start = lastSignificantTokenIndex + 1,\n        deleteCount = 0;\n\n  tokens.splice(start, deleteCount, ...addedTokens);\n}\n\nexport function overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset = 0) {\n  const node = clonedNode;  ///\n\n  overwriteNodeTokens(node, clonedTokens, tokens, offset);\n}\n\nexport function clonedTokensFromNodeAndTokens(node, tokens) {\n  const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),\n        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),\n        start = firstSignificantTokenIndex,  ///\n        end = lastSignificantTokenIndex + 1;\n\n  tokens = tokens.slice(start, end);  ///\n\n  const clonedTokens = tokens.map((token) => {  ///\n    const clonedToken = token.clone();\n\n    return clonedToken;\n  });\n\n  return clonedTokens;\n}\n\nfunction overwriteNodeTokens(node, clonedTokens, tokens, offset) {\n  const nodeTerminalNode = node.isTerminalNode();\n\n  if (nodeTerminalNode) {\n    const terminalNode = node;  ///\n\n    overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);\n  } else {\n    const nonTerminalNode = node;  ///\n\n    overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);\n  }\n}\n\nfunction overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {\n  let index,\n      significantToken;\n\n  significantToken = terminalNode.getSignificantToken();\n\n  if (significantToken !== null) {\n    index = tokens.indexOf(significantToken);\n\n    index -= offset;\n\n    const clonedToken = clonedTokens[index];\n\n    significantToken = clonedToken;  ///\n\n    terminalNode.setSignificantToken(significantToken);\n  }\n}\n\nfunction overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {\n  nonTerminalNode.forEachChildNode((childNode) => {\n    const clonedNode = childNode; ///\n\n    overwriteNodeTokens(clonedNode, clonedTokens, tokens, offset);\n  });\n}\n"],"names":["addNodeAfter","addNodesAfter","addTokensAfter","appendNode","appendTokens","clonedTokensFromNodeAndTokens","overwriteClonedNodeTokens","prependNode","prependTokens","removeNode","removeNodes","removeTokens","replaceNode","replaceNodes","replaceTokens","appendedNode","parentNode","appendedChildNode","appendChildNode","prependedNode","prependedChildNode","prependChildNode","removedNode","removedChildNode","removeChildNode","removedNodes","removedChildNodes","removeChildNodes","replacementNode","replacedNode","replacedChildNode","replacementChildNode","replacementChildNodes","replaceChildNode","replacementNodes","replaceChildNodes","existingNode","addedNode","childNode","index","indexOfChildNode","addedChildNode","startIndex","addChildNode","addedNodes","addedChildNodes","addChildNodes","appendedTokens","tokens","node","lastSignificantTokenIndex","getLastSignificantTokenIndex","start","deleteCount","splice","prependedTokens","firstSignificantTokenIndex","getFirstSignificantTokenIndex","end","replacementTokens","addedTokens","clonedNode","clonedTokens","offset","overwriteNodeTokens","slice","map","token","clonedToken","clone","nodeTerminalNode","isTerminalNode","terminalNode","overwriteTerminalNodeTokens","nonTerminalNode","overwriteNonTerminalNodeTokens","significantToken","getSignificantToken","indexOf","setSignificantToken","forEachChildNode"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-dom",
   "author": "James Smith",
-  "version": "5.0.14",
+  "version": "5.1.1",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-dom",
   "description": "Occam's DOM related functionality.",

package/src/index.js

@@ -1,4 +1,5 @@
 "use strict";
 
 export { default as Node } from "./node";
+export { default as Transform } from "./transform";
 export { default as nodeUtilities } from "./utilities/node";

package/src/node.js

@@ -78,7 +78,7 @@ export default class Node {
     return parseTree;
   }
 
-  static fromNothing(Class) {
+  static fromNothing(Class, ...remainingArguments) {
     if (Class === undefined) {
       Class = Node; ///
     }
@@ -86,12 +86,12 @@ export default class Node {
     const outerNode = null,
           parentNode = null,
           childNodes = [],
-          node = new Class(outerNode, parentNode, childNodes);
+          node = new Class(outerNode, parentNode, childNodes, ...remainingArguments);
 
     return node;
   }
 
-  static fromOuterNode(Class, outerNode) {
+  static fromOuterNode(Class, outerNode, ...remainingArguments) {
     if (outerNode === undefined) {
       outerNode = Class;  ///
 
@@ -100,7 +100,7 @@ export default class Node {
 
     const parentNode = null,
           childNodes = [],
-          node = new Class(outerNode, parentNode, childNodes);
+          node = new Class(outerNode, parentNode, childNodes, ...remainingArguments);
 
     return node;
   }

package/src/transform.js

@@ -0,0 +1,184 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { appendNode,
+         removeNode,
+         prependNode,
+         replaceNode,
+         appendTokens,
+         removeTokens,
+         replaceTokens,
+         addNodesAfter,
+         prependTokens,
+         addTokensAfter,
+         overwriteClonedNodeTokens,
+         clonedTokensFromNodeAndTokens, } from "./utilities/transform";
+
+const { push } = arrayUtilities;
+
+export default class Transform {
+  constructor(node, tokens) {
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens(tokens = []) {
+    push(tokens, this.tokens);
+
+    return this.tokens;
+  }
+
+  contract(Class, descendentNode, ...remainingArguments) {
+    if (descendentNode === undefined) {
+      descendentNode = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    const node = descendentNode,  ///
+          tokens = this.tokens, ///
+          context = { ///
+            tokens
+          },
+          transform = Class.fromNode(node, ...remainingArguments, context);
+
+    return transform;
+  }
+
+  expand(Class, ascendantNode, ...remainingArguments) {
+    if (ascendantNode === undefined) {
+      ascendantNode = Class;
+
+      Class = Transform;  ///
+    }
+
+    const node = ascendantNode, ///
+          tokens = this.tokens, ///
+          context = {
+            tokens
+          },
+          transform = Class.fromNode(node, ...remainingArguments, context);
+
+    return transform;
+  }
+
+  appendTo(parentNode, context) {
+    const { tokens } = context,
+          appendedNode = this.node,  ///
+          appendedTokens = this.tokens;  ///
+
+    appendNode(appendedNode, parentNode);
+
+    appendTokens(appendedTokens, parentNode, tokens);
+  }
+
+  prependTo(parentNode, context) {
+    const { tokens } = context,
+          prependedNode = this.node,  ///
+          prependedTokens = this.tokens;  ///
+
+    prependNode(prependedNode, parentNode);
+
+    prependTokens(prependedTokens, parentNode, tokens);
+  }
+
+  addAfter(existingNode, parentNode, context) {
+    const { tokens } = context,
+          markdownNode = this.node, ///
+          removedChildNodes = markdownNode.removeChildNodes(),
+          addedTokens = this.tokens,  ///
+          addedNodes = removedChildNodes;  ///
+
+    addNodesAfter(existingNode, addedNodes, parentNode);
+
+    addTokensAfter(existingNode, addedTokens, tokens);
+  }
+
+  replace(replacedNode, parentNode, context) {
+    const { tokens } = context,
+          replacementNode = this.node, ///
+          replacementTokens = this.tokens; ///
+
+    replaceNode(replacementNode, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
+  }
+
+  removeFrom(removedNode, parentNode, context) {
+    const { tokens } = context;
+
+    removeTokens(removedNode, tokens);
+
+    removeNode(removedNode, parentNode);
+  }
+
+  clone(...remainingArguments) {
+    const clonedNode = this.node.clone(),
+          clonedTokens = clonedTokensFromNodeAndTokens(this.node, this.tokens);
+
+    overwriteClonedNodeTokens(clonedNode, clonedTokens, this.tokens);
+
+    const Class = this.constructor, ///
+          node = clonedNode,  ///
+          tokens = clonedTokens, ///
+          transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform
+  }
+
+  static fromNode(Class, node, ...remainingArguments) {
+    let context = remainingArguments.pop();
+
+    if (context === undefined) {
+      context = node; ///
+
+      node = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    let { tokens } = context;
+
+    const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+          clonedNode = node.clone();
+
+    let clonedTokens;
+
+    if (firstSignificantTokenIndex === null) {
+      clonedTokens = [];
+    } else {
+      const offset = firstSignificantTokenIndex;  ///
+
+      clonedTokens = clonedTokensFromNodeAndTokens(node, tokens);
+
+      overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset);
+    }
+
+    node = clonedNode;  ///
+
+    tokens = clonedTokens; ///
+
+    const transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform;
+  }
+
+  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) {
+    if (tokens === undefined) {
+      tokens = node;  ///
+
+      node = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    const transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform;
+  }
+}

package/src/utilities/transform.js

@@ -0,0 +1,173 @@
+"use strict";
+
+export function appendNode(appendedNode, parentNode) {
+  const appendedChildNode = appendedNode;  ///
+
+  parentNode.appendChildNode(appendedChildNode);
+}
+
+export function prependNode(prependedNode, parentNode) {
+  const prependedChildNode = prependedNode;  ///
+
+  parentNode.prependChildNode(prependedChildNode);
+}
+
+export function removeNode(removedNode, parentNode) {
+  const removedChildNode = removedNode; ///
+
+  parentNode.removeChildNode(removedChildNode);
+}
+
+export function removeNodes(removedNodes, parentNode) {
+  const removedChildNodes = removedNodes; ///
+
+  parentNode.removeChildNodes(removedChildNodes);
+}
+
+export function replaceNode(replacementNode, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNode = replacementNode, ///
+        replacementChildNodes = [
+          replacementChildNode
+        ];
+
+  parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+}
+
+export function replaceNodes(replacementNodes, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNodes = replacementNodes; ///
+
+  parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);
+}
+
+export function addNodeAfter(existingNode, addedNode, parentNode) {
+  const childNode = existingNode, ///
+        index = parentNode.indexOfChildNode(childNode),
+        addedChildNode = addedNode, ///
+        startIndex = index + 1;
+
+  parentNode.addChildNode(addedChildNode, startIndex);
+}
+
+export function addNodesAfter(existingNode, addedNodes, parentNode) {
+  const childNode = existingNode, ///
+        index = parentNode.indexOfChildNode(childNode),
+        addedChildNodes = addedNodes, ///
+        startIndex = index + 1;
+
+  parentNode.addChildNodes(addedChildNodes, startIndex);
+}
+
+export function appendTokens(appendedTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = lastSignificantTokenIndex + 1,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...appendedTokens);
+}
+
+export function prependTokens(prependedTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...prependedTokens);
+}
+
+export function removeTokens(removedNode, tokens) {
+  const node = removedNode,  ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount);
+}
+
+export function replaceTokens(replacementTokens, replacedNode, tokens) {
+  const node = replacedNode,  ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount, ...replacementTokens);
+}
+
+export function addTokensAfter(existingNode, addedTokens, tokens) {
+  const node = existingNode,  ///
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = lastSignificantTokenIndex + 1,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...addedTokens);
+}
+
+export function overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset = 0) {
+  const node = clonedNode;  ///
+
+  overwriteNodeTokens(node, clonedTokens, tokens, offset);
+}
+
+export function clonedTokensFromNodeAndTokens(node, tokens) {
+  const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,  ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  const clonedTokens = tokens.map((token) => {  ///
+    const clonedToken = token.clone();
+
+    return clonedToken;
+  });
+
+  return clonedTokens;
+}
+
+function overwriteNodeTokens(node, clonedTokens, tokens, offset) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);
+  }
+}
+
+function overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {
+  let index,
+      significantToken;
+
+  significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken !== null) {
+    index = tokens.indexOf(significantToken);
+
+    index -= offset;
+
+    const clonedToken = clonedTokens[index];
+
+    significantToken = clonedToken;  ///
+
+    terminalNode.setSignificantToken(significantToken);
+  }
+}
+
+function overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {
+  nonTerminalNode.forEachChildNode((childNode) => {
+    const clonedNode = childNode; ///
+
+    overwriteNodeTokens(clonedNode, clonedTokens, tokens, offset);
+  });
+}