highmark-markdown 0.0.225 → 0.0.228

package/lib/utilities/query.js

@@ -27,6 +27,9 @@ _export(exports, {
     headingMarkdownNodesFromNode: function() {
         return headingMarkdownNodesFromNode;
     },
+    ignoreMarkdownNodeFromNode: function() {
+        return ignoreMarkdownNodeFromNode;
+    },
     linkMarkdownNodesFromNode: function() {
         return linkMarkdownNodesFromNode;
     },
@@ -46,7 +49,7 @@ _export(exports, {
 var _occamquery = require("occam-query");
 var _necessary = require("necessary");
 var first = _necessary.arrayUtilities.first, push = _necessary.arrayUtilities.push;
-var linkMarkdownNodesQuery = _occamquery.Query.fromExpression("//link"), headingMarkdownNodesQuery = _occamquery.Query.fromExpression("//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"), contentsMarkdownNodeQuery = _occamquery.Query.fromExpression("//contents"), footnoteMarkdownNodesQuery = _occamquery.Query.fromExpression("//footnote"), footnotesMarkdownNodeQuery = _occamquery.Query.fromExpression("/division/subDivision/footnotes"), footnotesMarkdownNodesQuery = _occamquery.Query.fromExpression("//footnotes"), referenceMarkdownNodesQuery = _occamquery.Query.fromExpression("//reference"), linkReferenceOrFootnotesMarkdownNodesQuery = _occamquery.Query.fromExpression("//link|reference|footnotes");
+var linkMarkdownNodesQuery = _occamquery.Query.fromExpression("//link"), ignoreMarkdownNodeQuery = _occamquery.Query.fromExpression("//ignore"), headingMarkdownNodesQuery = _occamquery.Query.fromExpression("//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"), contentsMarkdownNodeQuery = _occamquery.Query.fromExpression("//contents"), footnoteMarkdownNodesQuery = _occamquery.Query.fromExpression("//footnote"), footnotesMarkdownNodeQuery = _occamquery.Query.fromExpression("/division/subDivision/footnotes"), footnotesMarkdownNodesQuery = _occamquery.Query.fromExpression("//footnotes"), referenceMarkdownNodesQuery = _occamquery.Query.fromExpression("//reference"), linkReferenceOrFootnotesMarkdownNodesQuery = _occamquery.Query.fromExpression("//link|reference|footnotes");
 function nodeQuery(expression) {
     var query = _occamquery.Query.fromExpression(expression);
     return function(node) {
@@ -72,6 +75,10 @@ function linkMarkdownNodesFromNode(node) {
     nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);
     return linkMarkdownNodes;
 }
+function ignoreMarkdownNodeFromNode(node) {
+    var ignoreMarkdownNode = nodeFromNodeAndQuery(node, ignoreMarkdownNodeQuery);
+    return ignoreMarkdownNode;
+}
 function contentsMarkdownNodeFromNode(node) {
     var contentsMarkdownNode = nodeFromNodeAndQuery(node, contentsMarkdownNodeQuery);
     return contentsMarkdownNode;
@@ -107,6 +114,7 @@ function linkReferenceOrFootnotesMarkdownNodesFromNode(node) {
 }
 var _default = {
     linkMarkdownNodesFromNode: linkMarkdownNodesFromNode,
+    ignoreMarkdownNodeFromNode: ignoreMarkdownNodeFromNode,
     contentsMarkdownNodeFromNode: contentsMarkdownNodeFromNode,
     footnotesMarkdownNodeFromNode: footnotesMarkdownNodeFromNode,
     headingMarkdownNodesFromNode: headingMarkdownNodesFromNode,
@@ -131,4 +139,4 @@ function nodesFromNodeAndQuery(node, query, nodes) {
     return nodes;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/query.js"],"sourcesContent":["\"use strict\";\n\nimport { Query } from \"occam-query\";\nimport { arrayUtilities } from \"necessary\";\n\nconst { first, push } = arrayUtilities;\n\nconst linkMarkdownNodesQuery = Query.fromExpression(`//link`),\n      headingMarkdownNodesQuery = Query.fromExpression(`//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading`),\n      contentsMarkdownNodeQuery = Query.fromExpression(`//contents`),\n      footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),\n      footnotesMarkdownNodeQuery = Query.fromExpression(`/division/subDivision/footnotes`),\n      footnotesMarkdownNodesQuery = Query.fromExpression(`//footnotes`),\n      referenceMarkdownNodesQuery = Query.fromExpression(`//reference`),\n      linkReferenceOrFootnotesMarkdownNodesQuery = Query.fromExpression(`//link|reference|footnotes`);\n\nexport function nodeQuery(expression) {\n  const query = Query.fromExpression(expression);\n\n  return function(node) {\n    const nodes = query.execute(node),\n          nodesLength = nodes.length;\n\n    if (nodesLength > 0) {\n      const firstNode = first(nodes);\n\n      node = firstNode; ///\n    } else {\n      node = null;\n    }\n\n    return node;\n  }\n}\n\nexport function nodesQuery(expression) {\n  const query = Query.fromExpression(expression);\n\n  return function(node) {\n    const nodes = query.execute(node);\n\n    return nodes;\n  }\n}\n\nexport function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);\n\n  return linkMarkdownNodes;\n}\n\nexport function contentsMarkdownNodeFromNode(node) {\n  const contentsMarkdownNode = nodeFromNodeAndQuery(node, contentsMarkdownNodeQuery);\n\n  return contentsMarkdownNode;\n}\n\nexport function footnotesMarkdownNodeFromNode(node) {\n  const footnotesMarkdownNode = nodeFromNodeAndQuery(node, footnotesMarkdownNodeQuery);\n\n  return footnotesMarkdownNode;\n}\n\nexport function headingMarkdownNodesFromNode(node, headingMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, headingMarkdownNodesQuery, headingMarkdownNodes);\n\n  return headingMarkdownNodes;\n}\n\nexport function footnoteMarkdownNodesFromNode(node, footnoteMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, footnoteMarkdownNodesQuery, footnoteMarkdownNodes);\n\n  return footnoteMarkdownNodes;\n}\n\nexport function referenceMarkdownNodesFromNode(node, referenceMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, referenceMarkdownNodesQuery, referenceMarkdownNodes);\n\n  return referenceMarkdownNodes;\n}\n\nexport function footnotesMarkdownNodesFromNode(node, footnotesMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, footnotesMarkdownNodesQuery, footnotesMarkdownNodes);\n\n  return footnotesMarkdownNodes;\n}\n\nexport function linkReferenceOrFootnotesMarkdownNodesFromNode(node, linkReferenceOrFootnotesMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, linkReferenceOrFootnotesMarkdownNodesQuery, linkReferenceOrFootnotesMarkdownNodes);\n\n  return linkReferenceOrFootnotesMarkdownNodes;\n}\n\nexport default {\n  linkMarkdownNodesFromNode,\n  contentsMarkdownNodeFromNode,\n  footnotesMarkdownNodeFromNode,\n  headingMarkdownNodesFromNode,\n  footnoteMarkdownNodesFromNode,\n  referenceMarkdownNodesFromNode,\n  footnotesMarkdownNodesFromNode,\n  linkReferenceOrFootnotesMarkdownNodesFromNode\n};\n\nfunction nodeFromNodeAndQuery(node, query) {\n  const queryNodes = query.execute(node),\n        queryNodesLength = queryNodes.length;\n\n  if (queryNodesLength === 0) {\n    node = null;\n  } else {\n    const firstQueryNode = first(queryNodes);\n\n    node = firstQueryNode;  ///\n  }\n\n  return node;\n}\n\nfunction nodesFromNodeAndQuery(node, query, nodes) {\n  const queryNodes = query.execute(node);\n\n  push(nodes, queryNodes);\n\n  return nodes;\n}\n"],"names":["contentsMarkdownNodeFromNode","footnoteMarkdownNodesFromNode","footnotesMarkdownNodeFromNode","footnotesMarkdownNodesFromNode","headingMarkdownNodesFromNode","linkMarkdownNodesFromNode","linkReferenceOrFootnotesMarkdownNodesFromNode","nodeQuery","nodesQuery","referenceMarkdownNodesFromNode","first","arrayUtilities","push","linkMarkdownNodesQuery","Query","fromExpression","headingMarkdownNodesQuery","contentsMarkdownNodeQuery","footnoteMarkdownNodesQuery","footnotesMarkdownNodeQuery","footnotesMarkdownNodesQuery","referenceMarkdownNodesQuery","linkReferenceOrFootnotesMarkdownNodesQuery","expression","query","node","nodes","execute","nodesLength","length","firstNode","linkMarkdownNodes","nodesFromNodeAndQuery","contentsMarkdownNode","nodeFromNodeAndQuery","footnotesMarkdownNode","headingMarkdownNodes","footnoteMarkdownNodes","referenceMarkdownNodes","footnotesMarkdownNodes","linkReferenceOrFootnotesMarkdownNodes","queryNodes","queryNodesLength","firstQueryNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/query.js"],"sourcesContent":["\"use strict\";\n\nimport { Query } from \"occam-query\";\nimport { arrayUtilities } from \"necessary\";\n\nconst { first, push } = arrayUtilities;\n\nconst linkMarkdownNodesQuery = Query.fromExpression(`//link`),\n      ignoreMarkdownNodeQuery = Query.fromExpression(`//ignore`),\n      headingMarkdownNodesQuery = Query.fromExpression(`//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading`),\n      contentsMarkdownNodeQuery = Query.fromExpression(`//contents`),\n      footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),\n      footnotesMarkdownNodeQuery = Query.fromExpression(`/division/subDivision/footnotes`),\n      footnotesMarkdownNodesQuery = Query.fromExpression(`//footnotes`),\n      referenceMarkdownNodesQuery = Query.fromExpression(`//reference`),\n      linkReferenceOrFootnotesMarkdownNodesQuery = Query.fromExpression(`//link|reference|footnotes`);\n\nexport function nodeQuery(expression) {\n  const query = Query.fromExpression(expression);\n\n  return function(node) {\n    const nodes = query.execute(node),\n          nodesLength = nodes.length;\n\n    if (nodesLength > 0) {\n      const firstNode = first(nodes);\n\n      node = firstNode; ///\n    } else {\n      node = null;\n    }\n\n    return node;\n  }\n}\n\nexport function nodesQuery(expression) {\n  const query = Query.fromExpression(expression);\n\n  return function(node) {\n    const nodes = query.execute(node);\n\n    return nodes;\n  }\n}\n\nexport function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);\n\n  return linkMarkdownNodes;\n}\n\nexport function ignoreMarkdownNodeFromNode(node) {\n  const ignoreMarkdownNode = nodeFromNodeAndQuery(node, ignoreMarkdownNodeQuery);\n\n  return ignoreMarkdownNode;\n}\n\nexport function contentsMarkdownNodeFromNode(node) {\n  const contentsMarkdownNode = nodeFromNodeAndQuery(node, contentsMarkdownNodeQuery);\n\n  return contentsMarkdownNode;\n}\n\nexport function footnotesMarkdownNodeFromNode(node) {\n  const footnotesMarkdownNode = nodeFromNodeAndQuery(node, footnotesMarkdownNodeQuery);\n\n  return footnotesMarkdownNode;\n}\n\nexport function headingMarkdownNodesFromNode(node, headingMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, headingMarkdownNodesQuery, headingMarkdownNodes);\n\n  return headingMarkdownNodes;\n}\n\nexport function footnoteMarkdownNodesFromNode(node, footnoteMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, footnoteMarkdownNodesQuery, footnoteMarkdownNodes);\n\n  return footnoteMarkdownNodes;\n}\n\nexport function referenceMarkdownNodesFromNode(node, referenceMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, referenceMarkdownNodesQuery, referenceMarkdownNodes);\n\n  return referenceMarkdownNodes;\n}\n\nexport function footnotesMarkdownNodesFromNode(node, footnotesMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, footnotesMarkdownNodesQuery, footnotesMarkdownNodes);\n\n  return footnotesMarkdownNodes;\n}\n\nexport function linkReferenceOrFootnotesMarkdownNodesFromNode(node, linkReferenceOrFootnotesMarkdownNodes = []) {\n  nodesFromNodeAndQuery(node, linkReferenceOrFootnotesMarkdownNodesQuery, linkReferenceOrFootnotesMarkdownNodes);\n\n  return linkReferenceOrFootnotesMarkdownNodes;\n}\n\nexport default {\n  linkMarkdownNodesFromNode,\n  ignoreMarkdownNodeFromNode,\n  contentsMarkdownNodeFromNode,\n  footnotesMarkdownNodeFromNode,\n  headingMarkdownNodesFromNode,\n  footnoteMarkdownNodesFromNode,\n  referenceMarkdownNodesFromNode,\n  footnotesMarkdownNodesFromNode,\n  linkReferenceOrFootnotesMarkdownNodesFromNode\n};\n\nfunction nodeFromNodeAndQuery(node, query) {\n  const queryNodes = query.execute(node),\n        queryNodesLength = queryNodes.length;\n\n  if (queryNodesLength === 0) {\n    node = null;\n  } else {\n    const firstQueryNode = first(queryNodes);\n\n    node = firstQueryNode;  ///\n  }\n\n  return node;\n}\n\nfunction nodesFromNodeAndQuery(node, query, nodes) {\n  const queryNodes = query.execute(node);\n\n  push(nodes, queryNodes);\n\n  return nodes;\n}\n"],"names":["contentsMarkdownNodeFromNode","footnoteMarkdownNodesFromNode","footnotesMarkdownNodeFromNode","footnotesMarkdownNodesFromNode","headingMarkdownNodesFromNode","ignoreMarkdownNodeFromNode","linkMarkdownNodesFromNode","linkReferenceOrFootnotesMarkdownNodesFromNode","nodeQuery","nodesQuery","referenceMarkdownNodesFromNode","first","arrayUtilities","push","linkMarkdownNodesQuery","Query","fromExpression","ignoreMarkdownNodeQuery","headingMarkdownNodesQuery","contentsMarkdownNodeQuery","footnoteMarkdownNodesQuery","footnotesMarkdownNodeQuery","footnotesMarkdownNodesQuery","referenceMarkdownNodesQuery","linkReferenceOrFootnotesMarkdownNodesQuery","expression","query","node","nodes","execute","nodesLength","length","firstNode","linkMarkdownNodes","nodesFromNodeAndQuery","ignoreMarkdownNode","nodeFromNodeAndQuery","contentsMarkdownNode","footnotesMarkdownNode","headingMarkdownNodes","footnoteMarkdownNodes","referenceMarkdownNodes","footnotesMarkdownNodes","linkReferenceOrFootnotesMarkdownNodes","queryNodes","queryNodesLength","firstQueryNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/utilities/replace.js

@@ -0,0 +1,57 @@
+"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, {
+    replaceNode: function() {
+        return replaceNode;
+    },
+    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 replaceNode(replacementNode, replacedNode, parentNode) {
+    var replacedChildNode = replacedNode, replacementChildNode = replacementNode; ///
+    parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+}
+function replaceTokens(replacementTokens, replacedNode, tokens) {
+    var _tokens;
+    var nonTerminalNode = replacedNode, lastSignificantToken = nonTerminalNode.getLastSignificantToken(), firstSignificantToken = nonTerminalNode.getFirstSignificantToken(), lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken), firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1, deleteCount = end - start;
+    (_tokens = tokens).splice.apply(_tokens, [
+        start,
+        deleteCount
+    ].concat(_to_consumable_array(replacementTokens)));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "highmark-markdown",
   "author": "James Smith",
-  "version": "0.0.225",
+  "version": "0.0.228",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/highmark-markdown",
   "description": "Highmark's Markdown.",
@@ -17,12 +17,12 @@
   },
   "devDependencies": {
     "@swc/core": "1.2.52",
-    "easy": "^16.0.19",
-    "easy-layout": "^6.0.144",
-    "easy-with-style": "^3.0.348",
+    "easy": "^16.0.21",
+    "easy-layout": "^6.0.145",
+    "easy-with-style": "^3.0.349",
     "esbuild": "^0.9.2",
     "express": "^4.17.1",
-    "juxtapose": "^4.0.80",
+    "juxtapose": "^4.0.81",
     "lively-cli": "^2.0.52",
     "watchful-cli": "^1.7.44"
   },

package/src/clonedNode.js

@@ -0,0 +1,146 @@
+"use strict";
+
+export default class ClonedNode {
+  constructor(node, tokens) {
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getChildNodes() { return this.node.getChildNodes(); }
+
+  static fromNode(node, context) {
+    let { tokens } = context;
+
+    const offset = offsetFromNodeAndTokens(node, tokens),
+          replacementTokens = replacementTokensFromNodeAndTokens(node, tokens);
+
+    node = node.clone();  ///
+
+    replaceNodeTokens(node, replacementTokens, offset, tokens);
+
+    tokens = replacementTokens; ///
+
+    const clonedNode = new ClonedNode(node, tokens);
+
+    return clonedNode;
+  }
+}
+
+function replaceNodeTokens(node, replacementTokens, offset, tokens) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    replaceTerminalNodeTokens(terminalNode, replacementTokens, offset, tokens);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, offset, tokens);
+  }
+}
+
+function replaceChildNodesTokens(childNodes, replacementTokens, offset, tokens) {
+  childNodes.forEach((childNode) => {
+    const node = childNode; ///
+
+    replaceNodeTokens(node, replacementTokens, offset, tokens);
+  });
+}
+
+function replaceTerminalNodeTokens(terminalNode, replacementTokens, offset, tokens) {
+  let index,
+      significantToken;
+
+  significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken !== null) {
+    index = tokens.indexOf(significantToken);
+
+    index -= offset;
+
+    const replacementToken = replacementTokens[index];
+
+    significantToken = replacementToken;  ///
+
+    terminalNode.setSignificantToken(significantToken);
+  }
+}
+
+function replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, offset, tokens) {
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  replaceChildNodesTokens(childNodes, replacementTokens, offset, tokens);
+}
+
+function offsetFromNodeAndTokens(node, tokens) {
+  let offset;
+
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node,  ///
+          significantToken = terminalNode.getSignificantToken();
+
+    if (significantToken === null) {
+      offset = -1;
+    } else {
+      const significantTokenIndex = tokens.indexOf(significantToken);
+
+      offset = significantTokenIndex; ///
+    }
+  } else {
+    const nonTerminalNode = node,  ///
+          firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+          firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken);
+
+    offset = firstSignificantTokenIndex;  ///
+  }
+
+  return offset;
+}
+
+function replacementTokensFromNodeAndTokens(node, tokens) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node,  ///
+          significantToken = terminalNode.getSignificantToken();
+
+    if (significantToken === null) {
+      tokens = [];
+    } else {
+      const token = significantToken; ///
+
+      tokens = [
+        token
+      ];
+    }
+  } else {
+    const nonTerminalNode = node,  ///
+          lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
+          firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+          lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+          firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+          start = firstSignificantTokenIndex, ///
+          end = lastSignificantTokenIndex + 1;
+
+    tokens = tokens.slice(start, end);  ///
+  }
+
+  const replacementTokens = tokens.map((token) => {  ///
+    const replacementToken = token.clone();  ///;
+
+    return replacementToken;
+  });
+
+  return replacementTokens;
+}

