occam-furtle 2.0.279 → 2.0.282

package/lib/element/procedure/anonymous.js

@@ -0,0 +1,181 @@
+"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 _procedure = require("../procedure");
+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 _AnonymousProcedure;
+var typeTerminalNodeQuery = (0, _query.nodeQuery)("/anonymousProcedure/@type"), someAnonymousProcedureNodeQuery = (0, _query.nodeQuery)("/some/anonymousProcedure"), everyAnonymousProcedureNodeQuery = (0, _query.nodeQuery)("/every/anonymousProcedure"), reduceAnonymousProcedureNodeQuery = (0, _query.nodeQuery)("/reduce/anonymousProcedure");
+var _default = (0, _elements.define)((_AnonymousProcedure = /*#__PURE__*/ function() {
+    function AnonymousProcedure(string, type, parameters, returnBlock) {
+        _class_call_check(this, AnonymousProcedure);
+        this.string = string;
+        this.type = type;
+        this.parameters = parameters;
+        this.returnBlock = returnBlock;
+    }
+    _create_class(AnonymousProcedure, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "getParameters",
+            value: function getParameters() {
+                return this.paramters;
+            }
+        },
+        {
+            key: "getReturnBlock",
+            value: function getReturnBlock() {
+                return this.returnBlock;
+            }
+        },
+        {
+            key: "call",
+            value: function call(expressions, context) {
+                var anonymousProcedureString = this.string; ///
+                context.trace("Calling the '".concat(anonymousProcedureString, "' anonymous procedure..."));
+                this.parameters.matchExpressions(expressions, context);
+                var variables = (0, _procedure.variablesFromExpressionsAndParameters)(expressions, this.parameters, context), expression = this.returnBlock.evaluate(variables, context), expressionType = expression.getType();
+                if (this.type !== expressionType) {
+                    var expressionString = expression.asString(context), message = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type and the '").concat(anonymousProcedureString, "' anonymous procedure's '").concat(this.type, "' type  do not match."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                context.debug("...called the '".concat(anonymousProcedureString, "' anonymous procedure."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromSomeNode",
+            value: function fromSomeNode(someNode, context) {
+                var someAnonymousProcedureNode = someAnonymousProcedureNodeQuery(someNode), anonymousProcedureNode = someAnonymousProcedureNode, anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+                return anonymousProcedure;
+            }
+        },
+        {
+            key: "fromEveryNode",
+            value: function fromEveryNode(everyNode, context) {
+                var everyAnonymousProcedureNode = everyAnonymousProcedureNodeQuery(everyNode), anonymousProcedureNode = everyAnonymousProcedureNode, anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+                return anonymousProcedure;
+            }
+        },
+        {
+            key: "fromReduceNode",
+            value: function fromReduceNode(reduceNode, context) {
+                var reduceAnonymousProcedureNode = reduceAnonymousProcedureNodeQuery(reduceNode), anonymousProcedureNode = reduceAnonymousProcedureNode, anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+                return anonymousProcedure;
+            }
+        }
+    ]);
+    return AnonymousProcedure;
+}(), _define_property(_AnonymousProcedure, "name", "AnonymousProcedure"), _AnonymousProcedure));
+function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
+    var Parameters = _elements.default.Parameters, ReturnBlock = _elements.default.ReturnBlock, AnonymousProcedure = _elements.default.AnonymousProcedure, returnBlock = ReturnBlock.fromAnonymousProcedureNode(anonymousProcedureNode, context), parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context), type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context), string = stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context), anonymousProcedure = new AnonymousProcedure(string, type, parameters, returnBlock);
+    return anonymousProcedure;
+}
+function stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context) {
+    var typeString = type, parametersString = parameters.getString(), returnBlockString = returnBlock.getString(), string = "".concat(typeString, " (").concat(parametersString, ") ").concat(returnBlockString);
+    return string;
+}
+function typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context) {
+    var typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode), typeTerminalNodeContent = typeTerminalNode.getContent(), type = typeTerminalNodeContent; ///
+    return type;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/procedure/anonymous.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\nimport Exception from \"../../exception\";\n\nimport { define } from \"../../elements\";\nimport { nodeQuery } from \"../../utilities/query\";\nimport { variablesFromExpressionsAndParameters } from \"../procedure\";\n\nconst typeTerminalNodeQuery = nodeQuery(\"/anonymousProcedure/@type\"),\n      someAnonymousProcedureNodeQuery = nodeQuery(\"/some/anonymousProcedure\"),\n      everyAnonymousProcedureNodeQuery = nodeQuery(\"/every/anonymousProcedure\"),\n      reduceAnonymousProcedureNodeQuery = nodeQuery(\"/reduce/anonymousProcedure\");\n\nexport default define(class AnonymousProcedure {\n  constructor(string, type, parameters, returnBlock) {\n    this.string = string;\n    this.type = type;\n    this.parameters = parameters;\n    this.returnBlock = returnBlock;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getParameters() {\n    return this.paramters;\n  }\n\n  getReturnBlock() {\n    return this.returnBlock;\n  }\n\n  call(expressions, context) {\n    const anonymousProcedureString = this.string; ///\n\n    context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);\n\n    this.parameters.matchExpressions(expressions, context);\n\n    const variables = variablesFromExpressionsAndParameters(expressions, this.parameters, context),\n          expression = this.returnBlock.evaluate(variables, context),\n          expressionType = expression.getType();\n\n    if (this.type !== expressionType) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's '${expressionType}' type and the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type  do not match.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);\n\n    return expression;\n  }\n\n  static name = \"AnonymousProcedure\";\n\n  static fromSomeNode(someNode, context) {\n    const someAnonymousProcedureNode = someAnonymousProcedureNodeQuery(someNode),\n          anonymousProcedureNode = someAnonymousProcedureNode,  ///\n          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);\n\n    return anonymousProcedure;\n  }\n\n  static fromEveryNode(everyNode, context) {\n    const everyAnonymousProcedureNode = everyAnonymousProcedureNodeQuery(everyNode),\n          anonymousProcedureNode = everyAnonymousProcedureNode,  ///\n          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);\n\n    return anonymousProcedure;\n  }\n\n  static fromReduceNode(reduceNode, context) {\n    const reduceAnonymousProcedureNode = reduceAnonymousProcedureNodeQuery(reduceNode),\n          anonymousProcedureNode = reduceAnonymousProcedureNode,  ///\n          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);\n\n    return anonymousProcedure;\n  }\n});\n\nfunction anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {\n  const { Parameters, ReturnBlock, AnonymousProcedure } = elements,\n        returnBlock = ReturnBlock.fromAnonymousProcedureNode(anonymousProcedureNode, context),\n        parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context),\n        type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),\n        string = stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context),\n        anonymousProcedure = new AnonymousProcedure(string, type, parameters, returnBlock);\n\n  return anonymousProcedure;\n}\n\nfunction stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context) {\n  const typeString = type,  ///\n        parametersString = parameters.getString(),\n        returnBlockString = returnBlock.getString(),\n        string = `${typeString} (${parametersString}) ${returnBlockString}`;\n\n  return string;\n}\n\nfunction typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context) {\n  const typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),\n        typeTerminalNodeContent = typeTerminalNode.getContent(),\n        type = typeTerminalNodeContent; ///\n\n  return type;\n}\n"],"names":["typeTerminalNodeQuery","nodeQuery","someAnonymousProcedureNodeQuery","everyAnonymousProcedureNodeQuery","reduceAnonymousProcedureNodeQuery","define","AnonymousProcedure","string","type","parameters","returnBlock","getString","getType","getParameters","paramters","getReturnBlock","call","expressions","context","anonymousProcedureString","trace","matchExpressions","variables","variablesFromExpressionsAndParameters","expression","evaluate","expressionType","expressionString","asString","message","exception","Exception","fromMessage","debug","fromSomeNode","someNode","someAnonymousProcedureNode","anonymousProcedureNode","anonymousProcedure","anonymousProcedureFromAnonymousProcedureNode","fromEveryNode","everyNode","everyAnonymousProcedureNode","fromReduceNode","reduceNode","reduceAnonymousProcedureNode","name","Parameters","elements","ReturnBlock","fromAnonymousProcedureNode","typeFromProcedureAnonymousProcedureNode","stringFromTypeParametersAndReturnBlock","typeString","parametersString","returnBlockString","typeTerminalNode","typeTerminalNodeContent","getContent"],"mappings":"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"}

