occam-verify-cli 0.0.527 → 0.0.529

package/src/premise.js

@@ -2,9 +2,9 @@
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { premiseStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/premise";
-import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { premiseMetastatementForMetavariableMatcher } from "./matcher/metastatementForMetavariable/premise";
+import { premiseStatementForMetavariableVerifier } from "./verifier/statementForMetavariable/premise";
+import { metastatementNodeFromMetastatementString } from "./utilities/node";
+import { premiseMetastatementForMetavariableVerifier } from "./verifier/metastatementForMetavariable/premise";
 
 const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
@@ -43,7 +43,7 @@ export default class Premise {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
           if (nonTerminalNodeMatches) {
             return true;
@@ -58,7 +58,7 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -85,7 +85,7 @@ export default class Premise {
                                     const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
                                           nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                                           nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                     if (nonTerminalNodeMatches) {
                                       return true;
@@ -100,7 +100,7 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
@@ -116,10 +116,10 @@ export default class Premise {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { metastatement } = json,
           metastatementString = metastatement,  ///
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, releaseContext),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           premise = new Premise(metastatementNode);
 
     return premise;

package/src/rule.js

@@ -134,7 +134,7 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     let rule;
 
     let { labels } = json;
@@ -143,7 +143,7 @@ export default class Rule {
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, releaseContext);
+            label = Label.fromJSON(json, lexer, parser);
 
       return label;
     });
@@ -154,7 +154,7 @@ export default class Rule {
 
     premises = premisesJSON.map((premiseJSON) => {
       const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, releaseContext);
+            premise = Premise.fromJSON(json, lexer, parser);
 
       return premise;
     });
@@ -165,7 +165,7 @@ export default class Rule {
 
     json = conclusionJSON;  ///
 
-    conclusion = Conclusion.fromJSON(json, releaseContext);
+    conclusion = Conclusion.fromJSON(json, lexer, parser);
 
     rule = new Rule(labels, premises, conclusion);
 

package/src/step/metaproof.js

@@ -2,7 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { matchBracketedNonTerminalNode } from "../utilities/substitution";
+import { matchMetastatementModuloBrackets } from "../utilities/metaproof";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),
@@ -22,41 +22,44 @@ export default class MetaproofStep {
     return this.metastatementNode;
   }
 
-  matchMetastatement(metastatementNode) {
-    let metastatementMatches;
+  match(metastatementNode) {
+    let matches = false;
 
-    const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
+    if (!matches) {
+      const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
 
-    if (ruleSubproofAssertionNode !== null) {
-      const ruleSubproofAssertionMatches = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
+      if (ruleSubproofAssertionNode !== null) {
+        const matchesRuleSubproofAssertion = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
 
-      metastatementMatches = ruleSubproofAssertionMatches;  ///
-    } else {
-      const metastatementsMatch = this.matchMetastatements(metastatementNode);
+        matches = matchesRuleSubproofAssertion;  ///
+      }
+    }
 
-      metastatementMatches = metastatementsMatch; //
+    if (!matches) {
+      const matchesMetastatement = this.matchMetastatement(metastatementNode);
+
+      matches = matchesMetastatement; ///
     }
 
-    return metastatementMatches;
+    return matches;
   }
 
-  matchMetastatements(metastatementNode) {
-    let metastatementsMatch = false;
+  matchMetastatement(metastatementNode) {
+    let matchesMetastatement = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = metastatementNode, ///
-            nonTerminalNodeB = this.metastatementNode,  ///
-            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
-            metastatementNodeMatches = bracketedNodeMatches;  ///
+      const metastatementNodeA = metastatementNode, ///
+            metastatementNodeB = this.metastatementNode,  ///
+            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-      return metastatementNodeMatches;
+      matchesMetastatement = metastatementMatchesModuloBrackets;  ///
     }
 
-    return metastatementsMatch;
+    return matchesMetastatement;
   }
 
   matchRuleSubproofAssertion(ruleSubproofAssertionNode) {
-    let ruleSubproofAssertionMatches = false;
+    let matchesRuleSubproofAssertion = false;
 
     if (this.ruleSubproofNode !== null) {
       const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
@@ -64,23 +67,23 @@ export default class MetaproofStep {
             qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.ruleSubproofNode),
             firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-      const nonTerminalNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
-            nonTerminalNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+      const metastatementNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
+            metastatementNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-      if (bracketedNodeMatches) {
+      if (metastatementMatchesModuloBrackets) {
         const secondRuleSubproofAssertionMetastatementNode = second(ruleSubproofAssertionMetastatementNodes),
               secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-        const nonTerminalNodeA = secondRuleSubproofAssertionMetastatementNode, ///
-              nonTerminalNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+        const metastatementNodeA = secondRuleSubproofAssertionMetastatementNode, ///
+              metastatementNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-        ruleSubproofAssertionMatches = bracketedNodeMatches; ///
+        matchesRuleSubproofAssertion = metastatementMatchesModuloBrackets; ///
       }
     }
 
-    return ruleSubproofAssertionMatches;
+    return matchesRuleSubproofAssertion;
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {

package/src/step/proof.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import { matchBracketedNonTerminalNode } from "../utilities/substitution";
+import { META_ARGUMENT_RULE_NAME } from "../ruleNames";
+import { matchStatementModuloBrackets } from "../utilities/proof";
 
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
@@ -16,29 +17,29 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  matchStatement(statementNode) {
-    let statementMatches;
+  match(statementNode) {
+    let matches;
 
-    const statementsMatch = this.matchStatements(statementNode);
+    const matchesStatement = this.matchStatement(statementNode);
 
-    statementMatches = statementsMatch; //
+    matches = matchesStatement; //
 
-    return statementMatches;
+    return matches;
   }
 
-  matchStatements(statementNode) {
-    let statementsMatch = false;
+  matchStatement(statementNode) {
+    let matchesStatement = false;
 
     if (this.statementNode !== null) {
-      const nonTerminalNodeA = statementNode, ///
-            nonTerminalNodeB = this.statementNode,  ///
-            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
-            statementNodeMatches = bracketedNodeMatches;  ///
+      const ruleName = META_ARGUMENT_RULE_NAME,
+            statementNodeA = statementNode, ///
+            statementNodeB = this.statementNode,  ///
+            statementMatchesModuloBrackets = matchStatementModuloBrackets(statementNodeA, statementNodeB, ruleName);
 
-      return statementNodeMatches;
+      matchesStatement = statementMatchesModuloBrackets;  ///
     }
 
-    return statementsMatch;
+    return matchesStatement;
   }
 
   static fromSubproofNode(subproofNode) {

package/src/substitution/metastatementForMetavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { matcher } from "../matcher";
-import { METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+import matcher from "../matcher";
+
+import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
 
 export default class MetastatementForMetavariableSubstitution {
   constructor(metavariableName, metastatementNode) {
@@ -28,14 +28,11 @@ export default class MetastatementForMetavariableSubstitution {
     matchesMetastatementNode = nodeMatches;  ///
 
     if (!matchesMetastatementNode) {
-      const nonTerminalNode = metastatementNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = METASTATEMENT_RULE_NAME;
-
-      metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+      const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
-      if (metastatementNode !== null) {
-        const nodeA = this.metastatementNode,  ///
+      if (bracketedMetastatementChildNode !== null) {
+        const metastatementNode = bracketedMetastatementChildNode, ///
+              nodeA = this.metastatementNode,  ///
               nodeB = metastatementNode,
               nodeMatches = matcher.matchNode(nodeA, nodeB);
 
@@ -49,13 +46,11 @@ export default class MetastatementForMetavariableSubstitution {
   static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
     let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
 
-    const nonTerminalNode = metastatementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = METASTATEMENT_RULE_NAME;
+    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
-    metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+    if (bracketedMetastatementChildNode !== null) {
+      const metastatementNode = bracketedMetastatementChildNode; ///
 
-    if (metastatementNode !== null) {
       metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
     }
 

package/src/substitution/statementForMetavariable.js

@@ -1,11 +1,8 @@
 "use strict";
 
-import { matcher } from "../matcher";
-import { nodeQuery } from "../utilities/query";
-import { META_ARGUMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+import matcher from "../matcher";
 
-const statementNodeQuery = nodeQuery('/metaArgument/statement!');
+import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution {
   constructor(metavariableName, statementNode) {
@@ -31,21 +28,15 @@ export default class StatementForMetavariableSubstitution {
     matchesStatementNode = nodeMatches;  ///
 
     if (!matchesStatementNode) {
-      const nonTerminalNode = statementNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = META_ARGUMENT_RULE_NAME,
-            metaArgumentNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+      const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
-      if (metaArgumentNode !== null) {
-        const statementNode = statementNodeQuery(metaArgumentNode);
+      if (bracketedStatementChildNode !== null) {
+        const statementNode = bracketedStatementChildNode, ///
+              nodeA = this.statementNode,  ///
+              nodeB = statementNode,
+              nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-        if (statementNode !== null) {
-          const nodeA = this.statementNode,  ///
-                nodeB = statementNode,
-                nodeMatches = matcher.matchNode(nodeA, nodeB);
-
-          matchesStatementNode = nodeMatches;  ///
-        }
+        matchesStatementNode = nodeMatches;  ///
       }
     }
 
@@ -55,14 +46,11 @@ export default class StatementForMetavariableSubstitution {
   static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
     let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
 
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = META_ARGUMENT_RULE_NAME,
-          metaArgumentNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+    const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
-    statementNode = statementNodeQuery(metaArgumentNode);
+    if (bracketedStatementChildNode !== null) {
+      const statementNode = bracketedStatementChildNode; ///
 
-    if (statementNode !== null) {
       statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
     }
 

package/src/substitution/termForVariable.js

@@ -1,8 +1,6 @@
 "use strict";
 
-import { matcher } from "../matcher";
-import { STATEMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+import matcher from "../matcher";
 
 export default class TermForVariableSubstitution {
   constructor(variableName, termNode) {
@@ -27,37 +25,11 @@ export default class TermForVariableSubstitution {
 
     matchesTermNode = nodeMatches;  ///
 
-    if (!matchesTermNode) {
-      const nonTerminalNode = termNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = STATEMENT_RULE_NAME;
-
-      termNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
-
-      if (termNode !== null) {
-        const nodeA = this.termNode,  ///
-              nodeB = termNode,
-              nodeMatches = matcher.matchNode(nodeA, nodeB);
-
-        matchesTermNode = nodeMatches;  ///
-      }
-    }
-
     return matchesTermNode;
   }
 
   static fromVariableNameAndTermNode(variableName, termNode) {
-    let termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
-
-    const nonTerminalNode = termNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = STATEMENT_RULE_NAME;
-
-    termNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
-
-    if (termNode !== null) {
-      termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
-    }
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
 
     return termForVariableSubstitution;
   }

package/src/supposition.js

@@ -2,8 +2,8 @@
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString } from "./utilities/string";
-import { suppositionTermForVariableMatcher } from "./matcher/termForVariable/supposition";
+import { statementNodeFromStatementString } from "./utilities/node";
+import { suppositionTermForVariableVerifier } from "./verifier/termForVariable/supposition";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
@@ -40,7 +40,7 @@ export default class Supposition {
                                 const subproofStatementNode = subproofStatementNodes[index],
                                       nonTerminalNodeA = subproofAssertionStatementNode,  ///
                                       nonTerminalNodeB = subproofStatementNode, ///
-                                      nonTerminalNodeMatches = suppositionTermForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                                      nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                 if (nonTerminalNodeMatches) {
                                   return true;
@@ -55,7 +55,7 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = suppositionTermForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -71,10 +71,10 @@ export default class Supposition {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { statement } = json,
           statementString = statement,  ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           supposition = new Supposition(statementNode);
 
     return supposition;

package/src/theorem.js

@@ -7,7 +7,7 @@ import { THEOREM_KIND } from "./kinds";
 export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, releaseContext) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, releaseContext); }
+  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, lexer, parser); }
 
   static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }

package/src/type.js

@@ -124,14 +124,14 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     let type;
 
     let { superType } = json;
 
     const superTypeJSON = superType;  ///
 
-    superType = superTypeFromSuperTypeJSON(superTypeJSON, releaseContext);
+    superType = superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser);
 
     const { name } = json;
 
@@ -181,7 +181,7 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSON(superTypeJSON, releaseContext) {
+function superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser) {
   let superType;
 
   const json = superTypeJSON, ///
@@ -195,7 +195,7 @@ function superTypeFromSuperTypeJSON(superTypeJSON, releaseContext) {
 
     superType = (type !== null) ?
                   type :  ///
-                    Type.fromJSON(json, releaseContext);  ///
+                    Type.fromJSON(json, lexer, parser);  ///
   }
 
   return superType;

package/src/utilities/metaproof.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import matcher from "../matcher";
+import bracketedMetastatementNode from "../node/metastatement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_METASTATEMENT_DEPTH } from "../constants";
+
+const bracketedMetastatementChildNodeQuery = nodeQuery('/metastatement/metastatement!');
+
+export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
+  let metastatementMatchesModuloBrackets = false;
+
+  if (!metastatementMatchesModuloBrackets) {
+    const nodeA = metastatementNodeA,  ///
+          nodeB = metastatementNodeB,  ///
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    metastatementMatchesModuloBrackets = nodeMatches;  ///
+  }
+
+  if (!metastatementMatchesModuloBrackets) {
+    const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
+
+    if (bracketedMetastatementChildNodeA !== null) {
+      const nodeA = bracketedMetastatementChildNodeA,  ///
+            nodeB = metastatementNodeB, ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      metastatementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  if (!metastatementMatchesModuloBrackets) {
+    const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
+
+    if (bracketedMetastatementChildNodeB !== null) {
+      const nodeA = metastatementNodeA, ///
+            nodeB = bracketedMetastatementChildNodeB,  ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      metastatementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  return metastatementMatchesModuloBrackets;
+}
+
+export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {
+  let bracketedMetastatementChildNode = null;
+
+  const nodeA = metastatementNode,  ///
+        nodeB = bracketedMetastatementNode,  ///
+        depth = BRACKETED_METASTATEMENT_DEPTH,
+        nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+  if (nonTerminalNodeMatches) {
+    bracketedMetastatementChildNode = bracketedMetastatementChildNodeQuery(metastatementNode);
+  }
+
+  return bracketedMetastatementChildNode;
+}

package/src/utilities/node.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import { rewriteNodes } from "occam-grammar-utilities";
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+
+import { nodeQuery } from "../utilities/query";
+import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME } from "../ruleNames";
+
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
+
+const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+
+const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
+      florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+      florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+
+const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
+
+export function termNodeFromTermString(termString, lexer, parser) {
+  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
+        content = `Constructor ${termString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        constructorDeclarationNode = node, ///
+        termNode = termNodeQuery(constructorDeclarationNode);
+
+  return termNode;
+}
+
+export function labelNodeFromLabelString(labelString, lexer, parser) {
+  const content = labelString, ///
+        ruleName = LABEL_RULE_NAME,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        labelNode = node; ///
+
+  return labelNode;
+}
+
+export function statementNodeFromStatementString(statementString, lexer, parser) {
+  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        content = `${statementString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        unqualifiedStatementNode = node,  ///
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
+  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
+        content = `${metastatementString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        unqualifiedMetastatementNode = node,  ///
+        metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+  return metastatementNode;
+}
+
+function nodeFromContentAndRuleName(content, ruleName, lexer = florenceLexer, parser = florenceParser) {
+  const ruleMap = parser.getRuleMap(),
+        rule = ruleMap[ruleName],
+        tokens = lexer.tokenise(content),
+        node = parser.parse(tokens, rule);
+
+  rewriteNodes(node);
+
+  return node;
+}