occam-verify-cli 0.0.704 → 0.0.706

package/src/verifier/node.js

@@ -32,6 +32,28 @@ export default class NodeVerifier {
     return childNodesVerify;
   }
 
+  verifyTerminalNode(terminalNode, ...remainingArguments) {
+    let terminalNodeVerified;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          verifiedAhead = verifyAhead();  ///
+
+    terminalNodeVerified = verifiedAhead; ///
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
+    let nonTerminalNodeVerified;
+
+    const childNodes = nonTerminalNode.getChildNodes(), ///
+          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+
+    nonTerminalNodeVerified = childNodesVerify; ///
+
+    return nonTerminalNodeVerified;
+  }
+
   verifyChildNodesAhead(index, childNodes, ...remainingArguments) {
     let childNodesVerify;
 
@@ -46,11 +68,10 @@ export default class NodeVerifier {
       const childNode = childNodes[index],
             node = childNode, ///
             nodeVerified = this.verifyNode(node, ...remainingArguments, () => {
-              index++;
-
               remainingArguments.push(verifyAhead);
 
-              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+              const aheadIndex = index + 1,
+                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodes, ...remainingArguments);
 
               return childNodesVerifyAhead;
             });
@@ -60,26 +81,4 @@ export default class NodeVerifier {
 
     return childNodesVerify;
   }
-
-  verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerified;
-
-    const verifyAhead = remainingArguments.pop(), ///
-          verifiedAhead = verifyAhead();  ///
-
-    terminalNodeVerified = verifiedAhead; ///
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeVerified;
-
-    const childNodes = nonTerminalNode.getChildNodes(), ///
-          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
-
-    nonTerminalNodeVerified = childNodesVerify; ///
-
-    return nonTerminalNodeVerified;
-  }
 }

package/src/verifier/nodes/statement.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
+import termNodesVerifier from "../../verifier/nodes/term";
 
 import { nodeQuery } from "../../utilities/query";
-import { verifyArgument } from "../../verifier/nodes/term";
 import { STATEMENT_META_TYPE } from "../../metaTypes";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
@@ -26,9 +26,9 @@ class StatementNodesVerifier extends NodesVerifier {
         case ARGUMENT_RULE_NAME: {
           const argumentNode = nonTerminalNode, ///
                 constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentVerified = verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead);
+                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
 
-          nonTerminalNodeVerified = argumentVerified; ///
+          nonTerminalNodeVerified = argumentNodeVerified; ///
 
           break;
         }
@@ -36,8 +36,7 @@ class StatementNodesVerifier extends NodesVerifier {
         case META_ARGUMENT_RULE_NAME: {
           const metaArgumentNode = nonTerminalNode, ///
                 combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-                metaArgumentVerified = verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead),
-                metaArgumentNodeVerified = metaArgumentVerified;  ///
+                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);
 
           nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -54,47 +53,41 @@ class StatementNodesVerifier extends NodesVerifier {
 
     return nonTerminalNodeVerified;
   }
-}
-
-const statementNodesVerifier = new StatementNodesVerifier();
-
-export default statementNodesVerifier;
-
-export function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
-  let metaArgumentVerified = false;
 
-  const metaArgumentString = context.nodeAsString(metaArgumentNode);
+  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+    let metaArgumentNodeVerified = false;
 
-  context.trace(`Verifying the '${metaArgumentString}' metaargument...`, metaArgumentNode);
+    const metaArgumentString = context.nodeAsString(metaArgumentNode);
 