package/lib/element/procedure.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return _default;
+    },
+    get variablesFromExpressionsAndParameters () {
+        return variablesFromExpressionsAndParameters;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../exception"));
+var _query = require("../utilities/query");
+var _types = require("../types");
+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 _Procedure;
+var typeTerminalNodeQuery = (0, _query.nodeQuery)("/procedureDeclaration/@type");
+var _default = (0, _elements.define)((_Procedure = /*#__PURE__*/ function() {
+    function Procedure(string, type, label, parameters, returnBlock) {
+        _class_call_check(this, Procedure);
+        this.string = string;
+        this.type = type;
+        this.label = label;
+        this.parameters = parameters;
+        this.returnBlock = returnBlock;
+    }
+    _create_class(Procedure, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "getLabel",
+            value: function getLabel() {
+                return this.label;
+            }
+        },
+        {
+            key: "getParameters",
+            value: function getParameters() {
+                return this.parameters;
+            }
+        },
+        {
+            key: "getReturnBlock",
+            value: function getReturnBlock() {
+                return this.returnBlock;
+            }
+        },
+        {
+            key: "isBoolean",
+            value: function isBoolean() {
+                var typeBooleanType = this.type === _types.BOOLEAN_TYPE, boolean = typeBooleanType; ///
+                return boolean;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.label.getName();
+            }
+        },
+        {
+            key: "matchName",
+            value: function matchName(name) {
+                return this.label.matchName(name);
+            }
+        },
+        {
+            key: "call",
+            value: function call(expressions, context) {
+                var procedureString = this.string; ///
+                context.trace("Calling the '".concat(procedureString, "' procedure..."));
+                this.parameters.matchExpressions(expressions, context);
+                var variables = variablesFromExpressionsAndParameters(expressions, this.parameters, context), expression = this.returnBlock.evaluate(variables, context), expressionType = expression.getType();
+                if (this.type !== expressionType) {
+                    var expressionString = expression.asString(context), message = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type and the '").concat(procedureString, "' procedure's '").concat(this.type, "' type  do not match."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                context.debug("...called the '".concat(procedureString, "' procedure."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromProcedureDeclarationNode",
+            value: function fromProcedureDeclarationNode(procedureDeclarationNode, context) {
+                var procedureDeclaration = procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context);
+                return procedureDeclaration;
+            }
+        }
+    ]);
+    return Procedure;
+}(), _define_property(_Procedure, "name", "Procedure"), _Procedure));
+function variablesFromExpressionsAndParameters(expressions, parameters, context) {
+    var variables = [];
+    expressions.forEachExpression(function(expression, index) {
+        var Variable = _elements.default.Variable, parameter = parameters.getParameter(index);
+        if (parameter !== null) {
+            var variable = Variable.fromExpressionAndParameter(expression, parameter, context);
+            variables.push(variable);
+        }
+    });
+    return variables;
+}
+function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+    var Label = _elements.default.Label, ReturnBlock = _elements.default.ReturnBlock, Parameters = _elements.default.Parameters, Procedure = _elements.default.Procedure, returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context), parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context), label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context), type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context), string = stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock), procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
+    return procedureDeclaration;
+}
+function stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock) {
+    var typeString = type, labelString = label.getString(), parametersString = parameters.getString(), returnBlockString = returnBlock.getString(), string = "".concat(typeString, " ").concat(labelString, "(").concat(parametersString, ") ").concat(returnBlockString);
+    return string;
+}
+function typeFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+    var typeTerminalNode = typeTerminalNodeQuery(procedureDeclarationNode), typeTerminalNodeContent = typeTerminalNode.getContent(), type = typeTerminalNodeContent; ///
+    return type;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/procedure.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\nimport Exception from \"../exception\";\n\nimport { define } from \"../elements\";\nimport { nodeQuery } from \"../utilities/query\";\nimport { BOOLEAN_TYPE } from \"../types\";\n\nconst typeTerminalNodeQuery = nodeQuery(\"/procedureDeclaration/@type\");\n\nexport default define(class Procedure {\n  constructor(string, type, label, parameters, returnBlock) {\n    this.string = string;\n    this.type = type;\n    this.label = label;\n    this.parameters = parameters;\n    this.returnBlock = returnBlock;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getLabel() {\n    return this.label;\n  }\n\n  getParameters() {\n    return this.parameters;\n  }\n\n  getReturnBlock() {\n    return this.returnBlock;\n  }\n\n  isBoolean() {\n    const typeBooleanType = (this.type === BOOLEAN_TYPE),\n          boolean = typeBooleanType;  ///\n\n    return boolean;\n  }\n\n  getName() { return this.label.getName(); }\n\n  matchName(name) { return this.label.matchName(name); }\n\n  call(expressions, context) {\n    const procedureString = this.string;  ///\n\n    context.trace(`Calling the '${procedureString}' procedure...`);\n\n    this.parameters.matchExpressions(expressions, context);\n\n    const variables = variablesFromExpressionsAndParameters(expressions, this.parameters, context),\n          expression = this.returnBlock.evaluate(variables, context),\n          expressionType = expression.getType();\n\n    if (this.type !== expressionType) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's '${expressionType}' type and the '${procedureString}' procedure's '${this.type}' type  do not match.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    context.debug(`...called the '${procedureString}' procedure.`);\n\n    return expression;\n  }\n\n  static name = \"Procedure\";\n\n  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {\n    const procedureDeclaration = procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context);\n\n    return procedureDeclaration;\n  }\n});\n\nexport function variablesFromExpressionsAndParameters(expressions, parameters, context) {\n  const variables = [];\n\n  expressions.forEachExpression((expression, index) => {\n    const { Variable } = elements,\n          parameter = parameters.getParameter(index);\n\n    if (parameter !== null) {\n      const variable = Variable.fromExpressionAndParameter(expression, parameter, context);\n\n      variables.push(variable);\n    }\n  });\n\n  return variables;\n}\n\nfunction procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {\n  const { Label, ReturnBlock, Parameters, Procedure } = elements,\n        returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),\n        parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),\n        label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),\n        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),\n        string = stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),\n        procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);\n\n  return procedureDeclaration;\n}\n\nfunction stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock) {\n  const typeString = type,  ///\n        labelString = label.getString(),\n        parametersString = parameters.getString(),\n        returnBlockString = returnBlock.getString(),\n        string = `${typeString} ${labelString}(${parametersString}) ${returnBlockString}`;\n\n  return string;\n}\n\nfunction typeFromProcedureDeclarationNode(procedureDeclarationNode, context) {\n  const typeTerminalNode = typeTerminalNodeQuery(procedureDeclarationNode),\n        typeTerminalNodeContent = typeTerminalNode.getContent(),\n        type = typeTerminalNodeContent; ///\n\n  return type;\n}\n"],"names":["variablesFromExpressionsAndParameters","typeTerminalNodeQuery","nodeQuery","define","Procedure","string","type","label","parameters","returnBlock","getString","getType","getLabel","getParameters","getReturnBlock","isBoolean","typeBooleanType","BOOLEAN_TYPE","boolean","getName","matchName","name","call","expressions","context","procedureString","trace","matchExpressions","variables","expression","evaluate","expressionType","expressionString","asString","message","exception","Exception","fromMessage","debug","fromProcedureDeclarationNode","procedureDeclarationNode","procedureDeclaration","procedureDeclarationFromProcedureDeclarationNode","forEachExpression","index","Variable","elements","parameter","getParameter","variable","fromExpressionAndParameter","push","Label","ReturnBlock","Parameters","typeFromProcedureDeclarationNode","stringFromTypeLabelParametersAndReturnBlock","typeString","labelString","parametersString","returnBlockString","typeTerminalNode","typeTerminalNodeContent","getContent"],"mappings":"AAAA;;;;;;;;;;;QAWA;eAAA;;QAyEgBA;eAAAA;;;gEAlFK;gEACC;qBAGI;qBACG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7B,IAAMC,wBAAwBC,IAAAA,gBAAS,EAAC;IAExC,WAAeC,IAAAA,gBAAM,8BAAC;aAAMC,UACdC,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAEC,WAAW;gCAD9BL;QAExB,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,KAAK,GAAGA;QACb,IAAI,CAACC,UAAU,GAAGA;QAClB,IAAI,CAACC,WAAW,GAAGA;;;;YAGrBC,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACL,MAAM;YACpB;;;YAEAM,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACL,IAAI;YAClB;;;YAEAM,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACL,KAAK;YACnB;;;YAEAM,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACL,UAAU;YACxB;;;YAEAM,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACL,WAAW;YACzB;;;YAEAM,KAAAA;mBAAAA,SAAAA;gBACE,IAAMC,kBAAmB,IAAI,CAACV,IAAI,KAAKW,mBAAY,EAC7CC,UAAUF,iBAAkB,GAAG;gBAErC,OAAOE;YACT;;;YAEAC,KAAAA;mBAAAA,SAAAA;gBAAY,OAAO,IAAI,CAACZ,KAAK,CAACY,OAAO;YAAI;;;YAEzCC,KAAAA;mBAAAA,SAAAA,UAAUC,IAAI;gBAAI,OAAO,IAAI,CAACd,KAAK,CAACa,SAAS,CAACC;YAAO;;;YAErDC,KAAAA;mBAAAA,SAAAA,KAAKC,WAAW,EAAEC,OAAO;gBACvB,IAAMC,kBAAkB,IAAI,CAACpB,MAAM,EAAG,GAAG;gBAEzCmB,QAAQE,KAAK,CAAC,AAAC,gBAA+B,OAAhBD,iBAAgB;gBAE9C,IAAI,CAACjB,UAAU,CAACmB,gBAAgB,CAACJ,aAAaC;gBAE9C,IAAMI,YAAY5B,sCAAsCuB,aAAa,IAAI,CAACf,UAAU,EAAEgB,UAChFK,aAAa,IAAI,CAACpB,WAAW,CAACqB,QAAQ,CAACF,WAAWJ,UAClDO,iBAAiBF,WAAWlB,OAAO;gBAEzC,IAAI,IAAI,CAACL,IAAI,KAAKyB,gBAAgB;oBAChC,IAAMC,mBAAmBH,WAAWI,QAAQ,CAACT,UACvCU,UAAU,AAAC,OAAwCH,OAAlCC,kBAAiB,mBAAkDP,OAAjCM,gBAAe,oBAAmD,OAAjCN,iBAAgB,mBAA2B,OAAV,IAAI,CAACnB,IAAI,EAAC,0BAC/H6B,YAAYC,kBAAS,CAACC,WAAW,CAACH;oBAExC,MAAMC;gBACR;gBAEAX,QAAQc,KAAK,CAAC,AAAC,kBAAiC,OAAhBb,iBAAgB;gBAEhD,OAAOI;YACT;;;;YAIOU,KAAAA;mBAAP,SAAOA,6BAA6BC,wBAAwB,EAAEhB,OAAO;gBACnE,IAAMiB,uBAAuBC,iDAAiDF,0BAA0BhB;gBAExG,OAAOiB;YACT;;;;KANA,6BAAOpB,QAAO;AAST,SAASrB,sCAAsCuB,WAAW,EAAEf,UAAU,EAAEgB,OAAO;IACpF,IAAMI,YAAY,EAAE;IAEpBL,YAAYoB,iBAAiB,CAAC,SAACd,YAAYe;QACzC,IAAM,AAAEC,WAAaC,iBAAQ,CAArBD,UACFE,YAAYvC,WAAWwC,YAAY,CAACJ;QAE1C,IAAIG,cAAc,MAAM;YACtB,IAAME,WAAWJ,SAASK,0BAA0B,CAACrB,YAAYkB,WAAWvB;YAE5EI,UAAUuB,IAAI,CAACF;QACjB;IACF;IAEA,OAAOrB;AACT;AAEA,SAASc,iDAAiDF,wBAAwB,EAAEhB,OAAO;IACzF,IAAQ4B,QAA8CN,iBAAQ,CAAtDM,OAAOC,cAAuCP,iBAAQ,CAA/CO,aAAaC,aAA0BR,iBAAQ,CAAlCQ,YAAYlD,YAAc0C,iBAAQ,CAAtB1C,WAClCK,cAAc4C,YAAYd,4BAA4B,CAACC,0BAA0BhB,UACjFhB,aAAa8C,WAAWf,4BAA4B,CAACC,0BAA0BhB,UAC/EjB,QAAQ6C,MAAMb,4BAA4B,CAACC,0BAA0BhB,UACrElB,OAAOiD,iCAAiCf,0BAA0BhB,UAClEnB,SAASmD,4CAA4ClD,MAAMC,OAAOC,YAAYC,cAC9EgC,uBAAuB,IAAIrC,UAAUC,QAAQC,MAAMC,OAAOC,YAAYC;IAE5E,OAAOgC;AACT;AAEA,SAASe,4CAA4ClD,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAEC,WAAW;IACvF,IAAMgD,aAAanD,MACboD,cAAcnD,MAAMG,SAAS,IAC7BiD,mBAAmBnD,WAAWE,SAAS,IACvCkD,oBAAoBnD,YAAYC,SAAS,IACzCL,SAAS,AAAC,GAAgBqD,OAAdD,YAAW,KAAkBE,OAAfD,aAAY,KAAwBE,OAArBD,kBAAiB,MAAsB,OAAlBC;IAEpE,OAAOvD;AACT;AAEA,SAASkD,iCAAiCf,wBAAwB,EAAEhB,OAAO;IACzE,IAAMqC,mBAAmB5D,sBAAsBuC,2BACzCsB,0BAA0BD,iBAAiBE,UAAU,IACrDzD,OAAOwD,yBAAyB,GAAG;IAEzC,OAAOxD;AACT"}

