occam-verify-cli 0.0.700 → 0.0.702

package/src/verify/statement.js

@@ -38,53 +38,32 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
   return statementVerified;
 }
 
-Object.assign(verifyStatement, {
-  statementNodesVerifier
+Object.assign(statementNodesVerifier, {
+  verifyStatement
 });
 
 export default verifyStatement;
 
-export function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAgainstCombinators;
-
-  let combinators = context.getCombinators();
-
-  combinators = [ ///
-    bracketedCombinator,
-    ...combinators
-  ];
-
-  statementVerifiedAgainstCombinators = combinators.some((combinator) => {
-    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
-
-    if (statementVerifiedAgainstCombinator) {
-      return true;
-    }
-  });
-
-  return statementVerifiedAgainstCombinators;
-}
+function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsEquality = false;
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
-  let statementVerifiedAgainstCombinator;
+  const equalityNode = equalityNodeQuery(statementNode);
 
-  const statementString = context.nodeAsString(statementNode),
-        combinatorString = combinator.getString();
+  if (equalityNode !== null) {
+    const statementString = context.nodeAsString(statementNode);
 
-  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-  const combinatorStatementNode = combinator.getStatementNode(),
-        nonTerminalNodeA = statementNode, ///
-        nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
 
-  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+    statementVerifiedAsEquality = equalityVerified; ///
 
-  if (statementVerifiedAgainstCombinator) {
-    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+    if (statementVerifiedAsEquality) {
+      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
+    }
   }
 
-  return statementVerifiedAgainstCombinator;
+  return statementVerifiedAsEquality;
 }
 
 function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context, verifyAhead) {
@@ -109,24 +88,45 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAsEquality = false;
+function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAgainstCombinators;
 
-  const equalityNode = equalityNodeQuery(statementNode);
+  let combinators = context.getCombinators();
 
-  if (equalityNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+  combinators = [ ///
+    bracketedCombinator,
+    ...combinators
+  ];
 
-    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+  statementVerifiedAgainstCombinators = combinators.some((combinator) => {
+    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+    if (statementVerifiedAgainstCombinator) {
+      return true;
+    }
+  });
 
-    statementVerifiedAsEquality = equalityVerified; ///
+  return statementVerifiedAgainstCombinators;
+}
 
-    if (statementVerifiedAsEquality) {
-      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
-    }
+function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
+  let statementVerifiedAgainstCombinator;
+
+  const statementString = context.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+
+  const combinatorStatementNode = combinator.getStatementNode(),
+        nonTerminalNodeA = statementNode, ///
+        nonTerminalNodeB = combinatorStatementNode, ///
+        nonTerminalNodeVerified = statementNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+
+  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+
+  if (statementVerifiedAgainstCombinator) {
+    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementVerifiedAsEquality;
+  return statementVerifiedAgainstCombinator;
 }

package/src/verify/supposition.js

@@ -9,30 +9,37 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
-export default function verifySupposition(suppositionNode, suppositions, assignments, localContext) {
-  let suppositionVerified;
+export default function verifySupposition(suppositionNode, suppositions, localContext) {
+  let suppositionVerified = false;
 
   const suppositionString = localContext.nodeAsString(suppositionNode);
 
   localContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
+        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
   if (unqualifiedStatementVerified) {
+    suppositionVerified = assignments.every((assignment) => {  ///
+      const assigned = assignment.assign(localContext);
+
+      if (assigned) {
+        return true;
+      }
+    });
+  }
+
+  if (suppositionVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
-          proofStep = ProofStep.fromStatementNode(statementNode),
-          supposition = Supposition.fromStatementNode(statementNode);
+          supposition = Supposition.fromStatementNode(statementNode),
+          proofStep = ProofStep.fromStatementNode(statementNode);
 
     suppositions.push(supposition);
 
     localContext.addProofStep(proofStep);
 
-    suppositionVerified = true;
-  }
-
-  if (suppositionVerified) {
     localContext.debug(`...verified the '${suppositionString}' supposition.`, suppositionNode);
   }
 

package/src/verify/suppositions.js

@@ -5,25 +5,13 @@ import verifySupposition from "../verify/supposition";
 export default function verifySuppositions(suppositionNodes, suppositions, localContext) {
   let suppositionsVerified;
 
-  const assignments = [];
-
   suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-    const suppositionVerified = verifySupposition(suppositionNode, suppositions, assignments, localContext);
+    const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
     if (suppositionVerified) {
       return true;
     }
   });
 
-  if (suppositionsVerified) {
-    suppositionsVerified = assignments.every((assignment) => {  ///
-      const assigned = assignment.assign(localContext);
-
-      if (assigned) {
-        return true;
-      }
-    });
-  }
-
   return suppositionsVerified;
 }

package/src/verify/term.js

@@ -2,11 +2,9 @@
 
 import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
+import verifyTermAsGivenVariable from "../verify/termAsGivenVariable";
 
 import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
 
 function verifyTerm(termNode, terms, context, verifyAhead) {
   let termVerified;
@@ -16,7 +14,7 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   context.trace(`Verifying the '${termString}' term...`, termNode);
 
   const verifyTermFunctions = [
-    verifyTermAsStandaloneVariable,
+    verifyTermAsVariable,
     verifyTermAgainstConstructors
   ];
 
@@ -41,65 +39,15 @@ Object.assign(termNodesVerifier, {
 
 export default verifyTerm;
 
-export function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
-  let termVerifiedAgainstConstructors;
-
-  const constructors = context.getConstructors();
-
-  termVerifiedAgainstConstructors = constructors.some((constructor) => {
-    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
-
-    if (termVerifiedAgainstConstructor) {
-      return true;
-    }
-  });
-
-  return termVerifiedAgainstConstructors;
-}
-
-export function verifyTermAsVariable(termNode, variables, context, verifyAhead) {
-  let termVerifiedAsVariable = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const termString = context.nodeAsString(termNode);
-
-    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
-
-    const variable = context.findVariableByVariableNode(variableNode);
-
-    if (variable !== null) {
-      let verifiedAhead;
-
-      variables.push(variable);
-
-      verifiedAhead = verifyAhead();
-
-      if (!verifiedAhead) {
-        variables.pop();
-      }
-
-      termVerifiedAsVariable = verifiedAhead; ///
-    }
-
-    if (termVerifiedAsVariable) {
-      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
-    }
-  }
-
-  return termVerifiedAsVariable;
-}
-
-function verifyTermAsStandaloneVariable(termNode, terms, context, verifyAhead) {
-  let termVerifiedAsStandaloneVariable;
+function verifyTermAsVariable(termNode, terms, context, verifyAhead) {
+  let termVerifiedAsVariable;
 
   const termString = context.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
+  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
   const variables = [],
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+        termVerifiedAsGivenVariable = verifyTermAsGivenVariable(termNode, variables, context, () => {
           let verifiedAhead;
 
           const firstVariable = first(variables),
@@ -118,13 +66,29 @@ function verifyTermAsStandaloneVariable(termNode, terms, context, verifyAhead) {
           return verifiedAhead;
         });
 
-  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
+  termVerifiedAsVariable = termVerifiedAsGivenVariable;  ///
 
-  if (termVerifiedAsStandaloneVariable) {
-    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
+  if (termVerifiedAsVariable) {
+    context.debug(`...verified the '${termString}' term as a variable.`, termNode);
   }
 
-  return termVerifiedAsStandaloneVariable;
+  return termVerifiedAsVariable;
+}
+
+function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
+  let termVerifiedAgainstConstructors;
+
+  const constructors = context.getConstructors();
+
+  termVerifiedAgainstConstructors = constructors.some((constructor) => {
+    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+
+    if (termVerifiedAgainstConstructor) {
+      return true;
+    }
+  });
+
+  return termVerifiedAgainstConstructors;
 }
 
 function verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead) {

package/src/verify/termAndGivenType.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+import verifyGivenType from "../verify/givenType";
+
+export default function verifyTermAndGivenType(termNode, typeNode, terms, types, context, verifyAhead) {
+  let termAndGivenTypeVerified;
+
+  const termString = context.nodeAsString(termNode),
+        typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the '${termString}' term and the given '${typeString}' type...`, termNode);
+
+  const termVerified = verifyTerm(termNode, terms, context, () => {
+          let verifiedAhead;
+
+          const givenTypeVerified = verifyGivenType(typeNode, types, context, () => {
+            let verifiedAhead;
+
+            verifiedAhead = verifyAhead();
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = givenTypeVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  termAndGivenTypeVerified = termVerified; ///
+
+  if (termAndGivenTypeVerified) {
+    context.debug(`...verified the '${termString}' term and the given '${typeString}' type.`, termNode);
+  }
+
+  return termAndGivenTypeVerified
+}

package/src/verify/termAsGivenVariable.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+export default function verifyTermAsGivenVariable(termNode, variables, context, verifyAhead) {
+  let termVerifiedAsVariable = false;
+
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    const termString = context.nodeAsString(termNode);
+
+    context.trace(`Verifying the '${termString}' term as a given variable...`, termNode);
+
+    const variable = context.findVariableByVariableNode(variableNode);
+
+    if (variable !== null) {
+      let verifiedAhead;
+
+      variables.push(variable);
+
+      verifiedAhead = verifyAhead();
+
+      if (!verifiedAhead) {
+        variables.pop();
+      }
+
+      termVerifiedAsVariable = verifiedAhead; ///
+    }
+
+    if (termVerifiedAsVariable) {
+      context.debug(`...verified the '${termString}' term as a given variable.`, termNode);
+    }
+  }
+
+  return termVerifiedAsVariable;
+}

package/src/verify/typeAssertion.js

@@ -2,14 +2,15 @@
 
 import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
-import verifyTermAndStandaloneType from "../verify/termAndStandaloneType";
-import verifyTermAsVariableAndStandaloneType from "../verify/termAsVariableAndStandaloneType";
+import verifyTermAndGivenType from "../verify/termAndGivenType";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
+import { verifyTermAsGivenVariable } from "./term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type!");
+      typeNodeQuery = nodeQuery("/typeAssertion/type!"),
+      variableNodeQuery = nodeQuery("/term/variable!");
 
 export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
   let typeAssertionVerified;
@@ -50,28 +51,43 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, con
           types = [],
           termNode = termNodeQuery(typeAssertionNode),
           typeNode = typeNodeQuery(typeAssertionNode),
-          termAndStandaloneTypeVerified = verifyTermAndStandaloneType(termNode, typeNode, terms, types, context, () => {
+          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, context, () => {
             let verifiedAhead = false;
 
             const firstTerm = first(terms),
                   firstType = first(types),
                   term = firstTerm, ///
                   type = firstType, ///
-                  termType = term.getType(),
-                  termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);
+                  termType = context.getTermType(term),
+                  typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
 
-            if (termTypeEqualToOrSuperTypeOfType) {
-              debugger
+            if (typeEqualToOrSuperTypeOfTermType) {
+              const variableNode = variableNodeQuery(termNode);
 
-              if (false) {  ///
+              if (variableNode === null) {
                 verifiedAhead = verifyAhead();
+              } else {
+                let variable = context.findVariableByVariableNode(variableNode);
+
+                variable = Variable.fromVariableAndType(variable, type);
+
+                const variableAssignment = VariableAssignment.fromVariable(variable),
+                      assignment = variableAssignment;  ///
+
+                assignments.push(assignment);
+
+                verifiedAhead = verifyAhead();
+
+                if (!verifiedAhead) {
+                  assignments.pop();
+                }
               }
             }
 
             return verifiedAhead;
           });
 
-    derivedTypeAssertionVerified = termAndStandaloneTypeVerified; ///
+    derivedTypeAssertionVerified = termAndGivenTypeVerified; ///
 
     if (derivedTypeAssertionVerified) {
       context.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
@@ -89,41 +105,47 @@ function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, conte
 
     context.trace(`Verifying the '${typeAssertionString}' given type assertion...`, typeAssertionNode);
 
-    const types = [],
-          variables = [],
+    const terms = [],
+          types = [],
           termNode = termNodeQuery(typeAssertionNode),
           typeNode = typeNodeQuery(typeAssertionNode),
-          termAsVariableAndStandaloneTypeVerified = verifyTermAsVariableAndStandaloneType(termNode, typeNode, variables, types, context, () => {
+          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, context, () => {
             let verifiedAhead = false;
 
-            const firstVariable = first(variables);
+            const firstTerm = first(terms),
+                  firstType = first(types),
+                  term = firstTerm, ///
+                  type = firstType, ///
+                  termType = term.getType(),
+                  typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
 
-            let variable = firstVariable; ///
+            if (typeEqualToOrSubTypeOfTermType) {
+              const variableNode = variableNodeQuery(termNode);
 
-            const firstType = first(types),
-                  type = firstType, ///
-                  variableType = variable.getType(),
-                  variableTypeEqualToOrSuperTypeOfType = variableType.isEqualToOrSuperTypeOf(type);
+              if (variableNode === null) {
+                verifiedAhead = verifyAhead();
+              } else {
+                let variable = context.findVariableByVariableNode(variableNode);
 
-            if (variableTypeEqualToOrSuperTypeOfType) {
-              variable = Variable.fromVariableAndType(variable, type);  ///
+                variable = Variable.fromVariableAndType(variable, type);
 
-              const variableAssignment = VariableAssignment.fromVariable(variable),
-                    assignment = variableAssignment; ///
+                const variableAssignment = VariableAssignment.fromVariable(variable),
+                      assignment = variableAssignment;  ///
 
-              assignments.push(assignment);
+                assignments.push(assignment);
 
-              verifiedAhead = verifyAhead();
+                verifiedAhead = verifyAhead();
 
-              if (!verifiedAhead) {
-                assignments.pop();
+                if (!verifiedAhead) {
+                  assignments.pop();
+                }
               }
             }
 
             return verifiedAhead;
           });
 
-    givenTypeAssertionVerified = termAsVariableAndStandaloneTypeVerified; ///
+    givenTypeAssertionVerified = termAndGivenTypeVerified; ///
 
     if (givenTypeAssertionVerified) {
       context.trace(`...verified the '${typeAssertionString}' given type assertion.`, typeAssertionNode);

package/lib/verifier/nodes/metastatementForMetavariable/conclusion.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _metastatementForMetavariable = /*#__PURE__*/ _interop_require_default(require("../../../verifier/nodes/metastatementForMetavariable"));
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _is_native_reflect_construct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _create_super(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct();
-    return function _createSuperInternal() {
-        var Super = _get_prototype_of(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possible_constructor_return(this, result);
-    };
-}
-var ConclusionMetastatementForMetavariableNodesVerifier = /*#__PURE__*/ function(MetastatementForMetavariableNodesVerifier) {
-    _inherits(ConclusionMetastatementForMetavariableNodesVerifier, MetastatementForMetavariableNodesVerifier);
-    var _super = _create_super(ConclusionMetastatementForMetavariableNodesVerifier);
-    function ConclusionMetastatementForMetavariableNodesVerifier() {
-        _class_call_check(this, ConclusionMetastatementForMetavariableNodesVerifier);
-        return _super.apply(this, arguments);
-    }
-    return ConclusionMetastatementForMetavariableNodesVerifier;
-}(_metastatementForMetavariable.default);
-_define_property(ConclusionMetastatementForMetavariableNodesVerifier, "createSubstitutions", false);
-var conclusionMetastatementForMetavariableNodesVerifier = new ConclusionMetastatementForMetavariableNodesVerifier();
-var _default = conclusionMetastatementForMetavariableNodesVerifier;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy92ZXJpZmllci9ub2Rlcy9tZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlL2NvbmNsdXNpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBNZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlTm9kZXNWZXJpZmllciBmcm9tIFwiLi4vLi4vLi4vdmVyaWZpZXIvbm9kZXMvbWV0YXN0YXRlbWVudEZvck1ldGF2YXJpYWJsZVwiO1xuXG5jbGFzcyBDb25jbHVzaW9uTWV0YXN0YXRlbWVudEZvck1ldGF2YXJpYWJsZU5vZGVzVmVyaWZpZXIgZXh0ZW5kcyBNZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlTm9kZXNWZXJpZmllciB7XG4gIHN0YXRpYyBjcmVhdGVTdWJzdGl0dXRpb25zID0gZmFsc2U7XG59XG5cbmNvbnN0IGNvbmNsdXNpb25NZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlTm9kZXNWZXJpZmllciA9IG5ldyBDb25jbHVzaW9uTWV0YXN0YXRlbWVudEZvck1ldGF2YXJpYWJsZU5vZGVzVmVyaWZpZXIoKTtcblxuZXhwb3J0IGRlZmF1bHQgY29uY2x1c2lvbk1ldGFzdGF0ZW1lbnRGb3JNZXRhdmFyaWFibGVOb2Rlc1ZlcmlmaWVyO1xuIl0sIm5hbWVzIjpbIkNvbmNsdXNpb25NZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlTm9kZXNWZXJpZmllciIsIk1ldGFzdGF0ZW1lbnRGb3JNZXRhdmFyaWFibGVOb2Rlc1ZlcmlmaWVyIiwiY3JlYXRlU3Vic3RpdHV0aW9ucyIsImNvbmNsdXNpb25NZXRhc3RhdGVtZW50Rm9yTWV0YXZhcmlhYmxlTm9kZXNWZXJpZmllciJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBVUE7OztlQUFBOzs7bUZBUnNEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFdEQsSUFBQSxBQUFNQSxvRUFBRCxBQUFMO2NBQU1BOytCQUFBQTthQUFBQTtnQ0FBQUE7OztXQUFBQTtFQUE0REMscUNBQXlDO0FBQ3pHLGlCQURJRCxxREFDR0UsdUJBQXNCO0FBRy9CLElBQU1DLHNEQUFzRCxJQUFJSDtJQUVoRSxXQUFlRyJ9