-  const statementNode = statementNodeQuery(metaArgumentNode),
-        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+    const statementNode = statementNodeQuery(metaArgumentNode),
+          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
-  if (statementNode === null) {
-    context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-  } else {
-    if (combinatorMetaTYpeNode === null) {
-      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-
-      context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+    if (statementNode === null) {
+      context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
     } else {
-      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-            content = combinatorMetaTypeTerminalNode.getContent(),
-            contentStatementMetaType = (content === STATEMENT_META_TYPE);
+      if (combinatorMetaTYpeNode === null) {
+        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
-      if (!contentStatementMetaType) {
-        context.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
+        context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
       } else {
-        const verifiedAhead = verifyAhead();
+        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
+              content = combinatorMetaTypeTerminalNode.getContent(),
+              contentStatementMetaType = (content === STATEMENT_META_TYPE);
+
+        if (!contentStatementMetaType) {
+          context.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
+        } else {
+          const verifiedAhead = verifyAhead();
 
-        metaArgumentVerified = verifiedAhead; ///
+          metaArgumentNodeVerified = verifiedAhead; ///
+        }
       }
     }
-  }
 
-  if (metaArgumentVerified) {
-    context.debug(`...verified the '${metaArgumentString}' metaargument.`, metaArgumentNode);
+    return metaArgumentNodeVerified;
   }
-
-  return metaArgumentVerified;
 }
+
+const statementNodesVerifier = new StatementNodesVerifier();
+
+export default statementNodesVerifier;

package/src/verifier/nodes/term.js

@@ -21,8 +21,7 @@ class TermNodesVerifier extends NodesVerifier {
         case ARGUMENT_RULE_NAME: {
           const argumentNode = nonTerminalNode, ///
                 constructorArgumentNode = constructorNonTerminalNode, ///
-                argumentVerified = verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead),
-                argumentNodeVerified = argumentVerified;  ///
+                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
 
           nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -39,69 +38,64 @@ class TermNodesVerifier extends NodesVerifier {
 
     return nonTerminalNodeVerified;
   }
-}
-
-const termNodesVerifier = new TermNodesVerifier();
-
-export default termNodesVerifier;
-
-export function verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead) {
-  let argumentVerified = false;
 
-  const argumentString = context.nodeAsString(argumentNode);
+  verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead) {
+    let argumentNodeVerified = false;
 
-  context.trace(`Verifying the '${argumentString}' argument...`, argumentNode);
+    const argumentString = context.nodeAsString(argumentNode);
 
-  const typeNode = typeNodeQuery(argumentNode);
+    const typeNode = typeNodeQuery(argumentNode);
 
-  if (typeNode !== null) {
-    context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
-  } else {
-    const termNode = termNodeQuery(argumentNode);
+    if (typeNode !== null) {
+      context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
+    } else {
+      const termNode = termNodeQuery(argumentNode);
 
-    if (!argumentVerified) {
-      const constructorTermNode = termNodeQuery(constructorArgumentNode);
+      if (!argumentNodeVerified) {
+        const constructorTermNode = termNodeQuery(constructorArgumentNode);
 
-      if (constructorTermNode !== null) {
-        const node = termNode,  ///
-              constructorNode = constructorTermNode,  ///
-              nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
+        if (constructorTermNode !== null) {
+          const node = termNode,  ///
+                constructorNode = constructorTermNode,  ///
+                nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
 
-        argumentVerified = nodeVerified;  ///
+          argumentNodeVerified = nodeVerified;  ///
+        }
       }
-    }
 
-    if (!argumentVerified) {
-      const constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+      if (!argumentNodeVerified) {
+        const constructorTypeNode = typeNodeQuery(constructorArgumentNode);
 
-      if (constructorTypeNode !== null) {
-        const { verifyTerm } = termNodesVerifier,
-              terms = [],
-              termVerified = verifyTerm(termNode, terms, context, () => {
-                let verifiedAhead = false;
+        if (constructorTypeNode !== null) {
+          const { verifyTerm } = termNodesVerifier,
+                terms = [],
+                termVerified = verifyTerm(termNode, terms, context, () => {
+                  let verifiedAhead = false;
 
-                const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
-                      firstTerm = first(terms),
-                      term = firstTerm, ///
-                      termType = term.getType(),
-                      constructorType = context.findTypeByTypeName(constructorTypeName),
-                      termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+                  const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
+                        firstTerm = first(terms),
+                        term = firstTerm, ///
+                        termType = term.getType(),
+                        constructorType = context.findTypeByTypeName(constructorTypeName),
+                        termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 
-                if (termTypeEqualToOrSubTypeOfType) {
-                  verifiedAhead = verifyAhead();
-                }
+                  if (termTypeEqualToOrSubTypeOfType) {
+                    verifiedAhead = verifyAhead();
+                  }
 
-                return verifiedAhead;
-              });
+                  return verifiedAhead;
+                });
 
-        argumentVerified = termVerified;  ///
+          argumentNodeVerified = termVerified;  ///
+        }
       }
     }
-  }
 
-  if (argumentVerified) {
-    context.debug(`...verified the '${argumentString}' argument.`, argumentNode);
+    return argumentNodeVerified;
   }
-
-  return argumentVerified;
 }
+
+const termNodesVerifier = new TermNodesVerifier();
+
+export default termNodesVerifier;
+

package/src/verifier/nodes.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "../utilities/terminalNodes";
+
 export default class NodesVerifier {
   verifyNode(nodeA, nodeB, ...remainingArguments) {
     let nodeVerified = false;
@@ -35,15 +37,51 @@ export default class NodesVerifier {
           childNodesBLength = childNodesB.length;
 
     if (childNodesALength === childNodesBLength) {
-      const index = 0,
-            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+      const childTerminalNodeMapA = terminalNodeMapFromNodes(childNodesA),
+            childTerminalNodeMapB = terminalNodeMapFromNodes(childNodesB),
+            terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
+
+      if (terminalNodeMapsEqual) {
+        const index = 0,
+              childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
 
-      childNodesVerify = childNodesVerifyAhead; ///
+        childNodesVerify = childNodesVerifyAhead; ///
+      }
     }
 
     return childNodesVerify;
   }
 
+  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
+    let terminalNodeVerified;
+
+    const verifyAhead = remainingArguments.pop(),
+          verifiedAhead = verifyAhead();
+
+    terminalNodeVerified = verifiedAhead;  ///
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+
+      nonTerminalNodeVerified = childNodesVerify; ///
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
   verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
     let childNodesVerify;
 
@@ -60,11 +98,10 @@ export default class NodesVerifier {
             nodeA = childNodeA, ///
             nodeB = childNodeB, ///
             nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {
-              index++;
-
               remainingArguments.push(verifyAhead); ///
 
-              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+              const aheadIndex = index + 1,
+                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
 
               return childNodesVerifyAhead;
             });
@@ -74,38 +111,4 @@ export default class NodesVerifier {
 
     return childNodesVerify;
   }
-
-  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
-    let terminalNodeVerified = false;
-
-    const matches = terminalNodeA.match(terminalNodeB);
-
-    if (matches) {
-      const verifyAhead = remainingArguments.pop(),
-            verifiedAhead = verifyAhead();
-
-      terminalNodeVerified = verifiedAhead;  ///
-    }
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-    let nonTerminalNodeVerified = false;
-
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
-
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
-
-      nonTerminalNodeVerified = childNodesVerify; ///
-    }
-
-    return nonTerminalNodeVerified;
-  }
 }

package/src/verify/givenVariable.js

@@ -0,0 +1,31 @@
+"use strict";
+
+export default function verifyGivenVariable(variableNode, variables, context, verifyAhead) {
+  let givenVariableVerified = false;
+
+  const variableString = context.nodeAsString(variableNode);
+
+  context.trace(`Verifying the '${variableString}' given variable...`, variableNode);
+
+  const variable = context.findVariableByVariableNode(variableNode);
+
+  if (variable !== null) {
+    let verifiedAhead;
+
+    variables.push(variable);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      variables.pop();
+    }
+
+    givenVariableVerified = verifiedAhead; ///
+  }
+
+  if (givenVariableVerified) {
+    context.debug(`...verified the '${variableString}' given variable.`, variableNode);
+  }
+
+  return givenVariableVerified;
+}

package/src/verify/term.js

@@ -2,9 +2,12 @@
 
 import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
-import verifyTermAsGivenVariable from "../verify/termAsGivenVariable";
+import verifyGivenVariable from "../verify/givenVariable";
 
 import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
 
 function verifyTerm(termNode, terms, context, verifyAhead) {
   let termVerified;
@@ -60,53 +63,61 @@ Object.assign(termNodesVerifier, {
 export default verifyTerm;
 
 function verifyTermAsVariable(termNode, terms, context, verifyAhead) {
-  let termVerifiedAsVariable;
+  let termVerifiedAsVariable = false;
 
-  const termString = context.nodeAsString(termNode);
+  const variableNode = variableNodeQuery(termNode);
 
-  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+  if (variableNode !== null) {
+    const termString = context.nodeAsString(termNode);
 
-  const variables = [],
-        termVerifiedAsGivenVariable = verifyTermAsGivenVariable(termNode, variables, context, () => {
-          let verifiedAhead;
+    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-          const firstVariable = first(variables),
-                variable = firstVariable, ///
-                type = variable.getType(),
-                term = Term.fromTermNodeAndType(termNode, type);
+    const variables = [],
+          givenVariableVerified = verifyGivenVariable(variableNode, variables, context, () => {
+            let verifiedAhead;
 
-          terms.push(term);
+            const firstVariable = first(variables),
+                  variable = firstVariable, ///
+                  type = variable.getType(),
+                  term = Term.fromTermNodeAndType(termNode, type);
 
-          verifiedAhead = verifyAhead();
+            terms.push(term);
 
-          if (!verifiedAhead) {
-            terms.pop();
-          }
+            verifiedAhead = verifyAhead();
 
-          return verifiedAhead;
-        });
+            if (!verifiedAhead) {
+              terms.pop();
+            }
+
+            return verifiedAhead;
+          });
 
-  termVerifiedAsVariable = termVerifiedAsGivenVariable;  ///
+    termVerifiedAsVariable = givenVariableVerified;  ///
 
-  if (termVerifiedAsVariable) {
-    context.debug(`...verified the '${termString}' term as a variable.`, termNode);
+    if (termVerifiedAsVariable) {
+      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
+    }
   }
 
   return termVerifiedAsVariable;
 }
 
 function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
-  let termVerifiedAgainstConstructors;
+  let termVerifiedAgainstConstructors = false;
 
-  const constructors = context.getConstructors();
+  const variableNode = variableNodeQuery(termNode);
 
-  termVerifiedAgainstConstructors = constructors.some((constructor) => {
-    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+  if (variableNode === null) {
+    const constructors = context.getConstructors();
 
-    if (termVerifiedAgainstConstructor) {
-      return true;
-    }
-  });
+    termVerifiedAgainstConstructors = constructors.some((constructor) => {
+      const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+
+      if (termVerifiedAgainstConstructor) {
+        return true;
+      }
+    });
+  }
 
   return termVerifiedAgainstConstructors;
 }

package/lib/verify/termAsGivenVariable.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyTermAsGivenVariable;
-    }
-});
-var _query = require("../utilities/query");
-var variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
-function verifyTermAsGivenVariable(termNode, variables, context, verifyAhead) {
-    var termVerifiedAsVariable = false;
-    var variableNode = variableNodeQuery(termNode);
-    if (variableNode !== null) {
-        var termString = context.nodeAsString(termNode);
-        context.trace("Verifying the '".concat(termString, "' term as a given variable..."), termNode);
-        var variable = context.findVariableByVariableNode(variableNode);
-        if (variable !== null) {
-            var verifiedAhead;
-            variables.push(variable);
-            verifiedAhead = verifyAhead();
-            if (!verifiedAhead) {
-                variables.pop();
-            }
-            termVerifiedAsVariable = verifiedAhead; ///
-        }
-        if (termVerifiedAsVariable) {
-            context.debug("...verified the '".concat(termString, "' term as a given variable."), termNode);
-        }
-    }
-    return termVerifiedAsVariable;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/verify/termAsGivenVariable.js

@@ -1,39 +0,0 @@
-"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;
-}