occam-verify-cli 0.0.700 → 0.0.702

package/src/context/local.js

@@ -5,7 +5,7 @@ import Collection from "../collection";
 import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
-import { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from "../utilities/collection";
+import { mergeCollections, findCollectionByTerm } from "../utilities/collection";
 
 class LocalContext {
   constructor(context, variables, proofSteps, collections) {
@@ -44,10 +44,11 @@ class LocalContext {
   getCollections() {
     let collections = this.context.getCollections();
 
-    const collectionsA = collections, ///
-          collectionsB = this.collections;
+    const collectionsA = this.collections, ///
+          collectionsB = collections,
+          localContext = this;  ///
 
-    collections = mergeCollections(collectionsA, collectionsB); ///
+    collections = mergeCollections(collectionsA, collectionsB, localContext); ///
 
     return collections;
   }
@@ -66,6 +67,24 @@ class LocalContext {
 
   getMetavariables() { return this.context.getMetavariables(); }
 
+  getTermType(term) {
+    let termType;
+
+    const collections = this.getCollections(),
+          collection = findCollectionByTerm(collections, term);
+
+    if (collection !== null) {
+      const localContext = this,  ///
+            collectionType = collection.getType(localContext);
+
+      termType = collectionType;  ///
+    } else {
+      termType = term.getType();
+    }
+
+    return termType;
+  }
+
   addEquality(equality) {
     let equalityAdded;
 
@@ -88,23 +107,24 @@ class LocalContext {
 
         equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection === null)) {
-        const term = rightTerm, ///
-              collection = leftCollection;  ///
-
-        collection.addTerm(term);
+        leftCollection.addTerm(rightTerm);
 
         equalityAdded = true;
       } else if ((leftCollection === null) && (rightCollection !== null)) {
-        const term = leftTerm, ///
-              collection = rightCollection;  ///
-
-        collection.addTerm(term);
+        rightCollection.addTerm(leftTerm);
 
         equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection !== null)) {
+        if (leftCollection === rightCollection) {
+          const collection = leftCollection;  ///
 
-        debugger
+          collection.addTerm(leftTerm);
+          collection.addTerm(rightTerm);
 
+          equalityAdded = true;
+        } else {
+          debugger
+        }
       }
     }
 
@@ -162,27 +182,6 @@ class LocalContext {
     return statementMatches;
   }
 
-  findCollectionByType(type) {
-    const collections = this.getCollections(),
-          collection = findCollectionByType(collections, type);
-
-    return collection;
-  }
-
-  findCollectionByTerm(term) {
-    const collections = this.getCollections(),
-          collection = findCollectionByTerm(collections, term);
-
-    return collection;
-  }
-
-  findCollectionByTerms(terms) {
-    const collections = this.getCollections(),
-          collection = findCollectionByTerms(collections, terms);
-
-    return collection;
-  }
-
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
@@ -204,35 +203,6 @@ class LocalContext {
     return variablePresent;
   }
 
-  isEqualityEqual(equality) {
-    let equalityEqual;
-
-    const equalityReflexive = equality.isReflexive();
-
-    if (equalityReflexive) {
-      equalityEqual = true;
-    } else {
-      const leftTerm = equality.getLeftTerm(),
-            rightTerm = equality.getRightTerm(),
-            terms = [
-              leftTerm,
-              rightTerm
-            ],
-            termsEqual = this.areTermsEqual(terms);
-
-      equalityEqual = termsEqual; ///
-    }
-
-    return equalityEqual;
-  }
-
-  areTermsEqual(terms) {
-    const collection = this.findCollectionByTerms(terms),
-          termsEqual = (collection !== null);
-
-    return termsEqual;
-  }
-
   toJSON(tokens) {
     const variables = this.variables.map((variable) => {
             const variableJSON = variable.toJSON(tokens);
@@ -288,21 +258,6 @@ class LocalContext {
 
     return localContext;
   }
-
-  static fromLocalContextAndAssignments(localContext, assignments) {
-    const context = localContext,  ///
-          variables = assignments.map((assignment) => {
-            const variable = assignment.getVariable();
-
-            return variable;
-          }),
-          proofSteps = [],
-          collections = [];
-
-    localContext = new LocalContext(context, variables, proofSteps, collections);
-
-    return localContext;
-  }
 }
 
 Object.assign(LocalContext.prototype, contextMixins);

package/src/context/localMeta.js

@@ -15,6 +15,12 @@ class LocalMetaContext {
     return this.context;
   }
 
+  getTermType(term) {
+    const termType = term.getType();
+
+    return termType;
+  }
+
   getMetavariables() {
     let metavariables = this.context.getMetavariables();
 

package/src/equality.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import equalityNodesVerifier from "./verifier/nodes/equality";
+
 export default class Equality {
   constructor(node, leftTerm, rightTerm) {
     this.node = node;
@@ -21,12 +23,31 @@ export default class Equality {
 
   isReflexive() {
     const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
-          reflexive = leftTermMatchesRightTerm;
+          reflexive = leftTermMatchesRightTerm; ///
 
     return reflexive;
   }
 
-  static fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm) {
+  isEqual(context) {
+    const leftTerm = this.getLeftTerm(),
+          rightTerm = this.getRightTerm(),
+          leftTermNode = leftTerm.getNode(),
+          rightTermNode = rightTerm.getNode(),
+          nonTerminalNodeA = leftTermNode,  ///
+          nonTerminalNodeB = rightTermNode, ///
+          collections = context.getCollections(),
+          localContext = this,  ///
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
+          equal = nonTerminalNodeVerified;  ///
+
+    return equal;
+  }
+
+  static fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode) {
     let equality = null;
 
     const leftTermType = leftTerm.getType(),

package/src/premise.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import premiseStatementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable/premise";
-import premiseMetastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable/premise";
+import statementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable";
+import metastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable";
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -46,7 +46,7 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+                nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -67,7 +67,7 @@ export default class Premise {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -77,7 +77,7 @@ export default class Premise {
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetalocalContext) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -99,8 +99,8 @@ export default class Premise {
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
-                metalocalContextB = metastatementMetalocalContext,  ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
+                localMetaContextB = metastatementLocalMetaContext,  ///
+                nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -116,12 +116,12 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetalocalContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
-          metalocalContextB = metastatementMetalocalContext,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
+          localMetaContextB = metastatementLocalMetaContext,  ///
+          nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/supposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import suppositionTermForVariableNodesVerifier from "./verifier/nodes/termForVariable/supposition";
+import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -43,7 +43,7 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = localContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -64,7 +64,7 @@ export default class Supposition {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/utilities/collection.js

@@ -2,9 +2,29 @@
 
 import { compress } from "../utilities/array";
 
-export function mergeCollections(collectionsA, collectionsB) {
-  const typesA = typesFromCollections(collectionsA),
-        typesB = typesFromCollections(collectionsB),
+export function areTermNodesEqual(leftTermNode, rightTermNode, collections) {
+  let termNodesEqual;
+
+  const leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode);
+
+  if (leftTermNodeMatchesRightTermNode) {
+    termNodesEqual = true;
+  } else {
+    const termNodes = [
+            leftTermNode,
+            rightTermNode
+          ],
+          collection = findCollectionByTermNodes(collections, termNodes);
+
+    termNodesEqual = (collection !== null);
+  }
+
+  return termNodesEqual;
+}
+
+export function mergeCollections(collectionsA, collectionsB, localContext) {
+  const typesA = typesFromCollections(collectionsA, localContext),
+        typesB = typesFromCollections(collectionsB, localContext),
         types = [
           ...typesA,
           ...typesB
@@ -19,8 +39,8 @@ export function mergeCollections(collectionsA, collectionsB) {
   const collections = types.map((type) => {
     let collection;
 
-    const collectionA = findCollectionByType(collectionsA, type),
-          collectionB = findCollectionByType(collectionsB, type);
+    const collectionA = findCollectionByType(collectionsA, type, localContext),
+          collectionB = findCollectionByType(collectionsB, type, localContext);
 
     if ((collectionA !== null) && (collectionB !== null)) {
       collection = Collection.fromCollections(collectionA, collectionB);
@@ -36,9 +56,9 @@ export function mergeCollections(collectionsA, collectionsB) {
   return collections;
 }
 
-export function findCollectionByType(collections, type) {
+export function findCollectionByType(collections, type, localContext) {
   const collection = collections.find((collection) => {
-    const collectionMatchesType = collection.matchType(type);
+    const collectionMatchesType = collection.matchType(type, localContext);
 
     if (collectionMatchesType) {
       return true;
@@ -60,9 +80,9 @@ export function findCollectionByTerm(collections, term) {
   return collection;
 }
 
-export function findCollectionByTerms(collections, terms) {
+function findCollectionByTermNodes(collections, termNodes) {
   const collection = collections.find((collection) => {
-    const collectionMatchesTerms = collection.matchTerms(terms);
+    const collectionMatchesTerms = collection.matchTermNodes(termNodes);
 
     if (collectionMatchesTerms) {
       return true;
@@ -72,9 +92,9 @@ export function findCollectionByTerms(collections, terms) {
   return collection;
 }
 
-function typesFromCollections(collections) {
+function typesFromCollections(collections, localContext) {
   const types = collections.map((collection) => {
-    const type = collection.getType();
+    const type = collection.getType(localContext);
 
     return type;
   });

package/src/verifier/node/statementAsCombinator.js

@@ -14,6 +14,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case TYPE_RULE_NAME: {
+        debugger
+
         const typeNode = nonTerminalNode, ///
               typeVerified = verifyType(typeNode, fileContext, verifyAhead),
               typeNodeVerified = typeVerified;  ///
@@ -24,6 +26,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
+        debugger
+
         const termNode = nonTerminalNode, ///
               standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
@@ -34,6 +38,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case STATEMENT_RULE_NAME: {
+        debugger
+
         const statementNode = nonTerminalNode, ///
               standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
               statementNodeVerified = standaloneStatementVerified; ///

package/src/verifier/node/termAsConstructor.js

@@ -2,8 +2,9 @@
 
 import verifyTerm from "../../verify/term";
 import NodeVerifier from "../../verifier/node";
+import verifyGivenType from "../../verify/givenType";
 
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const typeNodeQuery = nodeQuery("/argument/type"),
@@ -71,29 +72,6 @@ export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
   return standaloneTermVerified;
 }
 
-export function verifyType(typeNode, fileContext, verifyAhead) {
-  let typeVerified = false;
-
-  const typeString = fileContext.nodeAsString(typeNode);
-
-  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
-  } else {
-    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
-
-    const verifiedAhead = verifyAhead();
-
-    typeVerified = verifiedAhead; ///
-  }
-
-  return typeVerified;
-}
-
 function verifyArgument(argumentNode, fileContext, verifyAhead) {
   let argumentVerified;
 
@@ -105,9 +83,10 @@ function verifyArgument(argumentNode, fileContext, verifyAhead) {
         termNode = termNodeQuery(argumentNode);
 
   if (typeNode !== null) {
-    const typeVerified = verifyType(typeNode, fileContext, verifyAhead);
+    const types = [], ///
+          givenTypeVerified = verifyGivenType(typeNode, types, fileContext, verifyAhead);
 
-    argumentVerified = typeVerified; ///
+    argumentVerified = givenTypeVerified; ///
   }
 
   if (termNode !== null) {

package/src/verifier/nodes/equality.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { areTermNodesEqual } from "../../utilities/collection";
+
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const ruleNameA = nonTerminalNodeA.getRuleName(), ///
+          ruleNameB = nonTerminalNodeB.getRuleName(); ///
+
+    if (ruleNameA === ruleNameB) {
+      switch (ruleNameA) {
+        case TERM_RULE_NAME: {
+          const leftTermNode = nonTerminalNodeA, ///
+                rightTermNode = nonTerminalNodeB, ///
+                termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+
+          if (termNodesEqual) {
+            const verifiedAhead = verifyAhead();
+
+            nonTerminalNodeVerified = verifiedAhead;  ///
+          } else {
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+          }
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const equalityNodesVerifier = new EqualityNodesVerifier();
+
+export default equalityNodesVerifier;

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -8,7 +8,7 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
+class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
@@ -68,16 +68,12 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
 
       metavariableNodeVerified = metastatementNodeMatches;  ///
     } else {
-      const { createSubstitutions } = this.constructor;
+      const metavariableNode = metavariableNodeA, ///
+            metastatementNode = metastatementNodeB, ///
+            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+            substitution = metastatementForMetavariableSubstitution;  ///
 
-      if (createSubstitutions) {
-        const metavariableNode = metavariableNodeA, ///
-              metastatementNode = metastatementNodeB, ///
-              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-              substitution = metastatementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
+      substitutions.push(substitution);
 
       metavariableNodeVerified = true;
     }
@@ -85,3 +81,7 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
     return metavariableNodeVerified;
   }
 }
+
+const metastatementForMetavariableNodesVerifier = new MetastatementForMetavariableNodesVerifier();
+
+export default metastatementForMetavariableNodesVerifier;

package/src/verifier/nodes/statement.js

@@ -60,7 +60,7 @@ const statementNodesVerifier = new StatementNodesVerifier();
 
 export default statementNodesVerifier;
 
-function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+export function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
   let metaArgumentVerified = false;
 
   const metaArgumentString = context.nodeAsString(metaArgumentNode);

package/src/verifier/nodes/statementForMetavariable.js

@@ -9,7 +9,7 @@ import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME }
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-export default class StatementForMetavariableNodesVerifier extends NodesVerifier {
+class StatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {
     let nonTerminalNodeVerified = false;
 
@@ -84,16 +84,12 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
 
       metavariableNodeVerified = statementNodeMatches;  ///
     } else {
-      const { createSubstitutions } = this.constructor;
+      const metavariableNode = metavariableNodeA, ///
+            statementNode = statementNodeB, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
+            substitution = statementForMetavariableSubstitution;  ///
 
-      if (createSubstitutions) {
-        const metavariableNode = metavariableNodeA, ///
-              statementNode = statementNodeB, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
-              substitution = statementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
+      substitutions.push(substitution);
 
       metavariableNodeVerified = true;
     }
@@ -101,3 +97,7 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
     return metavariableNodeVerified;
   }
 }
+
+const statementForMetavariableNodesVerifier = new StatementForMetavariableNodesVerifier();
+
+export default statementForMetavariableNodesVerifier;