occam-furtle 2.0.279 → 2.0.282

package/lib/element/parameter.js

@@ -0,0 +1,165 @@
+"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 _Parameter;
+var terminalNodesQuery = (0, _query.nodesQuery)("/parameter/@*"), nameTerminalNodeQuery = (0, _query.nodeQuery)("/parameter/@name"), typeTerminalNodeQuery = (0, _query.nodeQuery)("/parameter/@type");
+var _default = (0, _elements.define)((_Parameter = /*#__PURE__*/ function() {
+    function Parameter(string, type, name) {
+        _class_call_check(this, Parameter);
+        this.string = string;
+        this.type = type;
+        this.name = name;
+    }
+    _create_class(Parameter, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "matchExpression",
+            value: function matchExpression(expression, context) {
+                var expressionString = expression.asString(context), parameterString = this.string; ///
+                context.trace("Matching the ".concat(expressionString, " expression against the '").concat(parameterString, "' parameter..."));
+                var expressionType = expression.getType();
+                if (this.type !== expressionType) {
+                    var message = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type  and '").concat(parameterString, "' parameter's '").concat(this.type, "' type do not match."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                context.debug("...matched the ".concat(expressionString, " expression against the '").concat(parameterString, "' parameter."));
+            }
+        }
+    ], [
+        {
+            key: "fromParameterNode",
+            value: function fromParameterNode(parameterNode, context) {
+                var parameter = null;
+                var terminalNodes = terminalNodesQuery(parameterNode), terminalNodesLength = terminalNodes.length;
+                if (terminalNodesLength === 2) {
+                    parameter = parameterFromParameterNode(parameterNode, context);
+                }
+                return parameter;
+            }
+        }
+    ]);
+    return Parameter;
+}(), _define_property(_Parameter, "name", "Parameter"), _Parameter));
+function parameterFromParameterNode(parameterNode, context) {
+    var Parameter = _elements.default.Parameter, name = nameFromParameterNode(parameterNode, context), type = typeFromParameterNode(parameterNode, context), string = stringFromNameAndType(name, type, context), parameter = new Parameter(string, type, name);
+    return parameter;
+}
+function stringFromNameAndType(name, type, context) {
+    var nameString = name, typeString = type, string = "".concat(typeString, " ").concat(nameString);
+    return string;
+}
+function nameFromParameterNode(parameterNode, context) {
+    var nameTerminalNode = nameTerminalNodeQuery(parameterNode), nameTerminalNodeContent = nameTerminalNode.getContent(), name = nameTerminalNodeContent; ///
+    return name;
+}
+function typeFromParameterNode(parameterNode, context) {
+    var typeTerminalNode = typeTerminalNodeQuery(parameterNode), typeTerminalNodeContent = typeTerminalNode.getContent(), type = typeTerminalNodeContent; ///
+    return type;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbGVtZW50L3BhcmFtZXRlci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IGVsZW1lbnRzIGZyb20gXCIuLi9lbGVtZW50c1wiO1xuaW1wb3J0IEV4Y2VwdGlvbiBmcm9tIFwiLi4vZXhjZXB0aW9uXCI7XG5cbmltcG9ydCB7IGRlZmluZSB9IGZyb20gXCIuLi9lbGVtZW50c1wiO1xuaW1wb3J0IHsgbm9kZVF1ZXJ5LCBub2Rlc1F1ZXJ5IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9xdWVyeVwiO1xuXG5jb25zdCB0ZXJtaW5hbE5vZGVzUXVlcnkgPSBub2Rlc1F1ZXJ5KFwiL3BhcmFtZXRlci9AKlwiKSxcbiAgICAgIG5hbWVUZXJtaW5hbE5vZGVRdWVyeSA9IG5vZGVRdWVyeShcIi9wYXJhbWV0ZXIvQG5hbWVcIiksXG4gICAgICB0eXBlVGVybWluYWxOb2RlUXVlcnkgPSBub2RlUXVlcnkoXCIvcGFyYW1ldGVyL0B0eXBlXCIpO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmUoY2xhc3MgUGFyYW1ldGVyIHtcbiAgY29uc3RydWN0b3Ioc3RyaW5nLCB0eXBlLCBuYW1lKSB7XG4gICAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG4gICAgdGhpcy50eXBlID0gdHlwZTtcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICB9XG5cbiAgZ2V0U3RyaW5nKCkge1xuICAgIHJldHVybiB0aGlzLnN0cmluZztcbiAgfVxuXG4gIGdldFR5cGUoKSB7XG4gICAgcmV0dXJuIHRoaXMudHlwZTtcbiAgfVxuXG4gIGdldE5hbWUoKSB7XG4gICAgcmV0dXJuIHRoaXMubmFtZTtcbiAgfVxuXG4gIG1hdGNoRXhwcmVzc2lvbihleHByZXNzaW9uLCBjb250ZXh0KSB7XG4gICAgY29uc3QgZXhwcmVzc2lvblN0cmluZyA9IGV4cHJlc3Npb24uYXNTdHJpbmcoY29udGV4dCksXG4gICAgICAgICAgcGFyYW1ldGVyU3RyaW5nID0gdGhpcy5zdHJpbmc7ICAvLy9cblxuICAgIGNvbnRleHQudHJhY2UoYE1hdGNoaW5nIHRoZSAke2V4cHJlc3Npb25TdHJpbmd9IGV4cHJlc3Npb24gYWdhaW5zdCB0aGUgJyR7cGFyYW1ldGVyU3RyaW5nfScgcGFyYW1ldGVyLi4uYCk7XG5cbiAgICBjb25zdCBleHByZXNzaW9uVHlwZSA9IGV4cHJlc3Npb24uZ2V0VHlwZSgpO1xuXG4gICAgaWYgKHRoaXMudHlwZSAhPT0gZXhwcmVzc2lvblR5cGUpIHtcbiAgICAgIGNvbnN0IG1lc3NhZ2UgPSBgVGhlICR7ZXhwcmVzc2lvblN0cmluZ30gZXhwcmVzc2lvbidzICcke2V4cHJlc3Npb25UeXBlfScgdHlwZSAgYW5kICcke3BhcmFtZXRlclN0cmluZ30nIHBhcmFtZXRlcidzICcke3RoaXMudHlwZX0nIHR5cGUgZG8gbm90IG1hdGNoLmAsXG4gICAgICAgICAgICBleGNlcHRpb24gPSBFeGNlcHRpb24uZnJvbU1lc3NhZ2UobWVzc2FnZSk7XG5cbiAgICAgIHRocm93IGV4Y2VwdGlvbjtcbiAgICB9XG5cbiAgICBjb250ZXh0LmRlYnVnKGAuLi5tYXRjaGVkIHRoZSAke2V4cHJlc3Npb25TdHJpbmd9IGV4cHJlc3Npb24gYWdhaW5zdCB0aGUgJyR7cGFyYW1ldGVyU3RyaW5nfScgcGFyYW1ldGVyLmApO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIlBhcmFtZXRlclwiO1xuXG4gIHN0YXRpYyBmcm9tUGFyYW1ldGVyTm9kZShwYXJhbWV0ZXJOb2RlLCBjb250ZXh0KSB7XG4gICAgbGV0IHBhcmFtZXRlciA9IG51bGw7XG5cbiAgICBjb25zdCB0ZXJtaW5hbE5vZGVzID0gdGVybWluYWxOb2Rlc1F1ZXJ5KHBhcmFtZXRlck5vZGUpLFxuICAgICAgICAgIHRlcm1pbmFsTm9kZXNMZW5ndGggPSB0ZXJtaW5hbE5vZGVzLmxlbmd0aDtcblxuICAgIGlmICh0ZXJtaW5hbE5vZGVzTGVuZ3RoID09PSAyKSB7XG4gICAgICBwYXJhbWV0ZXIgPSBwYXJhbWV0ZXJGcm9tUGFyYW1ldGVyTm9kZShwYXJhbWV0ZXJOb2RlLCBjb250ZXh0KTtcbiAgICB9XG5cbiAgICByZXR1cm4gcGFyYW1ldGVyO1xuICB9XG59KTtcblxuZnVuY3Rpb24gcGFyYW1ldGVyRnJvbVBhcmFtZXRlck5vZGUocGFyYW1ldGVyTm9kZSwgY29udGV4dCkge1xuICBjb25zdCB7IFBhcmFtZXRlciB9ID0gZWxlbWVudHMsXG4gICAgICAgIG5hbWUgPSBuYW1lRnJvbVBhcmFtZXRlck5vZGUocGFyYW1ldGVyTm9kZSwgY29udGV4dCksXG4gICAgICAgIHR5cGUgPSB0eXBlRnJvbVBhcmFtZXRlck5vZGUocGFyYW1ldGVyTm9kZSwgY29udGV4dCksXG4gICAgICAgIHN0cmluZyA9IHN0cmluZ0Zyb21OYW1lQW5kVHlwZShuYW1lLCB0eXBlLCBjb250ZXh0KSxcbiAgICAgICAgcGFyYW1ldGVyID0gbmV3IFBhcmFtZXRlcihzdHJpbmcsIHR5cGUsIG5hbWUpO1xuXG4gIHJldHVybiBwYXJhbWV0ZXI7XG59XG5cbmZ1bmN0aW9uIHN0cmluZ0Zyb21OYW1lQW5kVHlwZShuYW1lLCB0eXBlLCBjb250ZXh0KSB7XG4gIGNvbnN0IG5hbWVTdHJpbmcgPSBuYW1lLCAgLy8vXG4gICAgICAgIHR5cGVTdHJpbmcgPSB0eXBlLCAgLy8vXG4gICAgICAgIHN0cmluZyA9IGAke3R5cGVTdHJpbmd9ICR7bmFtZVN0cmluZ31gO1xuXG4gIHJldHVybiBzdHJpbmc7XG59XG5cbmZ1bmN0aW9uIG5hbWVGcm9tUGFyYW1ldGVyTm9kZShwYXJhbWV0ZXJOb2RlLCBjb250ZXh0KSB7XG4gIGNvbnN0IG5hbWVUZXJtaW5hbE5vZGUgPSBuYW1lVGVybWluYWxOb2RlUXVlcnkocGFyYW1ldGVyTm9kZSksXG4gICAgICAgIG5hbWVUZXJtaW5hbE5vZGVDb250ZW50ID0gbmFtZVRlcm1pbmFsTm9kZS5nZXRDb250ZW50KCksXG4gICAgICAgIG5hbWUgPSBuYW1lVGVybWluYWxOb2RlQ29udGVudDsgLy8vXG5cbiAgcmV0dXJuIG5hbWU7XG59XG5cbmZ1bmN0aW9uIHR5cGVGcm9tUGFyYW1ldGVyTm9kZShwYXJhbWV0ZXJOb2RlLCBjb250ZXh0KSB7XG4gIGNvbnN0IHR5cGVUZXJtaW5hbE5vZGUgPSB0eXBlVGVybWluYWxOb2RlUXVlcnkocGFyYW1ldGVyTm9kZSksXG4gICAgICAgIHR5cGVUZXJtaW5hbE5vZGVDb250ZW50ID0gdHlwZVRlcm1pbmFsTm9kZS5nZXRDb250ZW50KCksXG4gICAgICAgIHR5cGUgPSB0eXBlVGVybWluYWxOb2RlQ29udGVudDsgLy8vXG5cbiAgcmV0dXJuIHR5cGU7XG59XG4iXSwibmFtZXMiOlsidGVybWluYWxOb2Rlc1F1ZXJ5Iiwibm9kZXNRdWVyeSIsIm5hbWVUZXJtaW5hbE5vZGVRdWVyeSIsIm5vZGVRdWVyeSIsInR5cGVUZXJtaW5hbE5vZGVRdWVyeSIsImRlZmluZSIsIlBhcmFtZXRlciIsInN0cmluZyIsInR5cGUiLCJuYW1lIiwiZ2V0U3RyaW5nIiwiZ2V0VHlwZSIsImdldE5hbWUiLCJtYXRjaEV4cHJlc3Npb24iLCJleHByZXNzaW9uIiwiY29udGV4dCIsImV4cHJlc3Npb25TdHJpbmciLCJhc1N0cmluZyIsInBhcmFtZXRlclN0cmluZyIsInRyYWNlIiwiZXhwcmVzc2lvblR5cGUiLCJtZXNzYWdlIiwiZXhjZXB0aW9uIiwiRXhjZXB0aW9uIiwiZnJvbU1lc3NhZ2UiLCJkZWJ1ZyIsImZyb21QYXJhbWV0ZXJOb2RlIiwicGFyYW1ldGVyTm9kZSIsInBhcmFtZXRlciIsInRlcm1pbmFsTm9kZXMiLCJ0ZXJtaW5hbE5vZGVzTGVuZ3RoIiwibGVuZ3RoIiwicGFyYW1ldGVyRnJvbVBhcmFtZXRlck5vZGUiLCJlbGVtZW50cyIsIm5hbWVGcm9tUGFyYW1ldGVyTm9kZSIsInR5cGVGcm9tUGFyYW1ldGVyTm9kZSIsInN0cmluZ0Zyb21OYW1lQW5kVHlwZSIsIm5hbWVTdHJpbmciLCJ0eXBlU3RyaW5nIiwibmFtZVRlcm1pbmFsTm9kZSIsIm5hbWVUZXJtaW5hbE5vZGVDb250ZW50IiwiZ2V0Q29udGVudCIsInR5cGVUZXJtaW5hbE5vZGUiLCJ0eXBlVGVybWluYWxOb2RlQ29udGVudCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBWUE7OztlQUFBOzs7Z0VBVnFCO2dFQUNDO3FCQUdnQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFdEMsSUFBTUEscUJBQXFCQyxJQUFBQSxpQkFBVSxFQUFDLGtCQUNoQ0Msd0JBQXdCQyxJQUFBQSxnQkFBUyxFQUFDLHFCQUNsQ0Msd0JBQXdCRCxJQUFBQSxnQkFBUyxFQUFDO0lBRXhDLFdBQWVFLElBQUFBLGdCQUFNLDhCQUFDO2FBQU1DLFVBQ2RDLE1BQU0sRUFBRUMsSUFBSSxFQUFFQyxJQUFJO2dDQURKSDtRQUV4QixJQUFJLENBQUNDLE1BQU0sR0FBR0E7UUFDZCxJQUFJLENBQUNDLElBQUksR0FBR0E7UUFDWixJQUFJLENBQUNDLElBQUksR0FBR0E7Ozs7WUFHZEMsS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLE9BQU8sSUFBSSxDQUFDSCxNQUFNO1lBQ3BCOzs7WUFFQUksS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLE9BQU8sSUFBSSxDQUFDSCxJQUFJO1lBQ2xCOzs7WUFFQUksS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLE9BQU8sSUFBSSxDQUFDSCxJQUFJO1lBQ2xCOzs7WUFFQUksS0FBQUE7bUJBQUFBLFNBQUFBLGdCQUFnQkMsVUFBVSxFQUFFQyxPQUFPO2dCQUNqQyxJQUFNQyxtQkFBbUJGLFdBQVdHLFFBQVEsQ0FBQ0YsVUFDdkNHLGtCQUFrQixJQUFJLENBQUNYLE1BQU0sRUFBRyxHQUFHO2dCQUV6Q1EsUUFBUUksS0FBSyxDQUFDLEFBQUMsZ0JBQTJERCxPQUE1Q0Ysa0JBQWlCLDZCQUEyQyxPQUFoQkUsaUJBQWdCO2dCQUUxRixJQUFNRSxpQkFBaUJOLFdBQVdILE9BQU87Z0JBRXpDLElBQUksSUFBSSxDQUFDSCxJQUFJLEtBQUtZLGdCQUFnQjtvQkFDaEMsSUFBTUMsVUFBVSxBQUFDLE9BQXdDRCxPQUFsQ0osa0JBQWlCLG1CQUErQ0UsT0FBOUJFLGdCQUFlLGlCQUFnRCxPQUFqQ0YsaUJBQWdCLG1CQUEyQixPQUFWLElBQUksQ0FBQ1YsSUFBSSxFQUFDLHlCQUM1SGMsWUFBWUMsa0JBQVMsQ0FBQ0MsV0FBVyxDQUFDSDtvQkFFeEMsTUFBTUM7Z0JBQ1I7Z0JBRUFQLFFBQVFVLEtBQUssQ0FBQyxBQUFDLGtCQUE2RFAsT0FBNUNGLGtCQUFpQiw2QkFBMkMsT0FBaEJFLGlCQUFnQjtZQUM5Rjs7OztZQUlPUSxLQUFBQTttQkFBUCxTQUFPQSxrQkFBa0JDLGFBQWEsRUFBRVosT0FBTztnQkFDN0MsSUFBSWEsWUFBWTtnQkFFaEIsSUFBTUMsZ0JBQWdCN0IsbUJBQW1CMkIsZ0JBQ25DRyxzQkFBc0JELGNBQWNFLE1BQU07Z0JBRWhELElBQUlELHdCQUF3QixHQUFHO29CQUM3QkYsWUFBWUksMkJBQTJCTCxlQUFlWjtnQkFDeEQ7Z0JBRUEsT0FBT2E7WUFDVDs7OztLQWJBLDZCQUFPbkIsUUFBTztBQWdCaEIsU0FBU3VCLDJCQUEyQkwsYUFBYSxFQUFFWixPQUFPO0lBQ3hELElBQU0sQUFBRVQsWUFBYzJCLGlCQUFRLENBQXRCM0IsV0FDRkcsT0FBT3lCLHNCQUFzQlAsZUFBZVosVUFDNUNQLE9BQU8yQixzQkFBc0JSLGVBQWVaLFVBQzVDUixTQUFTNkIsc0JBQXNCM0IsTUFBTUQsTUFBTU8sVUFDM0NhLFlBQVksSUFBSXRCLFVBQVVDLFFBQVFDLE1BQU1DO0lBRTlDLE9BQU9tQjtBQUNUO0FBRUEsU0FBU1Esc0JBQXNCM0IsSUFBSSxFQUFFRCxJQUFJLEVBQUVPLE9BQU87SUFDaEQsSUFBTXNCLGFBQWE1QixNQUNiNkIsYUFBYTlCLE1BQ2JELFNBQVMsQUFBQyxHQUFnQjhCLE9BQWRDLFlBQVcsS0FBYyxPQUFYRDtJQUVoQyxPQUFPOUI7QUFDVDtBQUVBLFNBQVMyQixzQkFBc0JQLGFBQWEsRUFBRVosT0FBTztJQUNuRCxJQUFNd0IsbUJBQW1CckMsc0JBQXNCeUIsZ0JBQ3pDYSwwQkFBMEJELGlCQUFpQkUsVUFBVSxJQUNyRGhDLE9BQU8rQix5QkFBeUIsR0FBRztJQUV6QyxPQUFPL0I7QUFDVDtBQUVBLFNBQVMwQixzQkFBc0JSLGFBQWEsRUFBRVosT0FBTztJQUNuRCxJQUFNMkIsbUJBQW1CdEMsc0JBQXNCdUIsZ0JBQ3pDZ0IsMEJBQTBCRCxpQkFBaUJELFVBQVUsSUFDckRqQyxPQUFPbUMseUJBQXlCLEdBQUc7SUFFekMsT0FBT25DO0FBQ1QifQ==

package/lib/element/parameters/named.js

@@ -0,0 +1,220 @@
+"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 _NamedParameters;
+var namedParameterNodesQuery = (0, _query.nodesQuery)("/namedParameters/namedParameter"), objectAssignmentNamedParametersNodeQuery = (0, _query.nodeQuery)("/objectAssignment/namedParameters");
+var _default = (0, _elements.define)((_NamedParameters = /*#__PURE__*/ function() {
+    function NamedParameters(string, array) {
+        _class_call_check(this, NamedParameters);
+        this.string = string;
+        this.array = array;
+    }
+    _create_class(NamedParameters, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getArray",
+            value: function getArray() {
+                return this.array;
+            }
+        },
+        {
+            key: "getLength",
+            value: function getLength() {
+                var length = this.array.length;
+                return length;
+            }
+        },
+        {
+            key: "getNamedParameter",
+            value: function getNamedParameter(index) {
+                var namedParameter = this.array[index] || null;
+                return namedParameter;
+            }
+        },
+        {
+            key: "someNamedParameter",
+            value: function someNamedParameter(callback) {
+                return this.array.some(callback);
+            }
+        },
+        {
+            key: "forEachNamedParameter",
+            value: function forEachNamedParameter(callback) {
+                this.array.forEach(callback);
+            }
+        },
+        {
+            key: "matchExpressions",
+            value: function matchExpressions(expressions, context) {
+                var expressionsString = expressions.getString(), namedParametersString = this.string; ///
+                context.trace("Matching the ".concat(expressionsString, " expressions against the '").concat(namedParametersString, "' named parameters..."));
+                var expressionsLength = expressions.getLength(), namedParametersLength = this.getLength();
+                if (expressionsLength !== namedParametersLength) {
+                    var message = "The ".concat(expressionsString, " expressions and '").concat(namedParametersString, "' named parameters are not of the same length."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                this.forEachNamedParameter(function(namedParameter, index) {
+                    if (namedParameter !== null) {
+                        var expression = expressions.getExpression(index);
+                        namedParameter.matchExpression(expression, context);
+                    }
+                });
+                context.debug("...matched the ".concat(expressionsString, " expressions against the '").concat(namedParametersString, "' named parameters."));
+            }
+        },
+        {
+            key: "matchNamedParameter",
+            value: function matchNamedParameter(namedParameter, context) {
+                var namedParameterString = namedParameter.getString(), namedParametersString = this.string; ///
+                context.trace("Matching the '".concat(namedParameterString, "' namedParameter against the '").concat(namedParametersString, "' named parameters..."));
+                var namedParameterA = namedParameter, namedParameterMatches = this.someNamedParameter(function(namedParameter) {
+                    if (namedParameter !== null) {
+                        var namedParameterB = namedParameter, namedParameterBMatchesNamedParameterA = namedParameterA.matchNamedParameter(namedParameterB, context);
+                        if (namedParameterBMatchesNamedParameterA) {
+                            return true;
+                        }
+                    }
+                });
+                if (!namedParameterMatches) {
+                    var message = "The '".concat(namedParameterString, "' namedParameter does not match any of the '").concat(namedParametersString, "' named parameters."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                context.debug("...matched the '".concat(namedParameterString, "' namedParameter against the '").concat(namedParametersString, "' named parameters."));
+            }
+        },
+        {
+            key: "matchNamedParameters",
+            value: function matchNamedParameters(namedParameters, context) {
+                var _this = this;
+                namedParameters.forEachNamedParameter(function(namedParameter) {
+                    if (namedParameter !== null) {
+                        _this.matchNamedParameter(namedParameter, context);
+                    }
+                });
+            }
+        }
+    ], [
+        {
+            key: "fromObjectAssignmentNode",
+            value: function fromObjectAssignmentNode(objectAssignmentNode, context) {
+                var objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode), namedParametersNode = objectAssignmentNamedParametersNode, namedParameters = namedParametersFromNamedParametersNode(namedParametersNode, context);
+                return namedParameters;
+            }
+        }
+    ]);
+    return NamedParameters;
+}(), _define_property(_NamedParameters, "name", "NamedParameters"), _NamedParameters));
+function namedParametersFromNamedParametersNode(namedParametersNode, context) {
+    var NamedParameters = _elements.default.NamedParameters, namedParameterNodes = namedParameterNodesQuery(namedParametersNode), array = arrayFromNamedParameterNodes(namedParameterNodes, context), string = stringFromArray(array, context), namedParameters = new NamedParameters(string, array);
+    return namedParameters;
+}
+function arrayFromNamedParameterNodes(namedParameterNodes, context) {
+    var NamedParameter = _elements.default.NamedParameter, array = namedParameterNodes.map(function(namedParameterNode) {
+        var namedParameter = NamedParameter.fromNamedParameterNode(namedParameterNode, context);
+        return namedParameter;
+    });
+    return array;
+}
+function stringFromArray(array, context) {
+    var namedParametersSString = array.reduce(function(namedParametersSString, namedParameter) {
+        var namedParameterString = namedParameter.getString();
+        namedParametersSString = namedParametersSString === null ? namedParameterString : "".concat(namedParametersSString, ", ").concat(namedParameterString);
+        return namedParametersSString;
+    }, null), string = namedParametersSString; ///
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/parameters/named.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\nimport Exception from \"../../exception\";\n\nimport { define } from \"../../elements\";\nimport { nodeQuery, nodesQuery } from \"../../utilities/query\";\n\nconst namedParameterNodesQuery = nodesQuery(\"/namedParameters/namedParameter\"),\n      objectAssignmentNamedParametersNodeQuery = nodeQuery(\"/objectAssignment/namedParameters\");\n\nexport default define(class NamedParameters {\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  getLength() {\n    const length = this.array.length;\n\n    return length;\n  }\n\n  getNamedParameter(index) {\n    const namedParameter = this.array[index] || null;\n\n    return namedParameter;\n  }\n\n  someNamedParameter(callback) { return this.array.some(callback); }\n\n  forEachNamedParameter(callback) { this.array.forEach(callback); }\n\n  matchExpressions(expressions, context) {\n    const expressionsString = expressions.getString(),\n          namedParametersString = this.string; ///\n\n    context.trace(`Matching the ${expressionsString} expressions against the '${namedParametersString}' named parameters...`);\n\n    const expressionsLength = expressions.getLength(),\n          namedParametersLength = this.getLength();\n\n    if (expressionsLength !== namedParametersLength) {\n      const message = `The ${expressionsString} expressions and '${namedParametersString}' named parameters are not of the same length.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    this.forEachNamedParameter((namedParameter, index) => {\n      if (namedParameter !== null) {\n        const expression = expressions.getExpression(index);\n\n        namedParameter.matchExpression(expression, context);\n      }\n    });\n\n    context.debug(`...matched the ${expressionsString} expressions against the '${namedParametersString}' named parameters.`);\n  }\n\n  matchNamedParameter(namedParameter, context) {\n    const namedParameterString = namedParameter.getString(),\n          namedParametersString = this.string; ///\n\n    context.trace(`Matching the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters...`);\n\n    const namedParameterA = namedParameter, ///\n          namedParameterMatches = this.someNamedParameter((namedParameter) => {\n            if (namedParameter !== null) {\n              const namedParameterB = namedParameter, ///\n                    namedParameterBMatchesNamedParameterA = namedParameterA.matchNamedParameter(namedParameterB, context);\n\n              if (namedParameterBMatchesNamedParameterA) {\n                return true;\n              }\n            }\n          });\n\n    if (!namedParameterMatches) {\n      const message = `The '${namedParameterString}' namedParameter does not match any of the '${namedParametersString}' named parameters.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    context.debug(`...matched the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters.`);\n  }\n\n  matchNamedParameters(namedParameters, context) {\n    namedParameters.forEachNamedParameter((namedParameter) => {\n      if (namedParameter !== null) {\n        this.matchNamedParameter(namedParameter, context);\n      }\n    });\n  }\n\n  static name = \"NamedParameters\";\n\n  static fromObjectAssignmentNode(objectAssignmentNode, context) {\n    const objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode),\n          namedParametersNode = objectAssignmentNamedParametersNode,  ///\n          namedParameters = namedParametersFromNamedParametersNode(namedParametersNode, context);\n\n    return namedParameters;\n  }\n});\n\nfunction namedParametersFromNamedParametersNode(namedParametersNode, context) {\n  const { NamedParameters } = elements,\n        namedParameterNodes = namedParameterNodesQuery(namedParametersNode),\n        array = arrayFromNamedParameterNodes(namedParameterNodes, context),\n        string = stringFromArray(array, context),\n        namedParameters = new NamedParameters(string, array);\n\n  return namedParameters;\n}\n\nfunction arrayFromNamedParameterNodes(namedParameterNodes, context) {\n  const { NamedParameter } = elements,\n        array = namedParameterNodes.map((namedParameterNode) => { ///\n          const namedParameter = NamedParameter.fromNamedParameterNode(namedParameterNode, context);\n\n          return namedParameter;\n        });\n\n  return array;\n}\n\nfunction stringFromArray(array, context) {\n  const namedParametersSString = array.reduce((namedParametersSString, namedParameter) => {\n          const namedParameterString = namedParameter.getString();\n\n          namedParametersSString = (namedParametersSString === null) ?\n                                     namedParameterString :\n                                      `${namedParametersSString}, ${namedParameterString}`;\n\n          return namedParametersSString;\n        }, null),\n        string = namedParametersSString;  ///\n\n  return string;\n}\n"],"names":["namedParameterNodesQuery","nodesQuery","objectAssignmentNamedParametersNodeQuery","nodeQuery","define","NamedParameters","string","array","getString","getArray","getLength","length","getNamedParameter","index","namedParameter","someNamedParameter","callback","some","forEachNamedParameter","forEach","matchExpressions","expressions","context","expressionsString","namedParametersString","trace","expressionsLength","namedParametersLength","message","exception","Exception","fromMessage","expression","getExpression","matchExpression","debug","matchNamedParameter","namedParameterString","namedParameterA","namedParameterMatches","namedParameterB","namedParameterBMatchesNamedParameterA","matchNamedParameters","namedParameters","fromObjectAssignmentNode","objectAssignmentNode","objectAssignmentNamedParametersNode","namedParametersNode","namedParametersFromNamedParametersNode","name","elements","namedParameterNodes","arrayFromNamedParameterNodes","stringFromArray","NamedParameter","map","namedParameterNode","fromNamedParameterNode","namedParametersSString","reduce"],"mappings":"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"}

package/lib/element/parameters.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 _constants = require("../constants");
+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 _Parameters;
+var parameterNodesQuery = (0, _query.nodesQuery)("/parameters/parameter"), arrayAssignmentParametersNodeQuery = (0, _query.nodeQuery)("/arrayAssignment/parameters"), anonymousProcedureParametersNodeQuery = (0, _query.nodeQuery)("/anonymousProcedure/parameters"), procedureDeclarationParametersNodeQuery = (0, _query.nodeQuery)("/procedureDeclaration/parameters");
+var _default = (0, _elements.define)((_Parameters = /*#__PURE__*/ function() {
+    function Parameters(string, array) {
+        _class_call_check(this, Parameters);
+        this.string = string;
+        this.array = array;
+    }
+    _create_class(Parameters, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getArray",
+            value: function getArray() {
+                return this.array;
+            }
+        },
+        {
+            key: "getLength",
+            value: function getLength() {
+                var length = this.array.length;
+                return length;
+            }
+        },
+        {
+            key: "getParameter",
+            value: function getParameter(index) {
+                var parameter = this.array[index] || null;
+                return parameter;
+            }
+        },
+        {
+            key: "forEachParameter",
+            value: function forEachParameter(callback) {
+                this.array.forEach(callback);
+            }
+        },
+        {
+            key: "matchExpressions",
+            value: function matchExpressions(expressions, context) {
+                var expressionsString = expressions.getString(), parametersString = this.string; ///
+                context.trace("Matching the ".concat(expressionsString, " expressions against the '").concat(parametersString, "' parameters..."));
+                var expressionsLength = expressions.getLength(), parametersLength = this.getLength();
+                if (expressionsLength !== parametersLength) {
+                    var message = "The ".concat(expressionsString, " expressions and '").concat(parametersString, "' parameters are not of the same length."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                this.forEachParameter(function(parameter, index) {
+                    if (parameter !== null) {
+                        var expression = expressions.getExpression(index);
+                        parameter.matchExpression(expression, context);
+                    }
+                });
+                context.debug("...matched the ".concat(expressionsString, " expressions against the '").concat(parametersString, "' parameters."));
+            }
+        }
+    ], [
+        {
+            key: "fromArrayAssignmentNode",
+            value: function fromArrayAssignmentNode(arrayAssignmentNode, context) {
+                var arrayAssignmentParametersNode = arrayAssignmentParametersNodeQuery(arrayAssignmentNode), parametersNode = arrayAssignmentParametersNode, parameters = parametersFromParametersNode(parametersNode, context);
+                return parameters;
+            }
+        },
+        {
+            key: "fromAnonymousProcedureNode",
+            value: function fromAnonymousProcedureNode(anonymousProcedureNode, context) {
+                var anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode), parametersNode = anonymousProcedureParametersNode, parameters = parametersFromParametersNode(parametersNode, context);
+                return parameters;
+            }
+        },
+        {
+            key: "fromProcedureDeclarationNode",
+            value: function fromProcedureDeclarationNode(procedureDeclarationNode, context) {
+                var procedureDeclarationParametersNode = procedureDeclarationParametersNodeQuery(procedureDeclarationNode), parametersNode = procedureDeclarationParametersNode, parameters = parametersFromParametersNode(parametersNode, context);
+                return parameters;
+            }
+        }
+    ]);
+    return Parameters;
+}(), _define_property(_Parameters, "name", "Parameters"), _Parameters));
+function parametersFromParametersNode(parametersNode, context) {
+    var Parameters = _elements.default.Parameters, array = arrayFromParametersNode(parametersNode, context), string = stringFromArray(array, context), parameters = new Parameters(string, array);
+    return parameters;
+}
+function arrayFromParametersNode(parametersNode, context) {
+    var parameterNodes = parameterNodesQuery(parametersNode), array = parameterNodes.map(function(parameterNode) {
+        var Parameter = _elements.default.Parameter, parameter = Parameter.fromParameterNode(parameterNode, context);
+        return parameter;
+    });
+    return array;
+}
+function stringFromArray(array, context) {
+    var parametersString = array.reduce(function(parametersString, parameter) {
+        var parameterString = parameter !== null ? parameter.getString() : _constants.UNDERSCORE;
+        parametersString = parametersString === null ? parameterString : "".concat(parametersString, ", ").concat(parameterString);
+        return parametersString;
+    }, null), string = parametersString; ///
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/parameters.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\nimport Exception from \"../exception\";\n\nimport { define } from \"../elements\";\nimport { UNDERSCORE } from \"../constants\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst parameterNodesQuery = nodesQuery(\"/parameters/parameter\"),\n      arrayAssignmentParametersNodeQuery = nodeQuery(\"/arrayAssignment/parameters\"),\n      anonymousProcedureParametersNodeQuery = nodeQuery(\"/anonymousProcedure/parameters\"),\n      procedureDeclarationParametersNodeQuery = nodeQuery(\"/procedureDeclaration/parameters\");\n\nexport default define(class Parameters {\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  getLength() {\n    const length = this.array.length;\n\n    return length;\n  }\n\n  getParameter(index) {\n    const parameter = this.array[index] || null;\n\n    return parameter;\n  }\n\n  forEachParameter(callback) { this.array.forEach(callback); }\n\n  matchExpressions(expressions, context) {\n    const expressionsString = expressions.getString(),\n          parametersString = this.string; ///\n\n    context.trace(`Matching the ${expressionsString} expressions against the '${parametersString}' parameters...`);\n\n    const expressionsLength = expressions.getLength(),\n          parametersLength = this.getLength();\n\n    if (expressionsLength !== parametersLength) {\n      const message = `The ${expressionsString} expressions and '${parametersString}' parameters are not of the same length.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    this.forEachParameter((parameter, index) => {\n      if (parameter !== null) {\n        const expression = expressions.getExpression(index);\n\n        parameter.matchExpression(expression, context);\n      }\n    });\n\n    context.debug(`...matched the ${expressionsString} expressions against the '${parametersString}' parameters.`);\n  }\n\n  static name = \"Parameters\";\n\n  static fromArrayAssignmentNode(arrayAssignmentNode, context) {\n    const arrayAssignmentParametersNode = arrayAssignmentParametersNodeQuery(arrayAssignmentNode),\n          parametersNode = arrayAssignmentParametersNode,  ///\n          parameters = parametersFromParametersNode(parametersNode, context);\n\n    return parameters;\n  }\n\n  static fromAnonymousProcedureNode(anonymousProcedureNode, context) {\n    const anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),\n          parametersNode = anonymousProcedureParametersNode,  ///\n          parameters = parametersFromParametersNode(parametersNode, context);\n\n    return parameters;\n  }\n\n  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {\n    const procedureDeclarationParametersNode = procedureDeclarationParametersNodeQuery(procedureDeclarationNode),\n          parametersNode = procedureDeclarationParametersNode,  ///\n          parameters = parametersFromParametersNode(parametersNode, context);\n\n    return parameters;\n  }\n});\n\nfunction parametersFromParametersNode(parametersNode, context) {\n  const { Parameters } = elements,\n        array = arrayFromParametersNode(parametersNode, context),\n        string = stringFromArray(array, context),\n        parameters = new Parameters(string, array);\n\n  return parameters;\n}\n\nfunction arrayFromParametersNode(parametersNode, context) {\n  const parameterNodes = parameterNodesQuery(parametersNode),\n        array = parameterNodes.map((parameterNode) => { ///\n          const { Parameter } = elements,\n                parameter = Parameter.fromParameterNode(parameterNode, context);\n\n          return parameter;\n        });\n\n  return array;\n}\n\nfunction stringFromArray(array, context) {\n  const parametersString = array.reduce((parametersString, parameter) => {\n          const parameterString = (parameter !== null)?\n                                    parameter.getString() :\n                                      UNDERSCORE;\n\n          parametersString = (parametersString === null) ?\n                               parameterString :\n                                `${parametersString}, ${parameterString}`;\n\n          return parametersString;\n        }, null),\n        string = parametersString;  ///\n\n  return string;\n}\n"],"names":["parameterNodesQuery","nodesQuery","arrayAssignmentParametersNodeQuery","nodeQuery","anonymousProcedureParametersNodeQuery","procedureDeclarationParametersNodeQuery","define","Parameters","string","array","getString","getArray","getLength","length","getParameter","index","parameter","forEachParameter","callback","forEach","matchExpressions","expressions","context","expressionsString","parametersString","trace","expressionsLength","parametersLength","message","exception","Exception","fromMessage","expression","getExpression","matchExpression","debug","fromArrayAssignmentNode","arrayAssignmentNode","arrayAssignmentParametersNode","parametersNode","parameters","parametersFromParametersNode","fromAnonymousProcedureNode","anonymousProcedureNode","anonymousProcedureParametersNode","fromProcedureDeclarationNode","procedureDeclarationNode","procedureDeclarationParametersNode","name","elements","arrayFromParametersNode","stringFromArray","parameterNodes","map","parameterNode","Parameter","fromParameterNode","reduce","parameterString","UNDERSCORE"],"mappings":"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"}