package/lib/element/procedureCall.js

@@ -0,0 +1,166 @@
+"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");
+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 _ProcedureCall;
+var expressionProcedureCallNodeQuery = (0, _query.nodeQuery)("/expression/procedureCall");
+var _default = (0, _elements.define)((_ProcedureCall = /*#__PURE__*/ function() {
+    function ProcedureCall(string, reference, expressions) {
+        _class_call_check(this, ProcedureCall);
+        this.string = string;
+        this.reference = reference;
+        this.expressions = expressions;
+    }
+    _create_class(ProcedureCall, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getReference",
+            value: function getReference() {
+                return this.reference;
+            }
+        },
+        {
+            key: "getExpressions",
+            value: function getExpressions() {
+                return this.expressions;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.reference.getName();
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var procedureCallString = this.string; ///
+                context.trace("Evaluating the '".concat(procedureCallString, "' procedure call..."));
+                var name = this.getName(), procedurePresent = context.isProcedurePresentByName(name);
+                if (!procedurePresent) {
+                    var message = "The '".concat(procedureCallString, " procedure is not present.'"), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                var procedure = context.findProcedureByName(name), expressions = this.expressions.evaluate(context), expression = procedure.call(expressions, context);
+                context.debug("...evaluated the '".concat(procedureCallString, "' procedure call."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(expressionNode, context) {
+                var procedureCall = null;
+                var expressionProcedureCallNode = expressionProcedureCallNodeQuery(expressionNode);
+                if (expressionProcedureCallNode !== null) {
+                    var procedureCallNode = expressionProcedureCallNode; ///
+                    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+                }
+                return procedureCall;
+            }
+        }
+    ]);
+    return ProcedureCall;
+}(), _define_property(_ProcedureCall, "name", "ProcedureCall"), _ProcedureCall));
+function procedureCallFromProcedureCallNode(procedureCallNode, context) {
+    var Reference = _elements.default.Reference, Expressions = _elements.default.Expressions, ProcedureCall = _elements.default.ProcedureCall, expressions = Expressions.fromProcedureCallNode(procedureCallNode, context), reference = Reference.fromProcedureCallNode(procedureCallNode, context), string = stringFromReferenceAndExpressions(reference, expressions, context), procedureCall = new ProcedureCall(string, reference, expressions);
+    return procedureCall;
+}
+function stringFromReferenceAndExpressions(reference, expressions, context) {
+    var expressionsString = expressions.getString(), referenceString = reference.getString(), string = "".concat(referenceString, "(").concat(expressionsString, ")");
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,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