occam-verify-cli 0.0.916 → 0.0.918

package/src/verify/statement.js

@@ -3,16 +3,16 @@
 import verifyEquality from "../verify/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/typeAssertion";
-import verifyDefinedAssertion from "../verify/definedAssertion";
-import verifyContainedAssertion from "../verify/containedAssertion";
+import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAssertion";
+import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
-import { nodeQuery } from "../utilities/query";
+import { DEFINED, CONTAINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -77,23 +77,24 @@ export default verifyStatement;
 export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
-  const equalityNode = equalityNodeQuery(statementNode);
+  const statementEquality = isStatementEquality(statementNode);
 
-  if (equalityNode !== null) {
+  if (statementEquality) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, equalityNode);
+    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
+    const equalityNode = equalityNodeQuery(statementNode),
+          equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-      return verifiedAhead;
-    });
+            return verifiedAhead;
+          });
 
     statementVerifiedAsEquality = equalityVerified; ///
 
     if (statementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' statement as an equality.`, equalityNode);
+      localContext.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
     }
   }
 
@@ -103,82 +104,39 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const statementTypeAssertion = isStatementTypeAssertion(statementNode);
 
-  if (typeAssertionNode !== null) {
+  if (statementTypeAssertion) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, typeAssertionNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
+    const typeAssertionNode = typeAssertionNodeQuery(statementNode),
+          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-      return verifiedAhead;
-    });
+            return verifiedAhead;
+          });
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
     if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, typeAssertionNode);
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
     }
   }
 
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsDefinedAssertion = false;
-
-  const definedAssertionNode = definedAssertionNodeQuery(statementNode);
-
-  if (definedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, definedAssertionNode);
-
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
-
-    if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, definedAssertionNode);
-    }
-  }
-
-  return statementVerifiedAsDefinedAssertion;
-}
-
-function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsContainedAssertion = false;
-
-  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
-
-  if (containedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, containedAssertionNode);
-
-    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
-
-    if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, containedAssertionNode);
-    }
-  }
-
-  return statementVerifiedAsContainedAssertion;
-}
-
 function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
   let statementVerifiedAgainstCombinators = false;
 
-  const equalityNode = equalityNodeQuery(statementNode),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        definedAssertionNode = definedAssertionNodeQuery(statementNode),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+  const statementEquality = isStatementEquality(statementNode),
+        statementTypeAssertion = isStatementTypeAssertion(statementNode),
+        statementDefinedAssertion = isStatementDefinedAssertion(statementNode),
+        statementContainedAssertion = isStatementContainedAssertion(statementNode);
 
-  if ((equalityNode === null) && (typeAssertionNode === null) && (definedAssertionNode === null) && (containedAssertionNode === null)) {
+  if (!statementEquality && !statementTypeAssertion && !statementDefinedAssertion && !statementContainedAssertion) {
     let combinators = localContext.getCombinators();
 
     combinators = [ ///
@@ -223,3 +181,45 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
 
   return statementVerifiedAgainstCombinator;
 }
+
+function isStatementEquality(statementNode) {
+  const equalityNode = equalityNodeQuery(statementNode),
+        statementEquality = (equalityNode !== null);
+
+  return statementEquality;
+}
+
+function isStatementTypeAssertion(statementNode) {
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        statementTypeAssertion = (typeAssertionNode === null);
+
+  return statementTypeAssertion;
+}
+
+function isStatementDefinedAssertion(statementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
+        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentDefined = (content === DEFINED);
+
+          if (contentDefined) {
+            return true;
+          }
+        });
+
+  return statementDefinedAssertion;
+}
+
+function isStatementContainedAssertion(statementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
+        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentContained = (content === CONTAINED);
+
+          if (contentContained) {
+            return true;
+          }
+        });
+
+  return statementContainedAssertion;
+}

package/src/verify/statementAsContainedAssertion.js

