occam-verify-cli 0.0.532 → 0.0.533

package/src/equality.js

@@ -1,15 +1,12 @@
 "use strict";
 
-import matcher from "./matcher";
+import Variable from "./variable";
 import verifyTerm from "./verify/term";
-import equalityCombinator from "./ocmbinator/equality";
-import equalityStatementNode from "./node/statement/equality";
 
 import { nodeQuery } from "./utilities/query";
 import { first, second } from "./utilities/array";
-import { EQUALITY_DEPTH } from "./constants";
 import { TERM_RULE_NAME } from "./ruleNames";
-import { verifyStatementAgainstCombinator } from "./verify/statement";
+import { verifyTermAsVariable } from "./verify/term";
 
 const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
@@ -88,40 +85,10 @@ export default class Equality {
     return equates;
   }
 
-  static fromProofStep(proofStep) {
-    let equality = null;
-
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const nodeA = statementNode,  ///
-            nodeB = equalityStatementNode,  ///
-            depth = EQUALITY_DEPTH,
-            nodeMatches = matcher.matchNode(nodeA, nodeB, depth);
-
-      if (nodeMatches) {
-        const leftTermNode = leftTermNodeQuery(statementNode),
-              rightTermNode = rightTermNodeQuery(statementNode);
-
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
-    }
-
-    return equality;
-  }
-
   static fromStatementNode(statementNode, context) {
-    let equality = null;
-
-    const combinator = equalityCombinator,  ///
-          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
-
-    if (statementVerifiedAgainstCombinator) {
-      const leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode);
-
-      equality = new Equality(leftTermNode, rightTermNode);
-    }
+    const leftTermNode = leftTermNodeQuery(statementNode),
+          rightTermNode = rightTermNodeQuery(statementNode),
+          equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
 
     return equality;
   }
@@ -264,12 +231,41 @@ function equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, c
     if (leftTermTypeEqualToRightTermType) {
       equality = new Equality(leftTermNode, rightTermNode);
     } else {
+      const leftTermTypeSubTypeOfRightTermType = leftTermType.isSubTypeOf(rightTermType);
+
+      if (false) {
+          ///
+      } else if (leftTermTypeSubTypeOfRightTermType) {
+        const variables = [],
+              rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+        if (rightTermVerifiedAsVariable) {
+          let rightVariable;
+
+          const firstVariable = first(variables);
+
+          rightVariable = firstVariable;  ///
+
+          const rightVariableName = rightVariable.getName(),
+                rightName = rightVariableName,  ///
+                rightType = leftTermType; ///
+
+          rightVariable = Variable.fromTypeAndName(rightType, rightName);
+
+          context.addVariable(rightVariable);
+
+          equality = new Equality(leftTermNode, rightTermNode);
+        }
+      }
+    }
+
+    if (equality === null) {
       const leftTermString = context.nodeAsString(leftTermNode),
             rightTermString = context.nodeAsString(rightTermNode),
             leftTermTypeName = leftTermType.getName(),
             rightTermTypeName = rightTermType.getName();
 
-      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type.'`, leftTermNode);
+      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type and neither can be inferred.'`, leftTermNode);
     }
   }
 

package/src/variable.js

@@ -1,9 +1,10 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name) {
+  constructor(type, name, termNode) {
     this.type = type;
     this.name = name;
+    this.termNode = termNode;
   }
 
   getType() {
@@ -14,6 +15,14 @@ export default class Variable {
     return this.name;
   }
 
+  getTermNode() {
+    return this.termNode;
+  }
+
+  isUndefined() {
+    return (this.termNode === null);
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 
@@ -28,7 +37,14 @@ export default class Variable {
   }
 
   static fromTypeAndName(type, name) {
-    const variable = new Variable(type, name);
+    const termNode = null,
+          variable = new Variable(type, name, termNode);
+
+    return variable;
+  }
+
+  static fromTypeNameAndTermNode(type, name, termNode) {
+    const variable = new Variable(type, name, termNode);
 
     return variable;
   }

package/src/verify/assertion/type.js

@@ -1,54 +1,53 @@
 "use strict";
 
 import Variable from "../../variable";
-import TypeAssertion from "../../assertion/type";
+import Assertion from "../../assertion";
 
 import { first } from "../../utilities/array";
-import { verifyTermAsVariable } from "../../verify/term";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, context) {
   let typeAssertionVerified = false;
 
-  const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
+  context.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
-        typePresent = proofContext.isTypePresentByTypeName(typeName);
+        typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
-    // if (!typeAssertionVerified) {
-    //   const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
-    //
-    //   typeAssertionVerified = termTypeAssertionVerified;  ///
-    // }
+    if (!typeAssertionVerified) {
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, context);
+
+      typeAssertionVerified = termTypeAssertionVerified;  ///
+    }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+    context.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context) {
   let variableTypeAssertionVerified = false;
 
-  const context = proofContext, ///
-        variables = [],
+  const variables = [],
         termNode = termNodeQuery(typeAssertionNode),
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
@@ -56,41 +55,45 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
     const typeNode = typeNodeQuery(typeAssertionNode),
           typeName = typeNameFromTypeNode(typeNode),
           assertedTypeName = typeName,  ///
-          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-          firstVariable = first(variables),
-          variable = firstVariable, ///
-          variableName = variable.getName(),
-          variableType = variable.getType();
-
-    if (derived) {
-      const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+          assertedType = context.findTypeByTypeName(assertedTypeName);
 
-      if (!variableTypeEqualToOrSubTypeOfAssertedType) {
-        const assertedTypeName = assertedType.getName(),
-              variableTypeName = variableType.getName();
-
-        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
-      } else {
-        variableTypeAssertionVerified = true;
-      }
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
-      const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+      const firstVariable = first(variables),
+            variable = firstVariable, ///
+            variableName = variable.getName(),
+            variableType = variable.getType();
+
+      if (derived) {
+        const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+
+        if (!variableTypeEqualToOrSubTypeOfAssertedType) {
+          const assertedTypeName = assertedType.getName(),
+                variableTypeName = variableType.getName();
+
+          context.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
+        } else {
+          variableTypeAssertionVerified = true;
+        }
+      } else {
+        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
-      if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-        const assertedTypeName = assertedType.getName(),
-              variableTypeName = variableType.getName();
+        if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+          const assertedTypeName = assertedType.getName(),
+                variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-      } else {
-        const type = assertedType,  ///
-              name = variableName,  ///
-              variable = Variable.fromTypeAndName(type, name),
-              typeAssertion = TypeAssertion.fromVariable(variable),
-              assertion = typeAssertion;  ///
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+        } else {
+          const type = assertedType,  ///
+                name = variableName,  ///
+                variable = Variable.fromTypeAndName(type, name),
+                assertion = Assertion.fromVariable(variable);
 
-        assertions.push(assertion);
+          assertions.push(assertion);
 
-        variableTypeAssertionVerified = true;
+          variableTypeAssertionVerified = true;
+        }
       }
     }
   }
