occam-furtle 2.0.279 → 2.0.282

package/lib/element/assignments/variable.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _query = require("../../utilities/query");
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _VariableAssignments;
+var typeTerminalNodeQuery = (0, _query.nodeQuery)("/variableAssignments/@type"), variableAssignmentNodesQuery = (0, _query.nodesQuery)("/variableAssignments/variableAssignment"), stepVariableAssignmentsNodeQuery = (0, _query.nodeQuery)("/step/variableAssignments");
+var _default = (0, _elements.define)((_VariableAssignments = /*#__PURE__*/ function() {
+    function VariableAssignments(string, array) {
+        _class_call_check(this, VariableAssignments);
+        this.string = string;
+        this.array = array;
+    }
+    _create_class(VariableAssignments, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getArray",
+            value: function getArray() {
+                return this.array;
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var variableAssignmentsString = this.string; ///
+                context.trace("Evaluating the '".concat(variableAssignmentsString, "' variable assignments..."));
+                this.array.forEach(function(variableAssignment) {
+                    variableAssignment.evaluate(context);
+                });
+                context.debug("...evaluated the '".concat(variableAssignmentsString, "' variable assignments."));
+            }
+        }
+    ], [
+        {
+            key: "fromStepNode",
+            value: function fromStepNode(stepNode, context) {
+                var variableAssignments = null;
+                var stepVariableAssignmentsNode = stepVariableAssignmentsNodeQuery(stepNode);
+                if (stepVariableAssignmentsNode !== null) {
+                    var variableAssignmentsNode = stepVariableAssignmentsNode; ///
+                    variableAssignments = variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context);
+                }
+                return variableAssignments;
+            }
+        }
+    ]);
+    return VariableAssignments;
+}(), _define_property(_VariableAssignments, "name", "VariableAssignments"), _VariableAssignments));
+function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+    var VariableAssignments = _elements.default.VariableAssignments, type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context), array = arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context), string = stringFromArray(array, context), variableAssignments = new VariableAssignments(string, array);
+    return variableAssignments;
+}
+function stringFromArray(array, context) {
+    var variableAssignmentsString = array.reduce(function(variableAssignmentsString, variableAssignment) {
+        var variableAssignmentString = variableAssignment.getString();
+        variableAssignmentsString = variableAssignmentsString === null ? variableAssignmentString : "".concat(variableAssignmentsString, ", ").concat(variableAssignmentString);
+        return variableAssignmentsString;
+    }, null), string = variableAssignmentsString; ///
+    return string;
+}
+function typeFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+    var typeTerminalNode = typeTerminalNodeQuery(variableAssignmentsNode), typeTerminalNodeContent = typeTerminalNode.getContent(), type = typeTerminalNodeContent; ///
+    return type;
+}
+function arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context) {
+    var variableAssignmentNodes = variableAssignmentNodesQuery(variableAssignmentsNode), array = variableAssignmentNodes.map(function(variableAssignmentNode) {
+        var VariableAssignment = _elements.default.VariableAssignment, variableAssignment = VariableAssignment.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context);
+        return variableAssignment;
+    });
+    return array;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/assignments/variable.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\n\nimport { define } from \"../../elements\";\nimport { nodeQuery, nodesQuery } from \"../../utilities/query\";\n\nconst typeTerminalNodeQuery = nodeQuery(\"/variableAssignments/@type\"),\n      variableAssignmentNodesQuery = nodesQuery(\"/variableAssignments/variableAssignment\"),\n      stepVariableAssignmentsNodeQuery = nodeQuery(\"/step/variableAssignments\");\n\nexport default define(class VariableAssignments {\n  constructor(string, array) {\n    this.string = string;\n    this.array = array;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getArray() {\n    return this.array;\n  }\n\n  evaluate(context) {\n    const variableAssignmentsString = this.string; ///\n\n    context.trace(`Evaluating the '${variableAssignmentsString}' variable assignments...`);\n\n    this.array.forEach((variableAssignment) => {\n      variableAssignment.evaluate(context);\n    });\n\n    context.debug(`...evaluated the '${variableAssignmentsString}' variable assignments.`);\n  }\n\n  static name = \"VariableAssignments\";\n\n  static fromStepNode(stepNode, context) {\n    let variableAssignments = null;\n\n    const stepVariableAssignmentsNode = stepVariableAssignmentsNodeQuery(stepNode);\n\n    if (stepVariableAssignmentsNode !== null) {\n      const variableAssignmentsNode = stepVariableAssignmentsNode;  ///\n\n      variableAssignments = variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context);\n    }\n\n    return variableAssignments;\n  }\n});\n\nfunction variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {\n  const { VariableAssignments } = elements,\n        type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context),\n        array = arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context),\n        string = stringFromArray(array, context),\n        variableAssignments = new VariableAssignments(string, array);\n\n  return variableAssignments;\n}\n\nfunction stringFromArray(array, context) {\n  const variableAssignmentsString = array.reduce((variableAssignmentsString, variableAssignment) => {\n          const variableAssignmentString = variableAssignment.getString();\n\n          variableAssignmentsString = (variableAssignmentsString === null) ?\n                                        variableAssignmentString :\n                                         `${variableAssignmentsString}, ${variableAssignmentString}`;\n\n          return variableAssignmentsString;\n        }, null),\n        string = variableAssignmentsString; ///\n\n  return string;\n}\n\nfunction typeFromVariableAssignmentsNode(variableAssignmentsNode, context) {\n  const typeTerminalNode = typeTerminalNodeQuery(variableAssignmentsNode),\n        typeTerminalNodeContent = typeTerminalNode.getContent(),\n        type = typeTerminalNodeContent; ///\n\n  return type;\n}\n\nfunction arrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context) {\n  const variableAssignmentNodes = variableAssignmentNodesQuery(variableAssignmentsNode),\n        array = variableAssignmentNodes.map((variableAssignmentNode) => {\n          const { VariableAssignment } = elements,\n                variableAssignment = VariableAssignment.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context);\n\n          return variableAssignment;\n        });\n\n  return array;\n}\n"],"names":["typeTerminalNodeQuery","nodeQuery","variableAssignmentNodesQuery","nodesQuery","stepVariableAssignmentsNodeQuery","define","VariableAssignments","string","array","getString","getArray","evaluate","context","variableAssignmentsString","trace","forEach","variableAssignment","debug","fromStepNode","stepNode","variableAssignments","stepVariableAssignmentsNode","variableAssignmentsNode","variableAssignmentsFromVariableAssignmentsNode","name","elements","type","typeFromVariableAssignmentsNode","arrayFromTypeAndVariableAssignmentsNode","stringFromArray","reduce","variableAssignmentString","typeTerminalNode","typeTerminalNodeContent","getContent","variableAssignmentNodes","map","variableAssignmentNode","VariableAssignment","fromTypeAndVariableAssignmentNode"],"mappings":"AAAA;;;;+BAWA;;;eAAA;;;gEATqB;qBAGiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtC,IAAMA,wBAAwBC,IAAAA,gBAAS,EAAC,+BAClCC,+BAA+BC,IAAAA,iBAAU,EAAC,4CAC1CC,mCAAmCH,IAAAA,gBAAS,EAAC;IAEnD,WAAeI,IAAAA,gBAAM,wCAAC;aAAMC,oBACdC,MAAM,EAAEC,KAAK;gCADCF;QAExB,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACC,KAAK,GAAGA;;;;YAGfC,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,MAAM;YACpB;;;YAEAG,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,KAAK;YACnB;;;YAEAG,KAAAA;mBAAAA,SAAAA,SAASC,OAAO;gBACd,IAAMC,4BAA4B,IAAI,CAACN,MAAM,EAAE,GAAG;gBAElDK,QAAQE,KAAK,CAAC,AAAC,mBAA4C,OAA1BD,2BAA0B;gBAE3D,IAAI,CAACL,KAAK,CAACO,OAAO,CAAC,SAACC;oBAClBA,mBAAmBL,QAAQ,CAACC;gBAC9B;gBAEAA,QAAQK,KAAK,CAAC,AAAC,qBAA8C,OAA1BJ,2BAA0B;YAC/D;;;;YAIOK,KAAAA;mBAAP,SAAOA,aAAaC,QAAQ,EAAEP,OAAO;gBACnC,IAAIQ,sBAAsB;gBAE1B,IAAMC,8BAA8BjB,iCAAiCe;gBAErE,IAAIE,gCAAgC,MAAM;oBACxC,IAAMC,0BAA0BD,6BAA8B,GAAG;oBAEjED,sBAAsBG,+CAA+CD,yBAAyBV;gBAChG;gBAEA,OAAOQ;YACT;;;;KAdA,uCAAOI,QAAO;AAiBhB,SAASD,+CAA+CD,uBAAuB,EAAEV,OAAO;IACtF,IAAM,AAAEN,sBAAwBmB,iBAAQ,CAAhCnB,qBACFoB,OAAOC,gCAAgCL,yBAAyBV,UAChEJ,QAAQoB,wCAAwCF,MAAMJ,yBAAyBV,UAC/EL,SAASsB,gBAAgBrB,OAAOI,UAChCQ,sBAAsB,IAAId,oBAAoBC,QAAQC;IAE5D,OAAOY;AACT;AAEA,SAASS,gBAAgBrB,KAAK,EAAEI,OAAO;IACrC,IAAMC,4BAA4BL,MAAMsB,MAAM,CAAC,SAACjB,2BAA2BG;QACnE,IAAMe,2BAA2Bf,mBAAmBP,SAAS;QAE7DI,4BAA4B,AAACA,8BAA8B,OAC7BkB,2BACC,AAAC,GAAgCA,OAA9BlB,2BAA0B,MAA6B,OAAzBkB;QAEhE,OAAOlB;IACT,GAAG,OACHN,SAASM,2BAA2B,GAAG;IAE7C,OAAON;AACT;AAEA,SAASoB,gCAAgCL,uBAAuB,EAAEV,OAAO;IACvE,IAAMoB,mBAAmBhC,sBAAsBsB,0BACzCW,0BAA0BD,iBAAiBE,UAAU,IACrDR,OAAOO,yBAAyB,GAAG;IAEzC,OAAOP;AACT;AAEA,SAASE,wCAAwCF,IAAI,EAAEJ,uBAAuB,EAAEV,OAAO;IACrF,IAAMuB,0BAA0BjC,6BAA6BoB,0BACvDd,QAAQ2B,wBAAwBC,GAAG,CAAC,SAACC;QACnC,IAAM,AAAEC,qBAAuBb,iBAAQ,CAA/Ba,oBACFtB,qBAAqBsB,mBAAmBC,iCAAiC,CAACb,MAAMW,wBAAwBzB;QAE9G,OAAOI;IACT;IAEN,OAAOR;AACT"}

