occam-verify-cli 0.0.532 → 0.0.534

package/src/verify/statement/qualified.js

@@ -7,7 +7,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(qualifiedStatementNode);
@@ -21,7 +21,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
 
     if (referenceNode === null) {
       const context = proofContext,
-            statementVerified = verifyStatement(statementNode, assertions, derived, context);
+            statementVerified = verifyStatement(statementNode, assignments, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
     } else {

package/src/verify/statement/unqualified.js

@@ -6,7 +6,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
@@ -24,7 +24,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
     if (statementMatches) {
       const context = proofContext, ///
-            statementVerified = verifyStatement(statementNode, assertions, derived, context);
+            statementVerified = verifyStatement(statementNode, assignments, derived, context);
 
       unqualifiedStatementVerified = statementVerified;  ///
     }

package/src/verify/statement.js

@@ -1,25 +1,24 @@
 "use strict";
 
 import Equality from "../equality";
+import Variable from "../variable";
+import Assignment from "../assignment";
 import verifyTerm from "../verify/term";
+import statementVerifier from "../verifier/statement";
+import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
-import { objectType } from "../type";
-import { OBJECT_TYPE_NAME } from "../typeNames";
-import { STATEMENT_META_TYPE } from "../metaTypes";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
-
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
-
-export default function verifyStatement(statementNode, assertions, derived, context) {
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+import { verifyTermAsVariable } from "../verify/term";
+
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+
+export default function verifyStatement(statementNode, assignments, derived, context) {
   let statementVerified = false;
 
   if (!statementVerified) {
@@ -29,13 +28,13 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, derived, context);
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
 
     statementVerified = statementVerifiedAsTypeAssertion; ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assignments, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -43,16 +42,6 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   return statementVerified;
 }
 
-export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
-  const combinatorStatementNode = combinator.getStatementNode(),
-        node = statementNode,  ///
-        combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, context),
-        statementVerifiedAgainstCombinator = nodeVerified;  ///
-
-  return statementVerifiedAgainstCombinator;
-}
-
 function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
@@ -78,13 +67,24 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
+function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+        nonTerminalNodeA = statementNode,  ///
+        nonTerminalNodeB = combinatorStatementNode, ///
+        substitutions = null,
+        nodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context),
+        statementVerifiedAgainstCombinator = nodeVerified;  ///
+
+  return statementVerifiedAgainstCombinator;
+}
+
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, derived, context);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
   }