@@ -98,40 +101,38 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
   return variableTypeAssertionVerified;
 }
 
-// function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
-//   let termTypeAssertionVerified = false;
-//
-//   const types = [],
-//         context = proofContext, ///
-//         termNode = termNodeQuery(typeAssertionNode),
-//         termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-//
-//   if (termVerifiedAgainstConstructors) {
-//     const typeNode = typeNodeQuery(typeAssertionNode),
-//           typeName = typeNameFromTypeNode(typeNode),
-//           assertedTypeName = typeName,  ///
-//           assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-//           firstType = first(types),
-//           termType = firstType,
-//           termString = proofContext.nodeAsString(termNode),
-//           termTypeEqualToOrSubTypeOfAssertedType = termType.isEqualToOrSubTypeOf(assertedType);
-//
-//     if (!termTypeEqualToOrSubTypeOfAssertedType) {
-//       const termTypeName = termType.getName(),
-//             assertedTypeName = assertedType.getName();
-//
-//       proofContext.error(`The '${termString}' term's '${termTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
-//     } else {
-//       const type = assertedType,  ///
-//             typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
-//             assertion = typeAssertion;  ///
-//
-//       assertions.push(assertion);
-//
-//       termTypeAssertionVerified = true;
-//     }
-//   }
-//
-//   return termTypeAssertionVerified;
-// }
+function verifyTermTypeAssertion(typeAssertionNode, context) {
+  let termTypeAssertionVerified = false;
+
+  const types = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+
+  if (termVerifiedAgainstConstructors) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = context.findTypeByTypeName(assertedTypeName);
+
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
+    } else {
+      const firstType = first(types),
+            termType = firstType, ///
+            termTypeIsEqualToAssertedType = termType.isEqualTo(assertedType);
+
+      if (!termTypeIsEqualToAssertedType) {
+        const termString = context.nodeAsString(termNode),
+              termTypeName = termType.getName(),
+              assertedTypeName = assertedType.getName();
+
+        context.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+      } else {
+        termTypeAssertionVerified = true;
+      }
+    }
+  }
+
+  return termTypeAssertionVerified;
+}
 

package/src/verify/statement.js

@@ -1,19 +1,25 @@
 "use strict";
 
-import Equality from "../equality";
+import Variable from "../variable";
+import Assertion from "../assertion";
 import verifyTerm from "../verify/term";
+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 { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
+import { verifyTermAsVariable } from "../verify/term";
 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!"),
+      leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
       metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
@@ -35,7 +41,7 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assertions, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -43,16 +49,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,6 +74,16 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   return statementVerifiedAgainstCombinators;
 }
 
+function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+      node = statementNode,  ///
+      combinatorNode = combinatorStatementNode, ///
+      nodeVerified = verifyNode(node, combinatorNode, context),
+      statementVerifiedAgainstCombinator = nodeVerified;  ///
+
+  return statementVerifiedAgainstCombinator;
+}
+
 function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
@@ -92,25 +98,73 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, derived, cont
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
+function verifyStatementAsEquality(statementNode, assertions, derived, context) {
   let statementVerifiedAsEquality = false;
 
-  const equality = Equality.fromStatementNode(statementNode, context);
+  const statementString = context.nodeAsString(statementNode);
 
-  if (equality !== null) {
-    statementVerifiedAsEquality = true; ///
+  const combinator = equalityCombinator,  ///
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
+  if (statementVerifiedAgainstCombinator) {
     if (derived) {
-      const equalities = context.getEqualities();
-
-      if (equalities !== null) {
-        const equalityEquates = equality.equate(equalities, context);
-
-        statementVerifiedAsEquality = equalityEquates; ///
+      debugger
+    } else {
+      const types = [],
+            variables = [],
+            leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode),
+            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),
+                assertion = Assertion.fromVariable(variable);
+
+          assertions.push(assertion);
+
+          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;
+        }
       }
     }
   }
 
+  if (statementVerifiedAsEquality) {
+    context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
+  }
+
   return statementVerifiedAsEquality;
 }
 

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;
-