package/lib/element/block/return.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../../exception"));
+var _block = /*#__PURE__*/ _interop_require_default(require("../../context/block"));
+var _query = require("../../utilities/query");
+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
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _ReturnBlock;
+var stepNodesQuery = (0, _query.nodesQuery)("/returnBlock/step"), nonsenseNodesQuery = (0, _query.nodesQuery)("/returnBlock/nonsense"), expressionReturnBlockNodeQuery = (0, _query.nodeQuery)("/expression/returnBlock"), anonymousProcedureReturnBlockNodeQuery = (0, _query.nodeQuery)("/anonymousProcedure/returnBlock"), procedureDeclarationReturnBlockNodeQuery = (0, _query.nodeQuery)("/procedureDeclaration/returnBlock");
+var _default = (0, _elements.define)((_ReturnBlock = /*#__PURE__*/ function() {
+    function ReturnBlock(string, steps, nonsensical, returnStatement) {
+        _class_call_check(this, ReturnBlock);
+        this.string = string;
+        this.steps = steps;
+        this.nonsensical = nonsensical;
+        this.returnStatement = returnStatement;
+    }
+    _create_class(ReturnBlock, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getSteps",
+            value: function getSteps() {
+                return this.steps;
+            }
+        },
+        {
+            key: "isNonsensical",
+            value: function isNonsensical() {
+                return this.nonsensical;
+            }
+        },
+        {
+            key: "getReturnStatement",
+            value: function getReturnStatement() {
+                return this.returnStatement;
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(variables, context) {
+                if (context === undefined) {
+                    context = variables; ///
+                    variables = [];
+                }
+                if (this.nonsensical) {
+                    var message = "The return block is nonsensical.", exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                var blockContext = _block.default.fromVariables(variables, context);
+                context = blockContext; ///
+                this.steps.forEach(function(step) {
+                    step.evaluate(context);
+                });
+                var expression = this.returnStatement.evaluate(context);
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(expressionNode, context) {
+                var returnBlock = null;
+                var expressionReturnBlockNode = expressionReturnBlockNodeQuery(expressionNode);
+                if (expressionReturnBlockNode !== null) {
+                    var returnBlockNode = expressionReturnBlockNode; ///
+                    returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+                }
+                return returnBlock;
+            }
+        },
+        {
+            key: "fromAnonymousProcedureNode",
+            value: function fromAnonymousProcedureNode(anonymousProcedureNode, context) {
+                var anonymousProcedureReturnBlockNode = anonymousProcedureReturnBlockNodeQuery(anonymousProcedureNode), returnBlockNode = anonymousProcedureReturnBlockNode, returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+                return returnBlock;
+            }
+        },
+        {
+            key: "fromProcedureDeclarationNode",
+            value: function fromProcedureDeclarationNode(procedureDeclarationNode, context) {
+                var procedureDeclarationReturnBlockNode = procedureDeclarationReturnBlockNodeQuery(procedureDeclarationNode), returnBlockNode = procedureDeclarationReturnBlockNode, returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
+                return returnBlock;
+            }
+        }
+    ]);
+    return ReturnBlock;
+}(), _define_property(_ReturnBlock, "name", "ReturnBlock"), _ReturnBlock));
+function stringFromReturnStatement(returnStatement, context) {
+    var returnStatementString = returnStatement.getString(), string = "{ ... ".concat(returnStatementString, " }");
+    return string;
+}
+function stepsFromReturnBlockNode(returnBlockNode, context) {
+    var Step = _elements.default.Step, stepNodes = stepNodesQuery(returnBlockNode), steps = stepNodes.map(function(stepNode) {
+        var step = Step.fromStepNode(stepNode, context);
+        return step;
+    });
+    return steps;
+}
+function returnBlockFromReturnBlockNode(returnBlockNode, context) {
+    var ReturnBlock = _elements.default.ReturnBlock, ReturnStatement = _elements.default.ReturnStatement, returnStatement = ReturnStatement.fromReturnBlockNode(returnBlockNode, context), nonsensical = nonsensicalFromReturnBlockNode(returnBlockNode, context), steps = stepsFromReturnBlockNode(returnBlockNode, context), string = stringFromReturnStatement(returnStatement, context), returnBlock = new ReturnBlock(string, steps, nonsensical, returnStatement);
+    return returnBlock;
+}
+function nonsensicalFromReturnBlockNode(returnBlockNode, context) {
+    var nonsenseNodes = nonsenseNodesQuery(returnBlockNode), nonsenseNodesLength = nonsenseNodes.length, nonsensical = nonsenseNodesLength > 0;
+    return nonsensical;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/block/return.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\nimport Exception from \"../../exception\";\nimport BlockContext from \"../../context/block\";\n\nimport { define } from \"../../elements\";\nimport { nodeQuery, nodesQuery } from \"../../utilities/query\";\n\nconst stepNodesQuery = nodesQuery(\"/returnBlock/step\"),\n      nonsenseNodesQuery = nodesQuery(\"/returnBlock/nonsense\"),\n      expressionReturnBlockNodeQuery = nodeQuery(\"/expression/returnBlock\"),\n      anonymousProcedureReturnBlockNodeQuery = nodeQuery(\"/anonymousProcedure/returnBlock\"),\n      procedureDeclarationReturnBlockNodeQuery = nodeQuery(\"/procedureDeclaration/returnBlock\");\n\nexport default define(class ReturnBlock {\n  constructor(string, steps, nonsensical, returnStatement) {\n    this.string = string;\n    this.steps = steps;\n    this.nonsensical = nonsensical;\n    this.returnStatement = returnStatement;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getSteps() {\n    return this.steps;\n  }\n\n  isNonsensical() {\n    return this.nonsensical;\n  }\n\n  getReturnStatement() {\n    return this.returnStatement;\n  }\n\n  evaluate(variables, context) {\n    if (context === undefined) {\n      context = variables;  ///\n\n      variables = [];\n    }\n\n    if (this.nonsensical) {\n      const message = `The return block is nonsensical.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const blockContext = BlockContext.fromVariables(variables, context);\n\n    context = blockContext; ///\n\n    this.steps.forEach((step) => {\n      step.evaluate(context);\n    });\n\n    const expression = this.returnStatement.evaluate(context);\n\n    return expression;\n  }\n\n  static name = \"ReturnBlock\";\n\n  static fromExpressionNode(expressionNode, context) {\n    let returnBlock = null;\n\n    const expressionReturnBlockNode = expressionReturnBlockNodeQuery(expressionNode);\n\n    if (expressionReturnBlockNode !== null) {\n      const returnBlockNode = expressionReturnBlockNode;  ///\n\n      returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);\n    }\n\n    return returnBlock;\n  }\n\n  static fromAnonymousProcedureNode(anonymousProcedureNode, context) {\n    const anonymousProcedureReturnBlockNode = anonymousProcedureReturnBlockNodeQuery(anonymousProcedureNode),\n          returnBlockNode = anonymousProcedureReturnBlockNode,  ///\n          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);\n\n    return returnBlock;\n  }\n\n  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {\n    const procedureDeclarationReturnBlockNode = procedureDeclarationReturnBlockNodeQuery(procedureDeclarationNode),\n          returnBlockNode = procedureDeclarationReturnBlockNode,  ///\n          returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);\n\n    return returnBlock;\n  }\n});\n\nfunction stringFromReturnStatement(returnStatement, context) {\n  const returnStatementString = returnStatement.getString(),\n        string = `{ ... ${returnStatementString} }`;\n\n  return string;\n}\n\nfunction stepsFromReturnBlockNode(returnBlockNode, context) {\n  const { Step } = elements,\n        stepNodes = stepNodesQuery(returnBlockNode),\n        steps = stepNodes.map((stepNode) => {\n          const step = Step.fromStepNode(stepNode, context);\n\n          return step;\n        });\n\n  return steps;\n}\n\nfunction returnBlockFromReturnBlockNode(returnBlockNode, context) {\n  const { ReturnBlock, ReturnStatement } = elements,\n        returnStatement = ReturnStatement.fromReturnBlockNode(returnBlockNode, context),\n        nonsensical = nonsensicalFromReturnBlockNode(returnBlockNode, context),\n        steps = stepsFromReturnBlockNode(returnBlockNode, context),\n        string = stringFromReturnStatement(returnStatement, context),\n        returnBlock = new ReturnBlock(string, steps, nonsensical, returnStatement);\n\n  return returnBlock;\n}\n\nfunction nonsensicalFromReturnBlockNode(returnBlockNode, context) {\n  const nonsenseNodes = nonsenseNodesQuery(returnBlockNode),\n        nonsenseNodesLength = nonsenseNodes.length,\n        nonsensical = (nonsenseNodesLength > 0);\n\n  return nonsensical;\n}\n"],"names":["stepNodesQuery","nodesQuery","nonsenseNodesQuery","expressionReturnBlockNodeQuery","nodeQuery","anonymousProcedureReturnBlockNodeQuery","procedureDeclarationReturnBlockNodeQuery","define","ReturnBlock","string","steps","nonsensical","returnStatement","getString","getSteps","isNonsensical","getReturnStatement","evaluate","variables","context","undefined","message","exception","Exception","fromMessage","blockContext","BlockContext","fromVariables","forEach","step","expression","fromExpressionNode","expressionNode","returnBlock","expressionReturnBlockNode","returnBlockNode","returnBlockFromReturnBlockNode","fromAnonymousProcedureNode","anonymousProcedureNode","anonymousProcedureReturnBlockNode","fromProcedureDeclarationNode","procedureDeclarationNode","procedureDeclarationReturnBlockNode","name","stringFromReturnStatement","returnStatementString","stepsFromReturnBlockNode","Step","elements","stepNodes","map","stepNode","fromStepNode","ReturnStatement","fromReturnBlockNode","nonsensicalFromReturnBlockNode","nonsenseNodes","nonsenseNodesLength","length"],"mappings":"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"}