@@ -92,189 +92,76 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, derived, cont
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
+function verifyStatementAsEquality(statementNode, assignments, derived, context) {
   let statementVerifiedAsEquality = false;
 
-  const equality = Equality.fromStatementNode(statementNode, context);
-
-  if (equality !== null) {
-    statementVerifiedAsEquality = true; ///
-
-    if (derived) {
-      const equalities = context.getEqualities();
+  const statementString = context.nodeAsString(statementNode);
 
-      if (equalities !== null) {
-        const equalityEquates = equality.equate(equalities, context);
+  const combinator = equalityCombinator,  ///
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
-        statementVerifiedAsEquality = equalityEquates; ///
-      }
-    }
-  }
+  if (statementVerifiedAgainstCombinator) {
+    const leftTermNode = leftTermNodeQuery(statementNode),
+          rightTermNode = rightTermNodeQuery(statementNode);
 
-  return statementVerifiedAsEquality;
-}
-
-function verifyNode(node, combinatorNode, context) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        combinatorNodeTerminalNode = combinatorNode.isTerminalNode();
-
-  if (nodeTerminalNode === combinatorNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            combinatorTerminalNode = combinatorNode,  ///
-            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, context);
+    if (derived) {
+      const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+            equalityEquates = equality.equate(context);
 
-      nodeVerified = terminalNodeVerified;  ///
+      statementVerifiedAsEquality = equalityEquates;  ///
     } else {
-      const nonTerminalNode = node, ///
-            combinatorNonTerminalNode = combinatorNode,  ///
-            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context);
-
-      nodeVerified = nonTerminalNodeVerified; ///
-    }
-  }
-
-  return nodeVerified;
-}
-
-function verifyNodes(nodes, combinatorNodes, context) {
-  let nodesVerified = false;
-
-  const nodesLength = nodes.length,
-        combinatorNodesLength = combinatorNodes.length;
-
-  if (nodesLength === combinatorNodesLength) {
-    nodesVerified = nodes.every((node, index) => {
-      const combinatorNode = combinatorNodes[index],
-            nodeVerified = verifyNode(node, combinatorNode, context);
-
-      if (nodeVerified) {
-        return true;
-      }
-    });
-  }
-
-  return nodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
-  let terminalNodeVerified = false;
-
-  const matches = terminalNode.match(combinatorTerminalNode);
-
-  if (matches) {
-    terminalNodeVerified = true;
-  }
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context) {
-  let nonTerminalNodeVerified = false;
-
-  const ruleName = nonTerminalNode.getRuleName(), ///
-        combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === combinatorRuleName) {
-    switch (ruleName) {
-      case ARGUMENT_RULE_NAME: {
-        const argumentNode = nonTerminalNode, ///
-              combinatorArgumentNode = combinatorNonTerminalNode, ///
-              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
-
-        nonTerminalNodeVerified = argumentNodeVerified; ///
-
-        break;
-      }
-
-      case META_ARGUMENT_RULE_NAME: {
-        const metaArgumentNode = nonTerminalNode, ///
-              combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
-
-        nonTerminalNodeVerified = metaArgumentNodeVerified; ///
-
-        break;
-      }
-
-      default: {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              combinatorNodes = combinatorChildNodes, ///
-              nodesVerified = verifyNodes(nodes, combinatorNodes, context);
-
-        nonTerminalNodeVerified = nodesVerified; ///
-
-        break;
-      }
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
-  let argumentNodeVerified = false;
-
-  const termNode = termNodeQuery(argumentNode);
-
-  if (termNode === null) {
-    const argumentString = context.nodeAsString(argumentNode);
-
-    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
-  } else {
-    const types = [],
-          termVerified = verifyTerm(termNode, types, context);
-
-    if (termVerified) {
-      const firstType = first(types),
-            termType = firstType, ///
-            typeNode = typeNodeQuery(combinatorArgumentNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            type = (typeName === OBJECT_TYPE_NAME) ?
-                     objectType :  ///
-                       context.findTypeByTypeName(typeName),
-            statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-
-      if (statementTypeEqualToOrSubTypeOfType) {
-        argumentNodeVerified = true;
+      const types = [],
+            variables = [],
+            leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context);
+
+      if (leftTermVerifiedAsVariable) {
+        verifyTerm(rightTermNode, types, context);
+
+        const firstVariable = first(variables),
+              leftVariable = firstVariable, ///
+              firstType = first(types),
+              rightTermType = firstType, ///
+              leftVariableType = leftVariable.getType(),
+              leftVariableName = leftVariable.getName(),
+              leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
+
+        if (!leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
+          const rightTermString = nodeAsString(rightTermNode),
+                rightTermTypeName = rightTermType.getName(),
+                leftVariableTypeName = leftVariableType.getName();
+
+          context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
+        } else {
+          const type = leftVariableType,  ///
+                name = leftVariableName,  ///
+                termNode = rightTermNode, ///
+                variable = Variable.fromTypeNameAndTermNode(type, name, termNode),
+                assignment = Assignment.fromVariable(variable);
+
+          assignments.push(assignment);
+
+          statementVerifiedAsEquality = true;
+        }
+      } else {
+        const rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+        if (rightTermVerifiedAsVariable) {
+          const firstVariable = first(variables),
+                rightVariable = firstVariable,  ///
+                leftTermString = nodeAsString(leftTermNode),
+                rightVariableName = rightVariable.getName();
+
+          context.error(`The left '${leftTermString}' term cannot be equated with the right '${rightVariableName}' variable.`, statementNode);
+        } else {
+          statementVerifiedAsEquality = true;
+        }
       }
     }
   }
 
-  return argumentNodeVerified;
-}
-
-function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
-  let metaArgumentNodeVerified = false;
-
-  const statementNode = statementNodeQuery(metaArgumentNode),
-        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
-
-  if (statementNode === null) {
-    const metaArgumentString = context.nodeAsString(metaArgumentNode);
-
-    context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-  } else {
-    if (combinatorMetaTYpeNode === null) {
-      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-
-      context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
-    } else {
-      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-            content = combinatorMetaTypeTerminalNode.getContent(),
-            contentStatementMetaType = (content === STATEMENT_META_TYPE);
-
-      if (!contentStatementMetaType) {
-        context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
-      } else {
-        metaArgumentNodeVerified = true;
-      }
-    }
+  if (statementVerifiedAsEquality) {
+    context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
   }
 
-  return metaArgumentNodeVerified;
+  return statementVerifiedAsEquality;
 }

package/src/verify/statementAsCombinator.js

@@ -145,8 +145,8 @@ function verifyTermNode(termNode, fileContext) {
 function verifyStatementNode(statementNode, fileContext) {
   const context = fileContext,  ///
         derived = false,
-        assertions = [],
-        statementVerified = verifyStatement(statementNode, assertions, derived, context),
+        assignments = [],
+        statementVerified = verifyStatement(statementNode, assignments, derived, context),
         statementNodeVerified = statementVerified;  ///
 
   return statementNodeVerified;

package/src/verify/supposition.js

@@ -17,9 +17,9 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
   proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
-        assertions = [],
+        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -30,8 +30,8 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
     proofContext.addProofStep(proofStep);
 
-    assertions.every((assertion) => {
-      assertion.assert(proofContext);
+    assignments.every((assignment) => {
+      assignment.assign(proofContext);
     });
 
     suppositionVerified = true;

package/lib/assertion/type.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return TypeAssertion;
-    }
-});
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var TypeAssertion = /*#__PURE__*/ function() {
-    function TypeAssertion(variable) {
-        _classCallCheck(this, TypeAssertion);
-        this.variable = variable;
-    }
-    _createClass(TypeAssertion, [
-        {
-            key: "getVariable",
-            value: function getVariable() {
-                return this.variable;
-            }
-        },
-        {
-            key: "assert",
-            value: function assert(proofContext) {
-                proofContext.addVariable(this.variable);
-            }
-        }
-    ], [
-        {
-            key: "fromVariable",
-            value: function fromVariable(variable) {
-                var typeAssertion = new TypeAssertion(variable);
-                return typeAssertion;
-            }
-        }
-    ]);
-    return TypeAssertion;
-}();
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hc3NlcnRpb24vdHlwZS5qcyIsIjw8anN4LWNvbmZpZy1wcmFnbWEuanM+PiJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVHlwZUFzc2VydGlvbiB7XG4gIGNvbnN0cnVjdG9yKHZhcmlhYmxlKSB7XG4gICAgdGhpcy52YXJpYWJsZSA9IHZhcmlhYmxlO1xuICB9XG5cbiAgZ2V0VmFyaWFibGUoKSB7XG4gICAgcmV0dXJuIHRoaXMudmFyaWFibGU7XG4gIH1cblxuICBhc3NlcnQocHJvb2ZDb250ZXh0KSB7XG4gICAgcHJvb2ZDb250ZXh0LmFkZFZhcmlhYmxlKHRoaXMudmFyaWFibGUpO1xuICB9XG5cbiAgc3RhdGljIGZyb21WYXJpYWJsZSh2YXJpYWJsZSkge1xuICAgIGNvbnN0IHR5cGVBc3NlcnRpb24gPSBuZXcgVHlwZUFzc2VydGlvbih2YXJpYWJsZSk7XG5cbiAgICByZXR1cm4gdHlwZUFzc2VydGlvbjtcbiAgfVxufVxuIiwiUmVhY3QuY3JlYXRlRWxlbWVudCJdLCJuYW1lcyI6WyJUeXBlQXNzZXJ0aW9uIiwidmFyaWFibGUiLCJnZXRWYXJpYWJsZSIsImFzc2VydCIsInByb29mQ29udGV4dCIsImFkZFZhcmlhYmxlIiwiZnJvbVZhcmlhYmxlIiwidHlwZUFzc2VydGlvbiJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7ZUFFcUJBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQU4sSUFBQSxBQUFNQSw4QkFBTjthQUFNQSxjQUNQQyxRQUFROzhCQURERDtRQUVqQixJQUFJLENBQUNDLFFBQVEsR0FBR0E7O2lCQUZDRDs7WUFLbkJFLEtBQUFBO21CQUFBQSxTQUFBQSxjQUFjO2dCQUNaLE9BQU8sSUFBSSxDQUFDRCxRQUFRO1lBQ3RCOzs7WUFFQUUsS0FBQUE7bUJBQUFBLFNBQUFBLE9BQU9DLFlBQVksRUFBRTtnQkFDbkJBLGFBQWFDLFdBQVcsQ0FBQyxJQUFJLENBQUNKLFFBQVE7WUFDeEM7Ozs7WUFFT0ssS0FBQUE7bUJBQVAsU0FBT0EsYUFBYUwsUUFBUSxFQUFFO2dCQUM1QixJQUFNTSxnQkFBZ0IsSUFkTFAsY0FjdUJDO2dCQUV4QyxPQUFPTTtZQUNUOzs7V0FqQm1CUCJ9

package/lib/node/statement/equality.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _node = require("../../utilities/node");
-var equalityStatementString = "n=m";
-var equalityStatementNode = (0, _node.statementNodeFromStatementString)(equalityStatementString);
-var _default = equalityStatementNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ub2RlL3N0YXRlbWVudC9lcXVhbGl0eS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgc3RhdGVtZW50Tm9kZUZyb21TdGF0ZW1lbnRTdHJpbmcgfSBmcm9tIFwiLi4vLi4vdXRpbGl0aWVzL25vZGVcIjtcblxuY29uc3QgZXF1YWxpdHlTdGF0ZW1lbnRTdHJpbmcgPSBcIm49bVwiO1xuXG5jb25zdCBlcXVhbGl0eVN0YXRlbWVudE5vZGUgPSBzdGF0ZW1lbnROb2RlRnJvbVN0YXRlbWVudFN0cmluZyhlcXVhbGl0eVN0YXRlbWVudFN0cmluZyk7XG5cbmV4cG9ydCBkZWZhdWx0IGVxdWFsaXR5U3RhdGVtZW50Tm9kZTtcblxuIl0sIm5hbWVzIjpbImVxdWFsaXR5U3RhdGVtZW50U3RyaW5nIiwiZXF1YWxpdHlTdGF0ZW1lbnROb2RlIiwic3RhdGVtZW50Tm9kZUZyb21TdGF0ZW1lbnRTdHJpbmciXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQVFBOzs7ZUFBQTs7O29CQU5pRDtBQUVqRCxJQUFNQSwwQkFBMEI7QUFFaEMsSUFBTUMsd0JBQXdCQyxJQUFBQSxzQ0FBZ0MsRUFBQ0Y7SUFFL0QsV0FBZUMifQ==

package/src/node/statement/equality.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import { statementNodeFromStatementString } from "../../utilities/node";
-
-const equalityStatementString = "n=m";
-
-const equalityStatementNode = statementNodeFromStatementString(equalityStatementString);
-
-export default equalityStatementNode;
-