@@ -0,0 +1,112 @@
+"use strict";
+
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { isAssertionNegated } from "../utilities/verify";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/statement/term/variable!"),
+      metastatementVariableNodesQuery = nodesQuery("/statement/statement//variable");
+
+export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
+
+  const statementFunctions = [
+    verifyStatementAsDerivedContainedAssertion,
+    verifyStatementAsStatedContainedAssertion
+  ];
+
+  statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
+    const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+
+    if (statementVerifiedAsContainedAssertion) {
+      return true;
+    }
+  });
+
+  if (statementVerifiedAsContainedAssertion) {
+    localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
+function verifyStatementAsDerivedContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedContainedAssertion = false;
+
+  if (derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
+
+    const statementNegated = isAssertionNegated(statementNode),
+          variableNode = variableNodeQuery(statementNode),
+          negated = statementNegated;  ///
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const metastatementVariableNodes = metastatementVariableNodesQuery(statementNode),
+            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
+              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
+
+              if (variableNodeMatchesMetaArgumentVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesMetaArgumentVariableNode) {
+          statementVerifiedAsDefinedContainedAssertion = true;
+        }
+      }
+
+      if (negated) {
+        if (!variableNodeMatchesMetaArgumentVariableNode) {
+          statementVerifiedAsDefinedContainedAssertion = true;
+        }
+      }
+    }
+
+    if (statementVerifiedAsDefinedContainedAssertion) {
+      localContext.debug(`...verified the derived '${statementString}' statement as a contained assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedContainedAssertion;
+}
+
+function verifyStatementAsStatedContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsStatedContainedAssertion = false;
+
+  if (!derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the stated '${statementString}' statement as a contained assertion...`, statementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${statementString}' statement as a contained assertion cannot be verified at intrinsic level.`, statementNode);
+    } else {
+      const nonTerminalNode = statementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statementVerifiedAsStatedContainedAssertion) {
+      localContext.debug(`...verified the stated '${statementString}' statement as a contained assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsStatedContainedAssertion;
+}

package/src/verify/statementAsDefinedAssertion.js

@@ -0,0 +1,136 @@
+"use strict";
+
+import verifyTerm from "./term";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+import { isStatementNegated } from "../utilities/verify";
+
+const termNodeQuery = nodeQuery("/statement/term!"),
+      variableNodeQuery = nodeQuery("/statement/term/variable!");
+
+export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedAssertion;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+  const definedAssertionFunctions = [
+    verifyDerivedStatementAsDefinedAssertion,
+    verifyStatedStatementAsDefinedAssertion
+  ];
+
+  statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
+    const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+
+    if (statementVerifiedAsDefinedAssertion) {
+      return true;
+    }
+  });
+
+  if (statementVerifiedAsDefinedAssertion) {
+    localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+  }
+
+  return statementVerifiedAsDefinedAssertion;
+}
+
+function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsDefeindAssertion = false;
+
+  if (derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const statementNegated = isStatementNegated(statementNode),
+          variableNode = variableNodeQuery(statementNode),
+          termNode = termNodeQuery(statementNode);
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!statementNegated) {
+          if (variableDefined) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (statementNegated) {
+          if (!variableDefined) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    } else if (termNode !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      if (termVerified) {
+        const firstTerm = first(terms),
+              term = firstTerm, ///
+              termGrounded = localContext.isTermGrounded(term);
+
+        if (!statementNegated) {
+          if (termGrounded) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (statementNegated) {
+          if (!termGrounded) {
+            derivedStatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    }
+
+    if (derivedStatementVerifiedAsDefeindAssertion) {
+      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsDefeindAssertion;
+}
+
+function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsDefinedAssertion = false;
+
+  if (!derived) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);
+    } else {
+      const nonTerminalNode = statementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statedStatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsDefinedAssertion;
+}

package/lib/verify/containedAssertion.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyContainedAssertion;
-    }
-});
-var _metaLevel = /*#__PURE__*/ _interop_require_default(require("../verifier/node/metaLevel"));
-var _verify = require("../utilities/verify");
-var _query = require("../utilities/query");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var variableNodeQuery = (0, _query.nodeQuery)("/containedAssertion/term/variable!"), metastatementVariableNodesQuery = (0, _query.nodesQuery)("/containedAssertion/statement//variable");
-function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
-    var containedAssertionVerified;
-    var containedAssertionString = localContext.nodeAsString(containedAssertionNode);
-    localContext.trace("Verifying the '".concat(containedAssertionString, "' contained assertion..."), containedAssertionNode);
-    var containedAssertionFunctions = [
-        verifyDerivedContainedAssertion,
-        verifyStatedContainedAssertion
-    ];
-    containedAssertionVerified = containedAssertionFunctions.some(function(containedAssertionFunction) {
-        var containedAssertionVerified = containedAssertionFunction(containedAssertionNode, assignments, derived, localContext);
-        if (containedAssertionVerified) {
-            return true;
-        }
-    });
-    if (containedAssertionVerified) {
-        localContext.debug("...verified the '".concat(containedAssertionString, "' contained assertion."), containedAssertionNode);
-    }
-    return containedAssertionVerified;
-}
-function verifyDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
-    var derivedContainedAssertionVerified = false;
-    if (derived) {
-        var containedAssertionString = localContext.nodeAsString(containedAssertionNode);
-        localContext.trace("Verifying the derived '".concat(containedAssertionString, "' contained assertion..."), containedAssertionNode);
-        var containedAssertionNegated = (0, _verify.isAssertionNegated)(containedAssertionNode), variableNode = variableNodeQuery(containedAssertionNode), negated = containedAssertionNegated; ///
-        if (false) {
-        ///
-        } else if (variableNode !== null) {
-            var metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode), variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some(function(metastatementVariableNode) {
-                var variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
-                if (variableNodeMatchesMetaArgumentVariableNode) {
-                    return true;
-                }
-            });
-            if (!negated) {
-                if (variableNodeMatchesMetaArgumentVariableNode) {
-                    derivedContainedAssertionVerified = true;
-                }
-            }
-            if (negated) {
-                if (!variableNodeMatchesMetaArgumentVariableNode) {
-                    derivedContainedAssertionVerified = true;
-                }
-            }
-        }
-        if (derivedContainedAssertionVerified) {
-            localContext.debug("...verified the derived '".concat(containedAssertionString, "' contained assertion."), containedAssertionNode);
-        }
-    }
-    return derivedContainedAssertionVerified;
-}
-function verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
-    var statedContainedAssertionVerified = false;
-    if (!derived) {
-        var containedAssertionString = localContext.nodeAsString(containedAssertionNode);
-        localContext.trace("Verifying the stated '".concat(containedAssertionString, "' contained assertion..."), containedAssertionNode);
-        var intrinsicLevel = localContext.isIntrinsicLevel();
-        if (intrinsicLevel) {
-            localContext.debug("The stated '".concat(containedAssertionString, "' contained assertion cannot be verified at intrinsic level."), containedAssertionNode);
-        } else {
-            var nonTerminalNode = containedAssertionNode, nonTerminalNodeVerified = _metaLevel.default.verifyNonTerminalNode(nonTerminalNode, localContext, function() {
-                var verifiedAhead = true;
-                return verifiedAhead;
-            });
-            statedContainedAssertionVerified = nonTerminalNodeVerified; ///
-        }
-        if (statedContainedAssertionVerified) {
-            localContext.debug("...verified the stated '".concat(containedAssertionString, "' contained assertion."), containedAssertionNode);
-        }
-    }
-    return statedContainedAssertionVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/containedAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport metaLevelNodeVerifier from \"../verifier/node/metaLevel\";\n\nimport { isAssertionNegated } from \"../utilities/verify\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst variableNodeQuery = nodeQuery(\"/containedAssertion/term/variable!\"),\n      metastatementVariableNodesQuery = nodesQuery(\"/containedAssertion/statement//variable\");\n\nexport default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {\n  let containedAssertionVerified;\n\n  const containedAssertionString = localContext.nodeAsString(containedAssertionNode);\n\n  localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);\n\n  const containedAssertionFunctions = [\n    verifyDerivedContainedAssertion,\n    verifyStatedContainedAssertion\n  ];\n\n  containedAssertionVerified = containedAssertionFunctions.some((containedAssertionFunction) => {\n    const containedAssertionVerified = containedAssertionFunction(containedAssertionNode, assignments, derived, localContext);\n\n    if (containedAssertionVerified) {\n      return true;\n    }\n  });\n\n  if (containedAssertionVerified) {\n    localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`, containedAssertionNode);\n  }\n\n  return containedAssertionVerified;\n}\n\nfunction verifyDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {\n  let derivedContainedAssertionVerified = false;\n\n  if (derived) {\n    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);\n\n    localContext.trace(`Verifying the derived '${containedAssertionString}' contained assertion...`, containedAssertionNode);\n\n    const containedAssertionNegated = isAssertionNegated(containedAssertionNode),\n          variableNode = variableNodeQuery(containedAssertionNode),\n          negated = containedAssertionNegated;  ///\n\n    if (false) {\n      ///\n    } else if (variableNode !== null) {\n      const metastatementVariableNodes = metastatementVariableNodesQuery(containedAssertionNode),\n            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {\n              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);\n\n              if (variableNodeMatchesMetaArgumentVariableNode) {\n                return true;\n              }\n            });\n\n      if (!negated) {\n        if (variableNodeMatchesMetaArgumentVariableNode) {\n          derivedContainedAssertionVerified = true;\n        }\n      }\n\n      if (negated) {\n        if (!variableNodeMatchesMetaArgumentVariableNode) {\n          derivedContainedAssertionVerified = true;\n        }\n      }\n    }\n\n    if (derivedContainedAssertionVerified) {\n      localContext.debug(`...verified the derived '${containedAssertionString}' contained assertion.`, containedAssertionNode);\n    }\n  }\n\n  return derivedContainedAssertionVerified;\n}\n\nfunction verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {\n  let statedContainedAssertionVerified = false;\n\n  if (!derived) {\n    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);\n\n    localContext.trace(`Verifying the stated '${containedAssertionString}' contained assertion...`, containedAssertionNode);\n\n    const intrinsicLevel = localContext.isIntrinsicLevel();\n\n    if (intrinsicLevel) {\n      localContext.debug(`The stated '${containedAssertionString}' contained assertion cannot be verified at intrinsic level.`, containedAssertionNode);\n    } else {\n      const nonTerminalNode = containedAssertionNode, ///\n            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      statedContainedAssertionVerified = nonTerminalNodeVerified; ///\n    }\n\n    if (statedContainedAssertionVerified) {\n      localContext.debug(`...verified the stated '${containedAssertionString}' contained assertion.`, containedAssertionNode);\n    }\n  }\n\n  return statedContainedAssertionVerified;\n}\n"],"names":["verifyContainedAssertion","variableNodeQuery","nodeQuery","metastatementVariableNodesQuery","nodesQuery","containedAssertionNode","assignments","derived","localContext","containedAssertionVerified","containedAssertionString","nodeAsString","trace","containedAssertionFunctions","verifyDerivedContainedAssertion","verifyStatedContainedAssertion","some","containedAssertionFunction","debug","derivedContainedAssertionVerified","containedAssertionNegated","isAssertionNegated","variableNode","negated","metastatementVariableNodes","variableNodeMatchesMetaArgumentVariableNode","metastatementVariableNode","match","statedContainedAssertionVerified","intrinsicLevel","isIntrinsicLevel","nonTerminalNode","nonTerminalNodeVerified","metaLevelNodeVerifier","verifyNonTerminalNode","verifiedAhead"],"mappings":"AAAA;;;;+BAUA;;;eAAwBA;;;gEARU;sBAEC;qBACG;;;;;;AAEtC,IAAMC,oBAAoBC,IAAAA,gBAAS,EAAC,uCAC9BC,kCAAkCC,IAAAA,iBAAU,EAAC;AAEpC,SAASJ,yBAAyBK,sBAAsB,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACzG,IAAIC;IAEJ,IAAMC,2BAA2BF,aAAaG,YAAY,CAACN;IAE3DG,aAAaI,KAAK,CAAC,AAAC,kBAA0C,OAAzBF,0BAAyB,6BAA2BL;IAEzF,IAAMQ,8BAA8B;QAClCC;QACAC;KACD;IAEDN,6BAA6BI,4BAA4BG,IAAI,CAAC,SAACC;QAC7D,IAAMR,6BAA6BQ,2BAA2BZ,wBAAwBC,aAAaC,SAASC;QAE5G,IAAIC,4BAA4B;YAC9B,OAAO;QACT;IACF;IAEA,IAAIA,4BAA4B;QAC9BD,aAAaU,KAAK,CAAC,AAAC,oBAA4C,OAAzBR,0BAAyB,2BAAyBL;IAC3F;IAEA,OAAOI;AACT;AAEA,SAASK,gCAAgCT,sBAAsB,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACjG,IAAIW,oCAAoC;IAExC,IAAIZ,SAAS;QACX,IAAMG,2BAA2BF,aAAaG,YAAY,CAACN;QAE3DG,aAAaI,KAAK,CAAC,AAAC,0BAAkD,OAAzBF,0BAAyB,6BAA2BL;QAEjG,IAAMe,4BAA4BC,IAAAA,0BAAkB,EAAChB,yBAC/CiB,eAAerB,kBAAkBI,yBACjCkB,UAAUH,2BAA4B,GAAG;QAE/C,IAAI,OAAO;QACT,GAAG;QACL,OAAO,IAAIE,iBAAiB,MAAM;YAChC,IAAME,6BAA6BrB,gCAAgCE,yBAC7DoB,8CAA8CD,2BAA2BR,IAAI,CAAC,SAACU;gBAC7E,IAAMD,8CAA8CH,aAAaK,KAAK,CAACD;gBAEvE,IAAID,6CAA6C;oBAC/C,OAAO;gBACT;YACF;YAEN,IAAI,CAACF,SAAS;gBACZ,IAAIE,6CAA6C;oBAC/CN,oCAAoC;gBACtC;YACF;YAEA,IAAII,SAAS;gBACX,IAAI,CAACE,6CAA6C;oBAChDN,oCAAoC;gBACtC;YACF;QACF;QAEA,IAAIA,mCAAmC;YACrCX,aAAaU,KAAK,CAAC,AAAC,4BAAoD,OAAzBR,0BAAyB,2BAAyBL;QACnG;IACF;IAEA,OAAOc;AACT;AAEA,SAASJ,+BAA+BV,sBAAsB,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IAChG,IAAIoB,mCAAmC;IAEvC,IAAI,CAACrB,SAAS;QACZ,IAAMG,2BAA2BF,aAAaG,YAAY,CAACN;QAE3DG,aAAaI,KAAK,CAAC,AAAC,yBAAiD,OAAzBF,0BAAyB,6BAA2BL;QAEhG,IAAMwB,iBAAiBrB,aAAasB,gBAAgB;QAEpD,IAAID,gBAAgB;YAClBrB,aAAaU,KAAK,CAAC,AAAC,eAAuC,OAAzBR,0BAAyB,iEAA+DL;QAC5H,OAAO;YACL,IAAM0B,kBAAkB1B,wBAClB2B,0BAA0BC,kBAAqB,CAACC,qBAAqB,CAACH,iBAAiBvB,cAAc;gBACnG,IAAM2B,gBAAgB;gBAEtB,OAAOA;YACT;YAENP,mCAAmCI,yBAAyB,GAAG;QACjE;QAEA,IAAIJ,kCAAkC;YACpCpB,aAAaU,KAAK,CAAC,AAAC,2BAAmD,OAAzBR,0BAAyB,2BAAyBL;QAClG;IACF;IAEA,OAAOuB;AACT"}