occam-furtle 2.0.330 → 2.0.331

package/src/node/term/logical.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import TermNode from "../../node/term";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { SPECIAL_TOKEN_TYPE } from "../../tokenTypes";
+import { CONJUNCTION_OPERATOR, DISJUNCTION_OPERATOR } from "../../constants";
+
+const { first, last } = arrayUtilities;
+
+export default class LogicalTermNode extends TermNode {
+  getOperator() {
+    let operator = null;
+
+    const tokenType = SPECIAL_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      operator = content; ///
+
+      return true;
+    }, tokenType);
+
+    return operator;
+  }
+
+  isConjection() {
+    const operator = this.getOperator(),
+          conjection = (operator === CONJUNCTION_OPERATOR);
+
+    return conjection;
+  }
+
+  isDisjunction() {
+    const operator = this.getOperator(),
+          disjunction = (operator === DISJUNCTION_OPERATOR);
+
+    return disjunction;
+  }
+
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodesByRuleName(ruleName);
+
+    return termNodes;
+  }
+
+  getLeftTermNode() {
+    const firstExpresionNode = this.getFirstTermNode(),
+          leftTermNode = firstExpresionNode;  ///
+
+    return leftTermNode;
+  }
+
+  getRightTermNode() {
+    const lastTermNode = this.getLastTermNode(),
+          rightTermNode = lastTermNode; ///
+
+    return rightTermNode;
+  }
+
+  getLastTermNode() {
+    const termNodes = this.getTermNodes(),
+          lastTermNode = last(termNodes);
+
+    return lastTermNode;
+  }
+
+  getFirstTermNode() {
+    const termNodes = this.getTermNodes(),
+          firstTermNode = first(termNodes);
+
+    return firstTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TermNode.fromRuleNameChildNodesOpacityAndPrecedence(LogicalTermNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/term/negated.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import TermNode from "../../node/term";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+export default class NegatedTermNode extends TermNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TermNode.fromRuleNameChildNodesOpacityAndPrecedence(NegatedTermNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/term.js

@@ -2,7 +2,12 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-import { VARIABLE_RULE_NAME, PRIMITIVE_RULE_NAME } from "../ruleNames";
+import { VARIABLE_RULE_NAME,
+         PRIMITIVE_RULE_NAME,
+         NEGATED_TERM_RULE_NAME,
+         LOGICAL_TERM_RULE_NAME,
+         BRACKETED_TERM_RULE_NAME,
+         COMPARISON_TERM_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
   getVariableNode() {
@@ -19,5 +24,49 @@ export default class TermNode extends NonTerminalNode {
     return primitiveNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
+  getNegatedTermNode() {
+    const ruleName = NEGATED_TERM_RULE_NAME,
+          negatedTermNode = this.getNodeByRuleName(ruleName);
+
+    return negatedTermNode;
+  }
+
+  getLogicalTermNode() {
+    const ruleName = LOGICAL_TERM_RULE_NAME,
+          logicalTermRuleName = this.getNodeByRuleName(ruleName);
+
+    return logicalTermRuleName;
+  }
+
+  getBracketedTermNode() {
+    const ruleName = BRACKETED_TERM_RULE_NAME,
+          bracketedTermRuleName = this.getNodeByRuleName(ruleName);
+
+    return bracketedTermRuleName;
+  }
+
+  getComparisonTermNode() {
+    const ruleName = COMPARISON_TERM_RULE_NAME,
+          comparisonNode = this.getNodeByRuleName(ruleName);
+
+    return comparisonNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) {
+    if (precedence === undefined) {
+      precedence = opacity; ///
+
+      opacity = childNodes; ///
+
+      childNodes = ruleName;  ///
+
+      ruleName = Class; ///
+
+      Class = TermNode;
+    }
+
+    const termNode = NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence);
+
+    return termNode;
+  }
 }

package/src/node/ternary.js

@@ -4,11 +4,18 @@ import { arrayUtilities } from "necessary";
 
 import NonTerminalNode from "../nonTerminalNode";
 
-import { EXPRESSION_RULE_NAME } from "../ruleNames";
+import { TERM_RULE_NAME, EXPRESSION_RULE_NAME } from "../ruleNames";
 
-const { first, second, third } = arrayUtilities;
+const { first, second } = arrayUtilities;
 
 export default class TernaryNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
   getExpressionNodes() {
     const ruleName = EXPRESSION_RULE_NAME,
           expressionNodes = this.getNodesByRuleName(ruleName);
@@ -16,23 +23,16 @@ export default class TernaryNode extends NonTerminalNode {
     return expressionNodes;
   }
 
-  getExpressionNode() {
-    const firstExpressionNode = this.getFirstExpressionNode(),
-          expressionNode = firstExpressionNode; ///
-
-    return expressionNode;
-  }
-
   getIfExpressionNode() {
-    const secondExpressionNode = this.getSecondExpressionNode(),
-          ifExpressionNode = secondExpressionNode;  ///
+    const firstExpressionNode = this.getFirstExpressionNode(),
+          ifExpressionNode = firstExpressionNode;  ///
 
     return ifExpressionNode;
   }
 
   getElseExpressionNode() {
-    const thirdExpressionNode = this.getThirdExpressionNode(),
-          elseExpressionNode = thirdExpressionNode; ///
+    const secondExpressionNode = this.getSecondExpressionNode(),
+          elseExpressionNode = secondExpressionNode; ///
 
     return elseExpressionNode;
   }
@@ -51,12 +51,5 @@ export default class TernaryNode extends NonTerminalNode {
     return secondExpressionNode;
   }
 
-  getThirdExpressionNode() {
-    const expressionNodes = this.getExpressionNodes(),
-          thirdExpressionNode = third(expressionNodes);
-
-    return thirdExpressionNode;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TernaryNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/nonTerminalNodeMap.js

@@ -16,22 +16,26 @@ import ReferenceNode from "./node/reference";
 import ParameterNode from "./node/parameter";
 import NodeQueryNode from "./node/nodeQuery";
 import ExpressionNode from "./node/expression";
-import ComparisonNode from "./node/comparison";
 import ParametersNode from "./node/parameters";
 import NodesQueryNode from "./node/nodesQuery";
 import ReturnBlockNode from "./node/returnBlock";
+import LogicalTermNode from "./node/term/logical";
+import NegatedTermNode from "./node/term/negated";
+import BracketedTermNode from "./node/term/bracketed";
+import ComparisonTermNode from "./node/term/comparison";
 import ProcedureCallNode from "./node/procedureCall";
 import NamedParameterNode from "./node/parameter/named";
 import NamedParametersNode from "./node/parameters/named";
 import ReturnStatementNode from "./node/statement/return";
 import ArrayAssignmentNode from "./node/assignment/array";
 import ObjectAssignmentNode from "./node/assignment/object";
-import LogicalExpresionNode from "./node/expression/logical";
+import LogicalExpressionNode from "./node/expression/logical";
 import NegatedExpressionNode from "./node/expression/negated";
 import AnonymousProcedureNode from "./node/procedure/anoymous";
 import VariableAssignmentNode from "./node/assignment/variable";
 import VariableAssignmentsNode from "./node/assignments/variable";
 import BracketedExpressionNode from "./node/expression/bracketed";
+import ComparisonExpressionNode from "./node/expression/comparison";
 import ProcedureDeclarationNode from "./node/declaration/procedure";
 
 import { STEP_RULE_NAME,
@@ -50,11 +54,14 @@ import { STEP_RULE_NAME,
          PARAMETER_RULE_NAME,
          NODE_QUERY_RULE_NAME,
          EXPRESSION_RULE_NAME,
-         COMPARISON_RULE_NAME,
          PARAMETERS_RULE_NAME,
          NODES_QUERY_RULE_NAME,
          RETURN_BLOCK_RULE_NAME,
+         LOGICAL_TERM_RULE_NAME,
+         NEGATED_TERM_RULE_NAME,
+         BRACKETED_TERM_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
+         COMPARISON_TERM_RULE_NAME,
          NAMED_PARAMETER_RULE_NAME,
          NAMED_PARAMETERS_RULE_NAME,
          RETURN_STATEMENT_RULE_NAME,
@@ -66,6 +73,7 @@ import { STEP_RULE_NAME,
          ANONYMOUS_PROCEDURE_RULE_NAME,
          VARIABLE_ASSIGNMENTS_RULE_NAME,
          BRACKETED_EXPRESSION_RULE_NAME,
+         COMPARISON_EXPRESSION_RULE_NAME,
          PROCEDURE_DECLARATION_RULE_NAME } from "./ruleNames";
 
 const NonTerminalNodeMap = {
@@ -85,22 +93,26 @@ const NonTerminalNodeMap = {
   [PARAMETER_RULE_NAME]: ParameterNode,
   [NODE_QUERY_RULE_NAME]: NodeQueryNode,
   [EXPRESSION_RULE_NAME]: ExpressionNode,
-  [COMPARISON_RULE_NAME]: ComparisonNode,
   [PARAMETERS_RULE_NAME]: ParametersNode,
   [NODES_QUERY_RULE_NAME]: NodesQueryNode,
   [RETURN_BLOCK_RULE_NAME]: ReturnBlockNode,
+  [LOGICAL_TERM_RULE_NAME]: LogicalTermNode,
+  [NEGATED_TERM_RULE_NAME]: NegatedTermNode,
   [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
+  [BRACKETED_TERM_RULE_NAME]: BracketedTermNode,
+  [COMPARISON_TERM_RULE_NAME]: ComparisonTermNode,
   [NAMED_PARAMETER_RULE_NAME]: NamedParameterNode,
   [NAMED_PARAMETERS_RULE_NAME]: NamedParametersNode,
   [RETURN_STATEMENT_RULE_NAME]: ReturnStatementNode,
   [ARRAY_ASSIGNMENT_RULE_NAME]: ArrayAssignmentNode,
   [OBJECT_ASSIGNMENT_RULE_NAME]: ObjectAssignmentNode,
-  [LOGICAL_EXPRESSION_RULE_NAME]: LogicalExpresionNode,
+  [LOGICAL_EXPRESSION_RULE_NAME]: LogicalExpressionNode,
   [NEGATED_EXPRESSION_RULE_NAME]: NegatedExpressionNode,
   [ANONYMOUS_PROCEDURE_RULE_NAME]: AnonymousProcedureNode,
   [VARIABLE_ASSIGNMENT_RULE_NAME]: VariableAssignmentNode,
   [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode,
   [BRACKETED_EXPRESSION_RULE_NAME]: BracketedExpressionNode,
+  [COMPARISON_EXPRESSION_RULE_NAME]: ComparisonExpressionNode,
   [PROCEDURE_DECLARATION_RULE_NAME]: ProcedureDeclarationNode
 };
 

package/src/preamble.js

@@ -17,10 +17,13 @@ import NodeQuery from "./element/nodeQuery";
 import Parameter from "./element/parameter";
 import Parameters from "./element/parameters";
 import NodesQuery from "./element/nodesQuery";
-import Comparison from "./element/comparison";
 import Expression from "./element/expression";
 import ReturnBlock from "./element/returnBlock";
+import NegatedTerm from "./element/term/negated";
+import LogicalTerm from "./element/term/logical";
+import BracketedTerm from "./element/term/bracketed";
 import ProcedureCall from "./element/procedureCall";
+import ComparisonTerm from "./element/term/comparison";
 import NamedParameter from "./element/parameter/named";
 import ArrayAssigment from "./element/assignment/array";
 import ReturnStatement from "./element/statement/return";
@@ -30,6 +33,7 @@ import NegatedExpression from "./element/expression/negated";
 import LogicalExpression from "./element/expression/logical";
 import AnonymousProcedure from "./element/procedure/anonymous";
 import VariableAssignment from "./element/assignment/variable";
-import BracketedExpression from "./element/expression/bracketed";
 import VariableAssignments from "./element/assignments/variable";
+import BracketedExpression from "./element/expression/bracketed";
+import ComparisonExpression from "./element/expression/comparison";
 import ProcedureDeclaration from "./element/declaration/procedure";

package/src/ruleNames.js

@@ -16,11 +16,14 @@ export const REFERENCE_RULE_NAME = "reference";
 export const PARAMETER_RULE_NAME = "parameter";
 export const NODE_QUERY_RULE_NAME = "nodeQuery";
 export const EXPRESSION_RULE_NAME = "expression";
-export const COMPARISON_RULE_NAME = "comparison";
 export const PARAMETERS_RULE_NAME = "parameters";
 export const NODES_QUERY_RULE_NAME = "nodesQuery";
 export const RETURN_BLOCK_RULE_NAME = "returnBlock";
+export const LOGICAL_TERM_RULE_NAME = "logicalTerm";
+export const NEGATED_TERM_RULE_NAME = "negatedTerm";
+export const BRACKETED_TERM_RULE_NAME = "bracketedTerm";
 export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
+export const COMPARISON_TERM_RULE_NAME = "comparisonTerm";
 export const NAMED_PARAMETER_RULE_NAME = "namedParameter";
 export const NAMED_PARAMETERS_RULE_NAME = "namedParameters";
 export const RETURN_STATEMENT_RULE_NAME = "returnStatement";
@@ -30,6 +33,8 @@ export const LOGICAL_EXPRESSION_RULE_NAME = "logicalExpression";
 export const NEGATED_EXPRESSION_RULE_NAME = "negatedExpression";
 export const VARIABLE_ASSIGNMENT_RULE_NAME = "variableAssignment";
 export const ANONYMOUS_PROCEDURE_RULE_NAME = "anonymousProcedure";
-export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";
 export const BRACKETED_EXPRESSION_RULE_NAME = "bracketedExpression";
+export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";
 export const PROCEDURE_DECLARATION_RULE_NAME = "procedureDeclaration";
+export const COMPARISON_EXPRESSION_RULE_NAME = "comparisonExpression";
+

package/src/utilities/element.js

@@ -31,11 +31,11 @@ export function stepFromStepNode(stepNode, context) {
 
 export function someFromSomeNode(someNode, context) {
   const { Some } = elements,
-    variable = variableFromSomeNode(someNode, context),
-    anonymousProcedure = anonymousProcedureFromSomeNode(someNode, context),
-    someString = someStringFromVariableAndAnonymousProcedure(variable, anonymousProcedure),
-    string = someString,  ///
-    some = new Some(string, variable, anonymousProcedure);
+        variable = variableFromSomeNode(someNode, context),
+        anonymousProcedure = anonymousProcedureFromSomeNode(someNode, context),
+        someString = someStringFromVariableAndAnonymousProcedure(variable, anonymousProcedure),
+        string = someString,  ///
+        some = new Some(string, variable, anonymousProcedure);
 
   return some;
 }
@@ -192,18 +192,6 @@ export function nodesQueryFromNodesQueryNode(nodesQueryNode, context) {
   return nodesQuery;
 }
 
-export function comparisonFromComparisonNode(comparisonNode, context) {
-  const { Comparison } = elements,
-        node = comparisonNode,  ///
-        string = context.nodeAsString(node),
-        negated = negatedFromComparisonNode(comparisonNode, context),
-        leftExpression = leftExpressionFromCompzrisonNode(comparisonNode, context),
-        rightExpression = rightExpressionFromCompzrisonNode(comparisonNode, context),
-        comparison = new Comparison(string, negated, leftExpression, rightExpression);
-
-  return comparison;
-}
-
 export function parametersFromParametersNode(parametersNode, context) {
   const { Parameters } = elements,
         node = parametersNode,  ///
@@ -225,12 +213,12 @@ export function expressionFromExpressionNode(expressionNode, context) {
         ternary = ternaryFromExpressionNode(expressionNode, context),
         nodeQuery = nodeQueryFromExpressionNode(expressionNode, context),
         nodesQuery = nodesQueryFromExpressionNode(expressionNode, context),
-        comparison = comparisonFromExpressionNode(expressionNode, context),
         returnBlock = returnBlockFromExpressionNode(expressionNode, context),
         procedureCall = procedureCallFromExpressionNode(expressionNode, context),
         negatedExpression = negatedExpressionFromExpressionNode(expressionNode, context),
         logicalExpression = logicalExpressionFromExpressionNode(expressionNode, context),
         bracketedExpression = bracketedExpressionFromExpressionNode(expressionNode, context),
+        comparisonExpression = comparisonExpressionFromExpressionNode(expressionNode, context),
         properties = [
           some,
           every,
@@ -239,7 +227,7 @@ export function expressionFromExpressionNode(expressionNode, context) {
           variable,
           nodeQuery,
           nodesQuery,
-          comparison,
+          comparisonExpression,
           returnBlock,
           procedureCall,
           negatedExpression,
@@ -248,7 +236,7 @@ export function expressionFromExpressionNode(expressionNode, context) {
         ],
         expressionString = expressionStringFromPrimitiveAndProperties(primitive, properties, context),
         string = expressionString,  ///
-        expression = new Expression(string, variable, primitive, some, every, reduce, ternary, nodeQuery, nodesQuery, comparison, returnBlock, procedureCall, negatedExpression, logicalExpression, bracketedExpression);
+        expression = new Expression(string, variable, primitive, some, every, reduce, ternary, nodeQuery, nodesQuery, returnBlock, procedureCall, negatedExpression, logicalExpression, bracketedExpression, comparisonExpression);
 
   return expression;
 }
@@ -394,6 +382,18 @@ export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclar
   return procedureDeclaration;
 }
 
+export function comparisonExpressionFromComparisonExpressionNode(comparisonExpressionNode, context) {
+  const { ComparisonExpression } = elements,
+        node = comparisonExpressionNode,  ///
+        string = context.nodeAsString(node),
+        negated = negatedFromComparisonExpressionNode(comparisonExpressionNode, context),
+        leftExpression = leftExpressionFromCompzrisonNode(comparisonExpressionNode, context),
+        rightExpression = rightExpressionFromCompzrisonNode(comparisonExpressionNode, context),
+        comparisonExpression = new ComparisonExpression(string, negated, leftExpression, rightExpression);
+
+  return comparisonExpression;
+}
+
 export function nameFromLabelNode(labelNode, context) {
   const name = labelNode.getName();
 
@@ -595,12 +595,6 @@ export function ternaryFromExpressionNode(expressionNode, context) {
   return ternary;
 }
 
-export function negatedFromComparisonNode(comparisonNode, context) {
-  const negated = comparisonNode.isNegated();
-
-  return negated;
-}
-
 export function expressionFromVariableNode(variableNode, context) {
   const expression = null;
 
@@ -725,18 +719,6 @@ export function nodesQueryFromExpressionNode(expressionNode, context) {
   return nodesQuery;
 }
 
-export function comparisonFromExpressionNode(expressionNOde, context) {
-  let comparison = null;
-
-  const comparisonNode = expressionNOde.getComparisonNode();
-
-  if (comparisonNode !== null) {
-    comparison = comparisonFromComparisonNode(comparisonNode, context);
-  }
-
-  return comparison;
-}
-
 export function elseExpressionFromTernaryNode(ternaryNode, context) {
   const elseExpressionNode = ternaryNode.getElseExpressionNode(),
         elseExpression = expressionFromExpressionNode(elseExpressionNode, context);
@@ -857,8 +839,8 @@ export function anonymousProcedureFromReduceNode(reduceNode, context) {
   return anonymousProcedure;
 }
 
-export function leftExpressionFromCompzrisonNode(comparisonNode, context) {
-  const leftExpressionNode = comparisonNode.getLeftExpressionNode(),
+export function leftExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
+  const leftExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
         leftExpression = expressionFromExpressionNode(leftExpressionNode, context);
 
   return leftExpression;
@@ -883,8 +865,8 @@ export function expressionFromTypeAndVariableNode(type, variableNode, context) {
   return expression;
 }
 
-export function rightExpressionFromCompzrisonNode(comparisonNode, context) {
-  const rightExpressionNode = comparisonNode.getLeftExpressionNode(),
+export function rightExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
+  const rightExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
         rightExpression = expressionFromExpressionNode(rightExpressionNode, context);
 
   return rightExpression;
@@ -935,6 +917,12 @@ export function logicalExpressionFromExpressionNode(expressionNode, context) {
   return logicalExpression;
 }
 
+export function negatedFromComparisonExpressionNode(comparisonExpressionNode, context) {
+  const negated = comparisonExpressionNode.isNegated();
+
+  return negated;
+}
+
 export function expressionFromNegatedExpressionNode(negatedExpressionNode, context) {
   const expressionNode = negatedExpressionNode.getExpressionNode(),
         expression = expressionFromExpressionNode(expressionNode, context);
@@ -1001,6 +989,18 @@ export function procedureFromProcedureDeclarationNode(procedureDeclarationNode,
   return procedure;
 }
 
+export function comparisonExpressionFromExpressionNode(expressionNOde, context) {
+  let comparisonExpression = null;
+
+  const comparisonExpressionNode = expressionNOde.getComparisonExpressionNode();
+
+  if (comparisonExpressionNode !== null) {
+    comparisonExpression = comparisonExpressionFromComparisonExpressionNode(comparisonExpressionNode, context);
+  }
+
+  return comparisonExpression;
+}
+
 export function parametersFromProcedureDeclarationNode(procedureDeclarationNode, context) {
   const parametersNode = procedureDeclarationNode.getParametersNode(),
         parameters = parametersFromParametersNode(parametersNode, context);

package/lib/element/comparison.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _exception = /*#__PURE__*/ _interop_require_default(require("../exception"));
-var _elements = require("../elements");
-var _term = require("../utilities/term");
-function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var _Comparison;
-var _default = (0, _elements.define)((_Comparison = /*#__PURE__*/ function() {
-    function Comparison(string, negated, leftExpression, rightExpression) {
-        _class_call_check(this, Comparison);
-        this.string = string;
-        this.negated = negated;
-        this.leftExpression = leftExpression;
-        this.rightExpression = rightExpression;
-    }
-    _create_class(Comparison, [
-        {
-            key: "getString",
-            value: function getString() {
-                return this.string;
-            }
-        },
-        {
-            key: "isNegated",
-            value: function isNegated() {
-                return this.negated;
-            }
-        },
-        {
-            key: "getLeftExpression",
-            value: function getLeftExpression() {
-                return this.leftExpression;
-            }
-        },
-        {
-            key: "getRightExpression",
-            value: function getRightExpression() {
-                return this.rightExpression;
-            }
-        },
-        {
-            key: "evaluate",
-            value: function evaluate(context) {
-                var term;
-                var comparisonString = this.string; ///
-                context.trace("Evaluating the '".concat(comparisonString, "' comparison..."));
-                var leftTerm = this.leftExpression.evaluate(context), rightTerm = this.rightExpression.evaluate(context), leftTermType = leftTerm.getType(), rightTermType = rightTerm.getType();
-                if (leftTermType !== rightTermType) {
-                    var leftTermString = leftTerm.getString(), rightTermString = rightTerm.getString(), message = "The '".concat(leftTermString, "' left expression's type is '").concat(leftTermType, "' whereas the '").concat(rightTermString, "' right expression's type is '").concat(rightTermType, "'."), exception = _exception.default.fromMessage(message);
-                    throw exception;
-                }
-                var leftTermEqualToRightTerm = leftTerm.isEqualTo(rightTerm);
-                var boolean = leftTermEqualToRightTerm; ///
-                if (this.negated) {
-                    boolean = !boolean; ///
-                }
-                term = (0, _term.termFromBoolean)(boolean, context);
-                context.debug("...evaluated the '".concat(comparisonString, "' comparison."));
-                return term;
-            }
-        }
-    ]);
-    return Comparison;
-}(), _define_property(_Comparison, "name", "Comparison"), _Comparison));
-
-//# sourceMappingURL=data:application/json;base64,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