occam-verify-cli 0.0.270 → 0.0.271

package/bin/assertion.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const { nodeQuery } = require("./utilities/query");
+
+const statementNodeQuery = nodeQuery("/*/statement!");
+
+class Assertion {
+  constructor(subproofNode, statementNode) {
+    this.subproofNode = subproofNode;
+    this.statementNode = statementNode;
+  }
+
+  getNonTerminalNode() {
+    const nonTerminalNode = (this.statementNode !== null) ?
+                               this.statementNode :
+                                 null;
+
+    return nonTerminalNode;
+  }
+
+  getSubproofNode() {
+    return this.subproofNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  match(assertion) {
+    let matches = false;
+
+    const statementNode = assertion.getstatementNode();
+
+    if ((statementNode !== null) && (this.statementNode !== null)) {
+      const nonTerminalNode = this.statementNode, ///
+            assertionNonTerminalNode = statementNode, ///
+            assertionNonTerminalNodeMatches = matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode);
+
+      matches = assertionNonTerminalNodeMatches;  ///
+    }
+
+    return matches;
+  }
+
+  static fromSubproofNode(subproofNode) {
+    const statementNode = null,
+          assertion = new Assertion(subproofNode, statementNode);
+
+    return assertion;
+  }
+
+  static fromQualifiedStatementNode(qualifiedStatementNode) {
+    const subproofNode = null,
+          statementNode = statementNodeQuery(qualifiedStatementNode),
+          assertion = new Assertion(subproofNode, statementNode);
+
+    return assertion;
+  }
+
+  static fromUnqualifiedStatementNode(unqualifiedStatementNode) {
+    const subproofNode = null,
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          assertion = new Assertion(subproofNode, statementNode);
+
+    return assertion;
+  }
+}
+
+module.exports = Assertion;
+
+function matchAssertionNode(assertionNode, node) {
+  let assertionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = assertionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            assertionTerminalNode = assertionNode,  ///
+            assertionTerminalNodeMatches = matchAssertionTerminalNode(assertionTerminalNode, terminalNode);
+
+      assertionNodeMatches = assertionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            assertionNonTerminalNode = assertionNode,  ///
+            assertionNonTerminalNodeMatches = matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode);
+
+      assertionNodeMatches = assertionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return assertionNodeMatches;
+}
+
+function matchAssertionChildNodes(assertionChildNodes, childNodes) {
+  let assertionChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+      assertionChildNodesLength = assertionChildNodes.length;
+
+  if (childNodesLength === assertionChildNodesLength) {
+    assertionChildNodesMatches = childNodes.every((childNode, index) => {
+      const assertionChildNode = assertionChildNodes[index],
+            assertionNode = assertionChildNode, ///
+            node = childNode, ///
+            assertionNodeMatches = matchAssertionNode(assertionNode, node);
+
+      if (assertionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return assertionChildNodesMatches;
+}
+
+function matchAssertionTerminalNode(assertionTerminalNode, terminalNode) {
+  let assertionTerminalNodeMatches = false;
+
+  const matches = assertionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    assertionTerminalNodeMatches = true;
+  }
+
+  return assertionTerminalNodeMatches;
+}
+
+function matchAssertionNonTerminalNode(assertionNonTerminalNode, nonTerminalNode) {
+  let assertionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        assertionRuleName = assertionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === assertionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          assertionChildNodes = assertionNonTerminalNode.getChildNodes(),
+          assertionChildNodesMatches = matchAssertionChildNodes(assertionChildNodes, childNodes);
+
+    assertionNonTerminalNodeMatches = assertionChildNodesMatches; ///
+  }
+
+  return assertionNonTerminalNodeMatches;
+}

package/bin/conclusion.js

@@ -1,7 +1,8 @@
 "use strict";
 
-const { METAVARIABLE_RULE_NAME } = require("./ruleNames"),
-      { metavariableNameFromMetavariableNode } = require("./utilities/query");
+const { first } = require("./utilities/array"),
+      { metavariableNameFromMetavariableNode } = require("./utilities/query"),
+      { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } = require("./ruleNames");
 
 class Conclusion {
   constructor(metastatementNode) {
@@ -12,13 +13,13 @@ class Conclusion {
     return this.metastatementNode;
   }
 
-  matchNonTerminalNode(metastatementNode, metaSubstitutions) {
+  matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           conclusionNonTerminalNode = this.metastatementNode,  ///
           conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          nonTerminalNodeMatches = conclusionNonTerminalNodeMatches; ///
+          metastatementNodeMatches = conclusionNonTerminalNodeMatches; ///
 
-    return nonTerminalNodeMatches;
+    return metastatementNodeMatches;
   }
 
   static fromMetastatementNode(metastatementNode) {
@@ -55,29 +56,27 @@ function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
   return conclusionNodeMatches;
 }
 
-function matchConclusionChildNodes(conclusionChildNodes, childNodes, metaSubstitutions) {
-  let conclusionChildNodesMatches = false;
+function matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
+  let conclusionNodesMatches = false;
 
-  const childNodesLength = childNodes.length,
-        conclusionChildNodesLength = conclusionChildNodes.length;
+  const nodesLength = nodes.length,
+        conclusionNodesLength = conclusionNodes.length;
 
-  if (childNodesLength === conclusionChildNodesLength) {
-    conclusionChildNodesMatches = childNodes.every((childNode, index) => {
-      const conclusionChildNode = conclusionChildNodes[index],
-            conclusionNode = conclusionChildNode, ///
-            node = childNode, ///
+  if (nodesLength === conclusionNodesLength) {
+    conclusionNodesMatches = nodes.every((node, index) => {
+      const conclusionNode = conclusionNodes[index],
             conclusionNodeMatches = matchConclusionNode(conclusionNode, node, metaSubstitutions);
 
       if (conclusionNodeMatches) {
         return true;
       }
-    })
+    });
   }
 
-  return conclusionChildNodesMatches;
+  return conclusionNodesMatches;
 }
 
-function matchConclusionMetavariable(conclusionMetavariableNode, nonTerminalNode, metaSubstitutions) {
+function matchConclusionMetavariable(conclusionMetavariableNode, nodes, metaSubstitutions) {
   let conclusionMetavariableMatches = true;
 
   const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
@@ -90,22 +89,17 @@ function matchConclusionMetavariable(conclusionMetavariableNode, nonTerminalNode
         }) || null;
 
   if (metaSubstitution !== null) {
-    const metaSubstitutionNonTerminalNodeMatches = metaSubstitution.matchNonTerminalNode(nonTerminalNode);
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
 
-    conclusionMetavariableMatches = metaSubstitutionNonTerminalNodeMatches;  ///
+    conclusionMetavariableMatches = metaSubstitutionNodesMatch;  ///
   }
 
   return conclusionMetavariableMatches;
 }
 
 function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions) {
-  let conclusionTerminalNodeMatches = false;
-
-  const matches = conclusionTerminalNode.match(terminalNode);
-
-  if (matches) {
-    conclusionTerminalNodeMatches = true;
-  }
+  const matches = conclusionTerminalNode.match(terminalNode),
+        conclusionTerminalNodeMatches = matches;  ///
 
   return conclusionTerminalNodeMatches;
 }
@@ -113,30 +107,62 @@ function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaS
 function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
   let conclusionNonTerminalNodeMatches = false;
 
-  const conclusionRuleName = conclusionNonTerminalNode.getRuleName(); ///
+  const ruleName = nonTerminalNode.getRuleName(),
+        conclusionRuleName = conclusionNonTerminalNode.getRuleName(); ///
 
-  switch (conclusionRuleName) {
-    case METAVARIABLE_RULE_NAME: {
-      const conclusionMetavariableNode = conclusionNonTerminalNode, ///
-            conclusionMetavariableMatches = matchConclusionMetavariable(conclusionMetavariableNode, nonTerminalNode, metaSubstitutions);
+  if (ruleName === conclusionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          conclusionNodes = conclusionChildNodes, ///
+          conclusionChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
 
-      conclusionNonTerminalNodeMatches = conclusionMetavariableMatches;
+    conclusionNonTerminalNodeMatches = conclusionChildNodesMatches; ///
 
-      break;
+    if (!conclusionNonTerminalNodeMatches) {
+      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
+
+      if (ruleNameMetastatementRuleName) {
+        const metastatementNode = nonTerminalNode,  ///
+              conclusionMetastatementNode = conclusionNonTerminalNode,  ///
+              conclusionMetastatementNodeMatches = matchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions);
+
+        conclusionNonTerminalNodeMatches = conclusionMetastatementNodeMatches; ///
+      }
     }
+  }
 
-    default: {
-      const ruleName = nonTerminalNode.getRuleName();
+  return conclusionNonTerminalNodeMatches;
+}
+
+function matchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions) {
+  let conclusionMetastatementNodeMatches = false;
+
+  const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
+        conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        conclusionChildNodesLength = conclusionChildNodes.length;
+
+  if (conclusionChildNodesLength === 1) {
+    const firstConclusionChildNode = first(conclusionChildNodes),
+          conclusionChildNode = firstConclusionChildNode,  ///
+          conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
 
-      if (ruleName === conclusionRuleName) {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
-              conclusionChildNodesMatches = matchConclusionChildNodes(conclusionChildNodes, childNodes, metaSubstitutions);
+    if (conclusionChildNodeNonTerminalNode) {
+      const conclusionNonTerminalChildNode = conclusionChildNode,  ///
+            conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
+            conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
 
-        conclusionNonTerminalNodeMatches = conclusionChildNodesMatches; ///
+      if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
+        const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
+              nonTerminalNode = metastatementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              conclusionMetaVariableMatches = matchConclusionMetavariable(conclusionMetavariableNode, nodes, metaSubstitutions);
+
+        conclusionMetastatementNodeMatches = conclusionMetaVariableMatches; ///
       }
     }
   }
 
-  return conclusionNonTerminalNodeMatches;
+  return conclusionMetastatementNodeMatches;
 }

package/bin/constants.js

@@ -2,8 +2,18 @@
 
 const COMMA = ',';
 const EMPTY_STRING = "";
+const LEFT_BRACKET = "(";
+const RIGHT_BRACKET = ")";
+const MAXIMUM_INDEXES_LENGTH = 10;
+const MAXIMUM_PERMUTATION_LENGTH = 5;
+const BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH = 3;
 
 module.exports = {
   COMMA,
-  EMPTY_STRING
+  EMPTY_STRING,
+  LEFT_BRACKET,
+  RIGHT_BRACKET,
+  MAXIMUM_INDEXES_LENGTH,
+  MAXIMUM_PERMUTATION_LENGTH,
+  BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH
 };

package/bin/context/file.js

@@ -116,6 +116,12 @@ class FileContext {
     return this.packageContext;
   }
 
+  getMetaAssertions() {
+    const metaAssertions = [];
+
+    return metaAssertions;
+  }
+
   findTypeByTypeName(typeName) {
     const types = this.getTypes(),
           type = types.find((type) => {
@@ -186,10 +192,10 @@ class FileContext {
     return labelPresent;
   }
 
-  isMetaAssertionPresent(metaAssertion) {
-    const metaAssertionPresent = false;
+  matchMetaAssertion(metaAssertion) {
+    const metaAssertionMatches = false;
 
-    return metaAssertionPresent;
+    return metaAssertionMatches;
   }
 
   isTypePresentByTypeName(typeName) {

package/bin/context/metaproof.js

@@ -16,7 +16,14 @@ class MetaproofContext {
   }
 
   getMetaAssertions() {
-    return this.metaAssertions;
+    let metaAssertions = this.context.getMetaAssertions();
+
+    metaAssertions = [
+      ...metaAssertions,
+      ...this.metaAssertions
+    ];
+
+    return metaAssertions;
   }
 
   getRules() { return this.context.getRules(); }
@@ -39,11 +46,13 @@ class MetaproofContext {
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-  isMetaAssertionPresent(metaAssertion) {
-    const metaAssertionA = metaAssertion; ///
+  matchMetaAssertion(metaAssertion) {
+    let metaAssertionMatches;
+
+    const metaAssertionB = metaAssertion; ///
 
-    let metaAssertionPresent = this.metaAssertions.some((metaAssertion) => {
-      const metaAssertionB = metaAssertion, ///
+    metaAssertionMatches = this.metaAssertions.some((metaAssertion) => {
+      const metaAssertionA = metaAssertion, ///
             matches = metaAssertionA.match(metaAssertionB);
 
       if (matches) {
@@ -51,11 +60,11 @@ class MetaproofContext {
       }
     });
 
-    if (!metaAssertionPresent) {
-      metaAssertionPresent = this.context.isMetaAssertionPresent(metaAssertion);
+    if (!metaAssertionMatches) {
+      metaAssertionMatches = this.context.matchMetaAssertion(metaAssertion);
     }
 
-    return metaAssertionPresent;
+    return metaAssertionMatches;
   }
 
   isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }

package/bin/metaAssertion.js

@@ -1,8 +1,13 @@
 "use strict";
 
-const { nodeQuery } = require("./utilities/query");
+const { first, second } = require("./utilities/array"),
+      { nodeQuery, nodesQuery } = require("./utilities/query"),
+      { matchBracketedMetastatementChildNode } = require("./utilities/metastatement");
 
-const metastatementNodeQuery = nodeQuery("/*/metastatement!");
+const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
+      metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 class MetaAssertion {
   constructor(metaSubproofNode, metastatementNode) {
@@ -10,14 +15,6 @@ class MetaAssertion {
     this.metastatementNode = metastatementNode;
   }
 
-  getNonTerminalNode() {
-    const nonTerminalNode = (this.metastatementNode !== null) ?
-                               this.metastatementNode :
-                                 null;
-
-    return nonTerminalNode;
-  }
-
   getMetaSubproofNode() {
     return this.metaSubproofNode;
   }
@@ -31,17 +28,65 @@ class MetaAssertion {
 
     const metastatementNode = metaAssertion.getMetastatementNode();
 
-    if ((metastatementNode !== null) && (this.metastatementNode !== null)) {
-      const nonTerminalNode = this.metastatementNode, ///
-            metaAssertionNonTerminalNode = metastatementNode, ///
-            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+    if (metastatementNode !== null) {
+      const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(metastatementNode);
+
+      if (metaSubproofAssertionNode === null) {
+        const metastatementNodeMatches = this.matchMetastatementNode(metastatementNode);
+
+        matches = metastatementNodeMatches;  ///
+      } else {
+        const metaSubproofAssertionNodeMatches = this.matchMetaSubproofAssertionNode(metaSubproofAssertionNode);
 
-      matches = metaAssertionNonTerminalNodeMatches;  ///
+        matches = metaSubproofAssertionNodeMatches; ///
+      }
     }
 
     return matches;
   }
 
+  matchMetastatementNode(metastatementNode) {
+    let metastatementNodeMatches = false;
+
+    if (this.metastatementNode !== null) {
+      const topmostMetastatementNode = metastatementNode, ///
+            topmostMetaAssertionMetastatementNode = this.metastatementNode,  ///
+            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
+
+      metastatementNodeMatches = topmostMetaAssertionMetastatementNodeMatches;  ///
+    }
+
+    return metastatementNodeMatches;
+  }
+
+  matchMetaSubproofAssertionNode(metaSubproofAssertionNode) {
+    let metaSubproofAssertionNodeMatches = false;
+
+    if (this.metaSubproofNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
+            firstMetaSubproofAssertionMetastatementNode = first(metaSubproofAssertionMetastatementNodes),
+            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.metaSubproofNode),
+            firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+      const topmostMetastatementNode = firstMetaSubproofAssertionMetastatementNode,  ///
+            topmostMetaAssertionMetastatementNode = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
+
+      if (topmostMetaAssertionMetastatementNodeMatches) {
+        const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
+              secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
+
+        const topmostMetastatementNode = secondMetaSubproofAssertionMetastatementNode, ///
+              topmostMetaAssertionMetastatementNode = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
+
+        metaSubproofAssertionNodeMatches = topmostMetaAssertionMetastatementNodeMatches; ///
+      }
+    }
+
+    return metaSubproofAssertionNodeMatches;
+  }
+
   static fromMetaSubproofNode(metaSubproofNode) {
     const metastatementNode = null,
           metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
@@ -49,6 +94,13 @@ class MetaAssertion {
     return metaAssertion;
   }
 
+  static fromMetastatementNode(metastatementNode) {
+    const metaSubproofNode = null,
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+
   static fromQualifiedMetastatementNode(qualifiedMetastatementNode) {
     const metaSubproofNode = null,
           metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
@@ -93,26 +145,24 @@ function matchMetaAssertionNode(metaAssertionNode, node) {
   return metaAssertionNodeMatches;
 }
 
-function matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes) {
-  let metaAssertionChildNodesMatches = false;
+function matchMetaAssertionNodes(metaAssertionNodes, nodes) {
+  let metaAssertionNodesMatches = false;
 
-  const childNodesLength = childNodes.length,
-      metaAssertionChildNodesLength = metaAssertionChildNodes.length;
+  const nodesLength = nodes.length,
+        metaAssertionNodesLength = metaAssertionNodes.length;
 
-  if (childNodesLength === metaAssertionChildNodesLength) {
-    metaAssertionChildNodesMatches = childNodes.every((childNode, index) => {
-      const metaAssertionChildNode = metaAssertionChildNodes[index],
-            metaAssertionNode = metaAssertionChildNode, ///
-            node = childNode, ///
+  if (nodesLength === metaAssertionNodesLength) {
+    metaAssertionNodesMatches = nodes.every((node, index) => {
+      const metaAssertionNode = metaAssertionNodes[index],
             metaAssertionNodeMatches = matchMetaAssertionNode(metaAssertionNode, node);
 
       if (metaAssertionNodeMatches) {
         return true;
       }
-    })
+    });
   }
 
-  return metaAssertionChildNodesMatches;
+  return metaAssertionNodesMatches;
 }
 
 function matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode) {
@@ -135,11 +185,63 @@ function matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerm
 
   if (ruleName === metaAssertionRuleName) {
     const childNodes = nonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
           metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
-          metaAssertionChildNodesMatches = matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes);
+          metaAssertionNodes = metaAssertionChildNodes, ///
+          metaAssertionNodesMatches = matchMetaAssertionNodes(metaAssertionNodes, nodes);
 
-    metaAssertionNonTerminalNodeMatches = metaAssertionChildNodesMatches; ///
+    metaAssertionNonTerminalNodeMatches = metaAssertionNodesMatches;  ///
   }
 
   return metaAssertionNonTerminalNodeMatches;
 }
+
+function matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode) {
+  const nonTerminalNode = metastatementNode,  ///
+        metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
+        metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode),
+        metaAssertionMetastatementNodeNatches = metaAssertionNonTerminalNodeMatches;  ///
+
+  return metaAssertionMetastatementNodeNatches;
+}
+
+function matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode) {
+  let metaAssertionMetastatementNodeMatches;
+
+  const metastatementNode = topmostMetastatementNode, ///
+        metaAssertionMetastatementNode = topmostMetaAssertionMetastatementNode;  ///
+
+  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode);
+
+  if (!metaAssertionMetastatementNodeMatches) {
+    const nonTerminalNode = metastatementNode,  ///
+          childNodes = nonTerminalNode, ///
+          bracketedMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(childNodes, (bracketedMetastatementChildNode) => {
+            const metastatementNode = bracketedMetastatementChildNode,  ///
+                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
+                  bracketedMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
+
+            return bracketedMetastatementChildNodeMatches;
+          });
+
+    metaAssertionMetastatementNodeMatches = bracketedMetastatementChildNodeMatches;  ///
+  }
+
+  if (!metaAssertionMetastatementNodeMatches) {
+    const metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
+          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
+          bracketedMetaAssertionMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(metaAssertionChildNodes, (bracketedMetaAssertionMetastatementChildNode) => {
+            const metaAssertionMetastatementNode = bracketedMetaAssertionMetastatementChildNode,  ///
+                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
+                  bracketedMetaAssertionMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
+
+            return bracketedMetaAssertionMetastatementChildNodeMatches;
+          });
+
+    metaAssertionMetastatementNodeMatches = bracketedMetaAssertionMetastatementChildNodeMatches;  ///
+  }
+
+  const topmostMetaAssertionMetastatementNodeMatches = metaAssertionMetastatementNodeMatches;  ///
+
+  return topmostMetaAssertionMetastatementNodeMatches;
+}