package/src/elementMap.js

@@ -8,6 +8,7 @@ import { LINK_RULE_NAME,
          ANCHOR_RULE_NAME,
          MARKER_RULE_NAME,
          BULLET_RULE_NAME,
+         IGNORE_RULE_NAME,
          IMPORT_RULE_NAME,
          IMPORTS_RULE_NAME,
          CONTENTS_RULE_NAME,
@@ -88,6 +89,10 @@ const elementMap = {
     tagName: null,
     className: null
   },
+  [IGNORE_RULE_NAME]: {
+    tagName: null,
+    className: null
+  },
   [IMPORT_RULE_NAME]: {
     tagName: null,
     className: null

package/src/example/view/div/preview.js

@@ -23,12 +23,14 @@ class PreviewDiv extends Element {
     });
   }
 
-  update(domElement) {
-    this.clear();
-
+  update(domElements) {
     const parentDOMElement = this.getParentDOMElement();
 
-    parentDOMElement.appendChild(domElement);
+    this.clear();
+
+    domElements.forEach((domElement) => {
+      parentDOMElement.appendChild(domElement);
+    });
   }
 
   parentContext() {

package/src/example/view/xmp.js

@@ -7,6 +7,16 @@ import { Element } from "easy";
 import { EMPTY_STRING } from "../constants";
 
 class XMP extends Element {
+  update(htmls) {
+    htmls = htmls.join(EMPTY_STRING);
+
+    const body = `<body>
+${htmls}</body>`,
+          html = body;
+
+    this.html(html);
+  }
+
   clear() {
     const html = EMPTY_STRING;
 
@@ -14,12 +24,12 @@ class XMP extends Element {
   }
 
   parentContext() {
-    const xmpHTML = this.html.bind(this),  ///
-          clearXMP = this.clear.bind(this); ///
+    const clearXMP = this.clear.bind(this), ///
+          updateXMP = this.update.bind(this);  ///
 
     return ({
-      xmpHTML,
-      clearXMP
+      clearXMP,
+      updateXMP
     });
   }
 

package/src/example/view.js

@@ -40,24 +40,44 @@ class View extends Element {
 
     if (node !== null) {
       const divisionMarkdownNode = node,  ///
-            parentNode = null,
+            divisionMarkdownNodes = [
+              divisionMarkdownNode
+            ],
             context = {
               tokens,
-              importer
+              importer,
+              divisionMarkdownNodes
             };
 
-      divisionMarkdownNode.resolveImports(parentNode, context);
+      divisionMarkdownNode.resolveImports(context);
 
-      divisionMarkdownNode.createContents(context);
+      divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+        divisionMarkdownNode.createFootnotes(context);
+      });
 
-      divisionMarkdownNode.createFootnotes(context);
+      divisionMarkdownNodes.some((divisionMarkdownNode) => {
+        const contentsCreated = divisionMarkdownNode.createContents(context);
 
-      const html = divisionMarkdownNode.asHTML(context),
-            domElement = divisionMarkdownNode.createDOMElement(context);
+        if (contentsCreated) {
+          return true;
+        }
+      });
 
-      this.xmpHTML(html);
+      const htmls = [],
+            domElements = [];
 
-      this.updatePreviewDiv(domElement);
+      divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+        const html = divisionMarkdownNode.asHTML(context),
+              domElement = divisionMarkdownNode.createDOMElement(context);
+
+        htmls.push(html);
+
+        domElements.push(domElement);
+      });
+
+      this.updateXMP(htmls);
+
+      this.updatePreviewDiv(domElements);
     } else {
       this.clearXMP();
 
@@ -120,23 +140,14 @@ class View extends Element {
     this.update();
   }
 
-  static initialMarkdownStyle = `
-min-height: initial;
-
-@media preview {
-  division division {
-    padding: 24pt;
-  }
-}
+  static initialMarkdownStyle = `min-height: initial;
 
+colour: red;
 `;
 
   static initialMarkdown = `Occam [^occam]
-
-[^occam]: Footnote
-
-@footnotes
-
+  
+@import example.md
 `;
 
   static tagName = "div";
@@ -157,19 +168,20 @@ export default withStyle(View)`
 `;
 
 function importer(filePath, context) {
-  const content = `
-Occam.[^occam]
+  const content = `Occam.[^occam]
 
 [^another]: Occam footnote.
         
         `,
-        className = "introduction",
         tokens = markdownLexer.tokenise(content),
-        node = markdownParser.parse(tokens);
+        node = markdownParser.parse(tokens),
+        importedNode = node,  ///
+        importedTokens = tokens,
+        importedClassName = "introduction";
 
   Object.assign(context, {
-    node,
-    tokens,
-    className
+    importedNode,
+    importedTokens,
+    importedClassName
   });
 }

package/src/markdown/bnf.js

@@ -5,7 +5,9 @@ const bnf = `
     division                ::=  ( subDivision | endOfLine | error )+ ;
     
     
-    subDivision..           ::=  ( endOfLine | <START_OF_CONTENT> ) ( imports 
+    subDivision..           ::=  ( endOfLine | <START_OF_CONTENT> ) ( ignore 
+    
+                                                                    | imports 
     
                                                                     | contents 
     
@@ -79,6 +81,9 @@ const bnf = `
     blockListing            ::=  blockListingStart blockText blockListingEnd ;
 
 
+    ignore                  ::=  "@"<NO_WHITESPACE>"ignore" ;
+
+
     imports                 ::=  import+ ;
 
 

package/src/node/markdown/contentsItem.js

@@ -6,6 +6,17 @@ import ContentsLinkMarkdownNode from "../../node/markdown/contentsLink";
 import { CONTENTS_ITEM_RULE_NAME } from "../../ruleNames";
 
 export default class ContentsItemMarkdownNode extends MarkdownNode {
+  getTokens(tokens = []) {
+    const childNodes = this.getChildNodes(),
+          contentsItemMarkdownNodes = childNodes;  ///
+
+    contentsItemMarkdownNodes.forEach((contentsItemMarkdownNode) => {
+      contentsItemMarkdownNode.getTokens(tokens);
+    });
+
+    return tokens;
+  }
+
   static fromContentsListMarkdownNodeAndNestedHeadingMarkdownNode(ContentsListMarkdownNode, nestedHeadingMarkdownNode, context) {
     const ruleName = CONTENTS_ITEM_RULE_NAME,
           childNodes = [],