package/lib/element/comparison.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../exception"));
+var _query = require("../utilities/query");
+var _constants = require("../constants");
+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
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Comparison;
+var terminalNodeQuery = (0, _query.nodeQuery)("/comparison/@*"), leftExpressionNodeQuery = (0, _query.nodeQuery)("/comparison/expression[0]"), rightExpressionNodeQuery = (0, _query.nodeQuery)("/comparison/expression[1]"), expressionComparisonNodeQuery = (0, _query.nodeQuery)("/expression/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 expression;
+                var comparisonString = this.string; ///
+                context.trace("Evaluating the '".concat(comparisonString, "' comparison..."));
+                var leftExpression = this.leftExpression.evaluate(context), rightExpression = this.rightExpression.evaluate(context), leftExpressionType = leftExpression.getType(), rightExpressionType = rightExpression.getType();
+                if (leftExpressionType !== rightExpressionType) {
+                    var leftExpressionString = leftExpression.asString(context), rightExpressionString = rightExpression.asString(context), message = "The ".concat(leftExpressionString, " left expression's type is '").concat(leftExpressionType, "' whereas the ").concat(rightExpressionString, " right expression's type is '").concat(rightExpressionType, "'."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                var leftExpressionEqualToRightExpression = leftExpression.isEqualTo(rightExpression);
+                var boolean = leftExpressionEqualToRightExpression; ///
+                if (this.negated) {
+                    boolean = !boolean; ///
+                }
+                var Expression = _elements.default.Expression;
+                expression = Expression.fromBoolean(boolean, context);
+                context.debug("...evaluated the '".concat(comparisonString, "' comparison."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(valudNode, context) {
+                var comparison = null;
+                var expressionComparisonNode = expressionComparisonNodeQuery(valudNode);
+                if (expressionComparisonNode !== null) {
+                    var comparisonNode = expressionComparisonNode; ///
+                    comparison = comparisonFromComparisonNode(comparisonNode, context);
+                }
+                return comparison;
+            }
+        }
+    ]);
+    return Comparison;
+}(), _define_property(_Comparison, "name", "Comparison"), _Comparison));
+function negatedFromComparisonNode(comparisonNode) {
+    var terminalNode = terminalNodeQuery(comparisonNode), terminalNodeContent = terminalNode.getContent(), negated = terminalNodeContent !== _constants.EQUAL_TO;
+    return negated;
+}
+function comparisonFromComparisonNode(comparisonNode, context) {
+    var Expression = _elements.default.Expression, Comparison = _elements.default.Comparison, leftExpressionNode = leftExpressionNodeQuery(comparisonNode), rightExpressionNode = rightExpressionNodeQuery(comparisonNode), rightExpression = Expression.fromExpressionNode(rightExpressionNode, context), leftExpression = Expression.fromExpressionNode(leftExpressionNode, context), negated = negatedFromComparisonNode(comparisonNode, context), string = stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context), comparison = new Comparison(string, negated, leftExpression, rightExpression);
+    return comparison;
+}
+function stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context) {
+    var operatorString = negated ? _constants.EQUAL_TO : _constants.NOT_EQUAL_TO, leftExpressionString = leftExpression.asString(context), rightExpressionString = rightExpression.asString(context), string = "".concat(leftExpressionString, " ").concat(operatorString, " ").concat(rightExpressionString);
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/comparison.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\nimport Exception from \"../exception\";\n\nimport { define } from \"../elements\";\nimport { nodeQuery } from \"../utilities/query\";\nimport { EQUAL_TO, NOT_EQUAL_TO } from \"../constants\";\n\nconst terminalNodeQuery = nodeQuery(\"/comparison/@*\"),\n      leftExpressionNodeQuery = nodeQuery(\"/comparison/expression[0]\"),\n      rightExpressionNodeQuery = nodeQuery(\"/comparison/expression[1]\"),\n      expressionComparisonNodeQuery = nodeQuery(\"/expression/comparison\");\n\nexport default define(class Comparison {\n  constructor(string, negated, leftExpression, rightExpression) {\n    this.string = string;\n    this.negated = negated;\n    this.leftExpression = leftExpression;\n    this.rightExpression = rightExpression;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  isNegated() {\n    return this.negated;\n  }\n\n  getLeftExpression() {\n    return this.leftExpression;\n  }\n\n  getRightExpression() {\n    return this.rightExpression;\n  }\n\n  evaluate(context) {\n    let expression;\n\n    const comparisonString = this.string; ///\n\n    context.trace(`Evaluating the '${comparisonString}' comparison...`);\n\n    const leftExpression = this.leftExpression.evaluate(context),\n          rightExpression = this.rightExpression.evaluate(context),\n          leftExpressionType = leftExpression.getType(),\n          rightExpressionType = rightExpression.getType();\n\n    if (leftExpressionType !== rightExpressionType) {\n      const leftExpressionString = leftExpression.asString(context),\n            rightExpressionString = rightExpression.asString(context),\n            message = `The ${leftExpressionString} left expression's type is '${leftExpressionType}' whereas the ${rightExpressionString} right expression's type is '${rightExpressionType}'.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const leftExpressionEqualToRightExpression = leftExpression.isEqualTo(rightExpression);\n\n    let boolean = leftExpressionEqualToRightExpression; ///\n\n    if (this.negated) {\n      boolean = !boolean; ///\n    }\n\n    const { Expression } = elements;\n\n    expression = Expression.fromBoolean(boolean, context);\n\n    context.debug(`...evaluated the '${comparisonString}' comparison.`);\n\n    return expression;\n  }\n\n  static name = \"Comparison\";\n\n  static fromExpressionNode(valudNode, context) {\n    let comparison = null;\n\n    const expressionComparisonNode = expressionComparisonNodeQuery(valudNode);\n\n    if (expressionComparisonNode !== null) {\n      const comparisonNode = expressionComparisonNode; ///\n\n      comparison = comparisonFromComparisonNode(comparisonNode, context);\n    }\n\n    return comparison;\n  }\n});\n\nfunction negatedFromComparisonNode(comparisonNode) {\n  const terminalNode = terminalNodeQuery(comparisonNode),\n        terminalNodeContent = terminalNode.getContent(),\n        negated = (terminalNodeContent !== EQUAL_TO);\n\n  return negated;\n}\n\nfunction comparisonFromComparisonNode(comparisonNode, context) {\n  const { Expression, Comparison } = elements,\n        leftExpressionNode = leftExpressionNodeQuery(comparisonNode),\n        rightExpressionNode = rightExpressionNodeQuery(comparisonNode),\n        rightExpression = Expression.fromExpressionNode(rightExpressionNode, context),\n        leftExpression = Expression.fromExpressionNode(leftExpressionNode, context),\n        negated = negatedFromComparisonNode(comparisonNode, context),\n        string = stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context),\n        comparison = new Comparison(string, negated, leftExpression, rightExpression);\n\n  return comparison;\n}\n\nfunction stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context) {\n  const operatorString = negated ?\n                           EQUAL_TO :\n                            NOT_EQUAL_TO,\n        leftExpressionString = leftExpression.asString(context),\n        rightExpressionString = rightExpression.asString(context),\n        string = `${leftExpressionString} ${operatorString} ${rightExpressionString}`;\n\n  return string;\n}\n"],"names":["terminalNodeQuery","nodeQuery","leftExpressionNodeQuery","rightExpressionNodeQuery","expressionComparisonNodeQuery","define","Comparison","string","negated","leftExpression","rightExpression","getString","isNegated","getLeftExpression","getRightExpression","evaluate","context","expression","comparisonString","trace","leftExpressionType","getType","rightExpressionType","leftExpressionString","asString","rightExpressionString","message","exception","Exception","fromMessage","leftExpressionEqualToRightExpression","isEqualTo","boolean","Expression","elements","fromBoolean","debug","fromExpressionNode","valudNode","comparison","expressionComparisonNode","comparisonNode","comparisonFromComparisonNode","name","negatedFromComparisonNode","terminalNode","terminalNodeContent","getContent","EQUAL_TO","leftExpressionNode","rightExpressionNode","stringFromNegatedLeftExpressionAndRightExpression","operatorString","NOT_EQUAL_TO"],"mappings":"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"}