occam-furtle 2.0.120 → 2.0.122

package/lib/dom/expressions.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+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 _Expressions;
+var expressionNodesQuery = (0, _query.nodesQuery)("/expressions/expression"), procedureCallExpressionsNodeQuery = (0, _query.nodeQuery)("/procedureCall/expressions");
+var _default = (0, _dom.domAssigned)((_Expressions = /*#__PURE__*/ function() {
+    function Expressions(string, array) {
+        _class_call_check(this, Expressions);
+        this.string = string;
+        this.array = array;
+    }
+    _create_class(Expressions, [
+        {
+            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: "getExpression",
+            value: function getExpression(index) {
+                var expression = this.array[index] || null; ///
+                return expression;
+            }
+        },
+        {
+            key: "addExpression",
+            value: function addExpression(expression) {
+                this.array.push(expression);
+            }
+        },
+        {
+            key: "mapExpression",
+            value: function mapExpression(callback) {
+                return this.array.map(callback);
+            }
+        },
+        {
+            key: "forEachExpression",
+            value: function forEachExpression(callback) {
+                this.array.forEach(callback);
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var array = this.mapExpression(function(expression) {
+                    expression = expression.evaluate(context);
+                    return expression;
+                }), expressions = Expressions.fromArray(array, context); ///
+                return expressions;
+            }
+        }
+    ], [
+        {
+            key: "fromNodes",
+            value: function fromNodes(nodes, context) {
+                var array = arrayFromNodes(nodes, context), string = stringFromArray(array, context), expressions = new Expressions(string, array);
+                return expressions;
+            }
+        },
+        {
+            key: "fromArray",
+            value: function fromArray(array, context) {
+                var string = stringFromArray(array, context), expressions = new Expressions(string, array);
+                return expressions;
+            }
+        },
+        {
+            key: "fromExpression",
+            value: function fromExpression(expression, context) {
+                var array = [
+                    expression
+                ], string = stringFromArray(array, context), expressions = new Expressions(string, array);
+                return expressions;
+            }
+        },
+        {
+            key: "fromProcedureCallNode",
+            value: function fromProcedureCallNode(procedureCallNode, context) {
+                var procedureCallExpressionsNode = procedureCallExpressionsNodeQuery(procedureCallNode), expressionsNode = procedureCallExpressionsNode, expressions = expressionsFromExpressionsNode(expressionsNode, context);
+                return expressions;
+            }
+        }
+    ]);
+    return Expressions;
+}(), _define_property(_Expressions, "name", "Expressions"), _Expressions));
+function arrayFromNodes(nodes, context) {
+    var Expression = _dom.default.Expression, array = nodes.map(function(node) {
+        var expression = Expression.fromNode(node, context);
+        return expression;
+    });
+    return array;
+}
+function stringFromArray(array, context) {
+    var expressionsString = array.reduce(function(expressionsString, expression) {
+        var expressionString = expression.asString(context);
+        expressionsString = expressionsString === null ? expressionString : "".concat(expressionsString, ", ").concat(expressionString);
+        return expressionsString;
+    }, null), string = expressionsString; ///
+    return string;
+}
+function arrayFromExpressionNodes(expressionNodes, context) {
+    var Expression = _dom.default.Expression, array = expressionNodes.map(function(expressionNode) {
+        var expression = Expression.fromExpressionNode(expressionNode, context);
+        return expression;
+    });
+    return array;
+}
+function expressionsFromExpressionsNode(expressionsNode, context) {
+    var Expressions = _dom.default.Expressions, node = expressionsNode, string = context.nodeAsString(node), expressionNodes = expressionNodesQuery(expressionsNode), array = arrayFromExpressionNodes(expressionNodes, context), expressions = new Expressions(string, array);
+    return expressions;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/expressions.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\n\nimport { domAssigned } from \"../dom\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst expressionNodesQuery = nodesQuery(\"/expressions/expression\"),\n      procedureCallExpressionsNodeQuery = nodeQuery(\"/procedureCall/expressions\");\n\nexport default domAssigned(class Expressions {\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  getExpression(index) {\n    const expression = this.array[index] || null;  ///\n\n    return expression;\n  }\n\n  addExpression(expression) {\n    this.array.push(expression);\n  }\n\n  mapExpression(callback) { return this.array.map(callback); }\n\n  forEachExpression(callback) { this.array.forEach(callback); }\n\n  evaluate(context) {\n    const array = this.mapExpression((expression) => {\n            expression = expression.evaluate(context);\n\n            return expression;\n          }),\n          expressions = Expressions.fromArray(array, context); ///\n\n    return expressions;\n  }\n\n  static name = \"Expressions\";\n\n  static fromNodes(nodes, context) {\n    const array = arrayFromNodes(nodes, context),\n          string = stringFromArray(array, context),\n          expressions = new Expressions(string, array);\n\n    return expressions;\n  }\n\n  static fromArray(array, context) {\n    const string = stringFromArray(array, context),\n          expressions = new Expressions(string, array);\n\n    return expressions;\n  }\n\n  static fromExpression(expression, context) {\n    const array = [\n            expression\n          ],\n          string = stringFromArray(array, context),\n          expressions = new Expressions(string, array);\n\n    return expressions;\n  }\n\n  static fromProcedureCallNode(procedureCallNode, context) {\n    const procedureCallExpressionsNode = procedureCallExpressionsNodeQuery(procedureCallNode),\n          expressionsNode = procedureCallExpressionsNode, ///\n          expressions = expressionsFromExpressionsNode(expressionsNode, context);\n\n    return expressions;\n  }\n});\n\nfunction arrayFromNodes(nodes, context) {\n  const { Expression } = dom,\n        array = nodes.map((node) => { ///\n          const expression = Expression.fromNode(node, context);\n\n          return expression;\n        });\n\n  return array;\n}\n\nfunction stringFromArray(array, context) {\n  const expressionsString = array.reduce((expressionsString, expression) => {\n          const expressionString = expression.asString(context);\n\n          expressionsString = (expressionsString === null) ?\n                           expressionString :\n                            `${expressionsString}, ${expressionString}`;\n\n          return expressionsString;\n        }, null),\n        string = expressionsString;  ///\n\n  return string;\n}\n\nfunction arrayFromExpressionNodes(expressionNodes, context) {\n  const { Expression } = dom,\n        array = expressionNodes.map((expressionNode) => { ///\n          const expression = Expression.fromExpressionNode(expressionNode, context);\n\n          return expression;\n        });\n\n  return array;\n}\n\nfunction expressionsFromExpressionsNode(expressionsNode, context) {\n  const { Expressions } = dom,\n        node = expressionsNode, ///\n        string = context.nodeAsString(node),\n        expressionNodes = expressionNodesQuery(expressionsNode),\n        array = arrayFromExpressionNodes(expressionNodes, context),\n        expressions = new Expressions(string, array);\n\n  return expressions;\n}\n"],"names":["expressionNodesQuery","nodesQuery","procedureCallExpressionsNodeQuery","nodeQuery","domAssigned","Expressions","string","array","getString","getArray","getLength","length","getExpression","index","expression","addExpression","push","mapExpression","callback","map","forEachExpression","forEach","evaluate","context","expressions","fromArray","fromNodes","nodes","arrayFromNodes","stringFromArray","fromExpression","fromProcedureCallNode","procedureCallNode","procedureCallExpressionsNode","expressionsNode","expressionsFromExpressionsNode","name","Expression","dom","node","fromNode","expressionsString","reduce","expressionString","asString","arrayFromExpressionNodes","expressionNodes","expressionNode","fromExpressionNode","nodeAsString"],"mappings":"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"}

package/lib/dom/parameter/named.js

@@ -125,16 +125,16 @@ var _default = (0, _dom.domAssigned)((_NamedParameter = /*#__PURE__*/ function()
             }
         },
         {
-            key: "matchValue",
-            value: function matchValue(value, context) {
-                var valueString = value.asString(context), namedParameterString = this.string; ///
-                context.trace("Matching the ".concat(valueString, " value against the '").concat(namedParameterString, "' named parameter..."));
-                var valueType = value.getType();
-                if (this.type !== valueType) {
-                    var message = "The ".concat(valueString, " value's '").concat(valueType, "' type  and '").concat(namedParameterString, "' named parameter's '").concat(this.type, "' type do not match."), exception = _exception.default.fromMessage(message);
+            key: "matchExpression",
+            value: function matchExpression(expression, context) {
+                var expressionString = expression.asString(context), namedParameterString = this.string; ///
+                context.trace("Matching the ".concat(expressionString, " expression against the '").concat(namedParameterString, "' named parameter..."));
+                var expressionType = expression.getType();
+                if (this.type !== expressionType) {
+                    var message = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type  and '").concat(namedParameterString, "' named parameter's '").concat(this.type, "' type do not match."), exception = _exception.default.fromMessage(message);
                     throw exception;
                 }
-                context.debug("...matched the ".concat(valueString, " value against the '").concat(namedParameterString, "' named parameter."));
+                context.debug("...matched the ".concat(expressionString, " expression against the '").concat(namedParameterString, "' named parameter."));
             }
         },
         {
@@ -195,4 +195,4 @@ function asNameFromNamedParameterNode(namedParameterNode, context) {
     return asName;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/parameter/named.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../../dom\";\nimport Exception from \"../../exception\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { domAssigned } from \"../../dom\";\n\nconst typeTerminalNodeQuery = nodeQuery(\"/namedParameter/@type\"),\n      nameTerminalNodeQuery = nodeQuery(\"/namedParameter/@name[0]\"),\n      asNameTerminalNodeQuery = nodeQuery(\"/namedParameter/@name[1]\");\n\nexport default domAssigned(class NamedParameter {\n  constructor(string, type, name, asName) {\n    this.string = string;\n    this.type = type;\n    this.name = name;\n    this.asName = asName;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getAsName() {\n    return this.asName;\n  }\n\n  matchValue(value, context) {\n    const valueString = value.asString(context),\n          namedParameterString = this.string;  ///\n\n    context.trace(`Matching the ${valueString} value against the '${namedParameterString}' named parameter...`);\n\n    const valueType = value.getType();\n\n    if (this.type !== valueType) {\n      const message = `The ${valueString} value's '${valueType}' type  and '${namedParameterString}' named parameter's '${this.type}' type do not match.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    context.debug(`...matched the ${valueString} value against the '${namedParameterString}' named parameter.`);\n  }\n\n  matchNamedParameter(namedParameter, context) {\n    let namedParameterMatches;\n\n    const namedParameterA = this,  ///\n          namedParameterB = namedParameter; ///\n\n    const namedParameterAString = namedParameterA.getString(),\n          namedParameterBString = namedParameterB.getString();\n\n    context.trace(`Matching the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter...`);\n\n    const name = namedParameter.getName(),\n          type = namedParameter.getType();\n\n    namedParameterMatches = ((this.name === name) && (this.type === type));\n\n    if (namedParameterMatches) {\n      context.debug(`...matched the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter.`);\n    }\n\n    return namedParameterMatches;\n  }\n\n  static name = \"NamedParameter\";\n\n  static fromNamedParameterNode(namedParameterNode, context) {\n    const namedParameter = namedParameterFromNamedParameterNode(namedParameterNode, context);\n\n    return namedParameter;\n  }\n});\n\nfunction namedParameterFromNamedParameterNode(namedParameterNode, context) {\n  const { NamedParameter } = dom,\n        type = typeFromNamedParameterNode(namedParameterNode, context),\n        name = nameFromNamedParameterNode(namedParameterNode, context),\n        asName = asNameFromNamedParameterNode(namedParameterNode, context),\n        string = stringFromTypeNameAndAsName(type, name, asName, context),\n        namedParameter = new NamedParameter(string, type, name, asName);\n\n  return namedParameter;\n}\n\nfunction stringFromTypeNameAndAsName(type, name, asName, context) {\n  let string;\n\n  const typeString = type,  ///\n        nameString = name;  ///\n\n  string = `${typeString} ${nameString}`;\n\n  if (asName !== null) {\n    const asNameString = asName;  ///\n\n    string = `${string} As ${asNameString}`;\n  }\n\n  return string;\n}\n\n\nfunction typeFromNamedParameterNode(namedParameterNode, context) {\n  const typeTerminalNode = typeTerminalNodeQuery(namedParameterNode),\n        typeTerminalNodeContent = typeTerminalNode.getContent(),\n        type = typeTerminalNodeContent; ///\n\n  return type;\n}\n\nfunction nameFromNamedParameterNode(namedParameterNode, context) {\n  const nameTerminalNode = nameTerminalNodeQuery(namedParameterNode),\n        nameTerminalNodeContent = nameTerminalNode.getContent(),\n        name = nameTerminalNodeContent; ///\n\n  return name;\n}\n\nfunction asNameFromNamedParameterNode(namedParameterNode, context) {\n  let asName = null;\n\n  const asNameTerminalNode = asNameTerminalNodeQuery(namedParameterNode);\n\n  if (asNameTerminalNode !== null) {\n    const asNameTerminalNodeContent = asNameTerminalNode.getContent();\n\n    asName = asNameTerminalNodeContent; ///\n  }\n\n  return asName;\n}\n"],"names":["typeTerminalNodeQuery","nodeQuery","nameTerminalNodeQuery","asNameTerminalNodeQuery","domAssigned","NamedParameter","string","type","name","asName","getString","getType","getName","getAsName","matchValue","value","context","valueString","asString","namedParameterString","trace","valueType","message","exception","Exception","fromMessage","debug","matchNamedParameter","namedParameter","namedParameterMatches","namedParameterA","namedParameterB","namedParameterAString","namedParameterBString","fromNamedParameterNode","namedParameterNode","namedParameterFromNamedParameterNode","dom","typeFromNamedParameterNode","nameFromNamedParameterNode","asNameFromNamedParameterNode","stringFromTypeNameAndAsName","typeString","nameString","asNameString","typeTerminalNode","typeTerminalNodeContent","getContent","nameTerminalNode","nameTerminalNodeContent","asNameTerminalNode","asNameTerminalNodeContent"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/parameter/named.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../../dom\";\nimport Exception from \"../../exception\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { domAssigned } from \"../../dom\";\n\nconst typeTerminalNodeQuery = nodeQuery(\"/namedParameter/@type\"),\n      nameTerminalNodeQuery = nodeQuery(\"/namedParameter/@name[0]\"),\n      asNameTerminalNodeQuery = nodeQuery(\"/namedParameter/@name[1]\");\n\nexport default domAssigned(class NamedParameter {\n  constructor(string, type, name, asName) {\n    this.string = string;\n    this.type = type;\n    this.name = name;\n    this.asName = asName;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getAsName() {\n    return this.asName;\n  }\n\n  matchExpression(expression, context) {\n    const expressionString = expression.asString(context),\n          namedParameterString = this.string;  ///\n\n    context.trace(`Matching the ${expressionString} expression against the '${namedParameterString}' named parameter...`);\n\n    const expressionType = expression.getType();\n\n    if (this.type !== expressionType) {\n      const message = `The ${expressionString} expression's '${expressionType}' type  and '${namedParameterString}' named parameter's '${this.type}' type do not match.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    context.debug(`...matched the ${expressionString} expression against the '${namedParameterString}' named parameter.`);\n  }\n\n  matchNamedParameter(namedParameter, context) {\n    let namedParameterMatches;\n\n    const namedParameterA = this,  ///\n          namedParameterB = namedParameter; ///\n\n    const namedParameterAString = namedParameterA.getString(),\n          namedParameterBString = namedParameterB.getString();\n\n    context.trace(`Matching the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter...`);\n\n    const name = namedParameter.getName(),\n          type = namedParameter.getType();\n\n    namedParameterMatches = ((this.name === name) && (this.type === type));\n\n    if (namedParameterMatches) {\n      context.debug(`...matched the '${namedParameterAString}' named parameter against the '${namedParameterBString}' named parameter.`);\n    }\n\n    return namedParameterMatches;\n  }\n\n  static name = \"NamedParameter\";\n\n  static fromNamedParameterNode(namedParameterNode, context) {\n    const namedParameter = namedParameterFromNamedParameterNode(namedParameterNode, context);\n\n    return namedParameter;\n  }\n});\n\nfunction namedParameterFromNamedParameterNode(namedParameterNode, context) {\n  const { NamedParameter } = dom,\n        type = typeFromNamedParameterNode(namedParameterNode, context),\n        name = nameFromNamedParameterNode(namedParameterNode, context),\n        asName = asNameFromNamedParameterNode(namedParameterNode, context),\n        string = stringFromTypeNameAndAsName(type, name, asName, context),\n        namedParameter = new NamedParameter(string, type, name, asName);\n\n  return namedParameter;\n}\n\nfunction stringFromTypeNameAndAsName(type, name, asName, context) {\n  let string;\n\n  const typeString = type,  ///\n        nameString = name;  ///\n\n  string = `${typeString} ${nameString}`;\n\n  if (asName !== null) {\n    const asNameString = asName;  ///\n\n    string = `${string} As ${asNameString}`;\n  }\n\n  return string;\n}\n\n\nfunction typeFromNamedParameterNode(namedParameterNode, context) {\n  const typeTerminalNode = typeTerminalNodeQuery(namedParameterNode),\n        typeTerminalNodeContent = typeTerminalNode.getContent(),\n        type = typeTerminalNodeContent; ///\n\n  return type;\n}\n\nfunction nameFromNamedParameterNode(namedParameterNode, context) {\n  const nameTerminalNode = nameTerminalNodeQuery(namedParameterNode),\n        nameTerminalNodeContent = nameTerminalNode.getContent(),\n        name = nameTerminalNodeContent; ///\n\n  return name;\n}\n\nfunction asNameFromNamedParameterNode(namedParameterNode, context) {\n  let asName = null;\n\n  const asNameTerminalNode = asNameTerminalNodeQuery(namedParameterNode);\n\n  if (asNameTerminalNode !== null) {\n    const asNameTerminalNodeContent = asNameTerminalNode.getContent();\n\n    asName = asNameTerminalNodeContent; ///\n  }\n\n  return asName;\n}\n"],"names":["typeTerminalNodeQuery","nodeQuery","nameTerminalNodeQuery","asNameTerminalNodeQuery","domAssigned","NamedParameter","string","type","name","asName","getString","getType","getName","getAsName","matchExpression","expression","context","expressionString","asString","namedParameterString","trace","expressionType","message","exception","Exception","fromMessage","debug","matchNamedParameter","namedParameter","namedParameterMatches","namedParameterA","namedParameterB","namedParameterAString","namedParameterBString","fromNamedParameterNode","namedParameterNode","namedParameterFromNamedParameterNode","dom","typeFromNamedParameterNode","nameFromNamedParameterNode","asNameFromNamedParameterNode","stringFromTypeNameAndAsName","typeString","nameString","asNameString","typeTerminalNode","typeTerminalNodeContent","getContent","nameTerminalNode","nameTerminalNodeContent","asNameTerminalNode","asNameTerminalNodeContent"],"mappings":"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"}

package/lib/dom/parameter.js

@@ -118,16 +118,16 @@ var _default = (0, _dom.domAssigned)((_Parameter = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "matchValue",
-            value: function matchValue(value, context) {
-                var valueString = value.asString(context), parameterString = this.string; ///
-                context.trace("Matching the ".concat(valueString, " value against the '").concat(parameterString, "' parameter..."));
-                var valueType = value.getType();
-                if (this.type !== valueType) {
-                    var message = "The ".concat(valueString, " value's '").concat(valueType, "' type  and '").concat(parameterString, "' parameter's '").concat(this.type, "' type do not match."), exception = _exception.default.fromMessage(message);
+            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(valueString, " value against the '").concat(parameterString, "' parameter."));
+                context.debug("...matched the ".concat(expressionString, " expression against the '").concat(parameterString, "' parameter."));
             }
         }
     ], [
@@ -162,4 +162,4 @@ function typeFromParameterNode(parameterNode, context) {
     return type;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dom/parameters/named.js

@@ -137,22 +137,22 @@ var _default = (0, _dom.domAssigned)((_NamedParameters = /*#__PURE__*/ function(
             }
         },
         {
-            key: "matchValues",
-            value: function matchValues(values, context) {
-                var valuesString = values.getString(), namedParametersString = this.string; ///
-                context.trace("Matching the ".concat(valuesString, " values against the '").concat(namedParametersString, "' named parameters..."));
-                var valuesLength = values.getLength(), namedParametersLength = this.getLength();
-                if (valuesLength !== namedParametersLength) {
-                    var message = "The ".concat(valuesString, " values and '").concat(namedParametersString, "' named parameters are not of the same length."), exception = _exception.default.fromMessage(message);
+            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 value = values.getValue(index);
-                        namedParameter.matchValue(value, context);
+                        var expression = expressions.getExpression(index);
+                        namedParameter.matchExpression(expression, context);
                     }
                 });
-                context.debug("...matched the ".concat(valuesString, " values against the '").concat(namedParametersString, "' named parameters."));
+                context.debug("...matched the ".concat(expressionsString, " expressions against the '").concat(namedParametersString, "' named parameters."));
             }
         },
         {
@@ -217,4 +217,4 @@ function stringFromArray(array, context) {
     return string;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/parameters/named.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../../dom\";\nimport Exception from \"../../exception\";\n\nimport { domAssigned } from \"../../dom\";\nimport { nodeQuery, nodesQuery } from \"../../utilities/query\";\n\nconst namedParameterNodesQuery = nodesQuery(\"/namedParameters/namedParameter\"),\n      objectAssignmentNamedParametersNodeQuery = nodeQuery(\"/objectAssignment/namedParameters\");\n\nexport default domAssigned(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  matchValues(values, context) {\n    const valuesString = values.getString(),\n          namedParametersString = this.string; ///\n\n    context.trace(`Matching the ${valuesString} values against the '${namedParametersString}' named parameters...`);\n\n    const valuesLength = values.getLength(),\n          namedParametersLength = this.getLength();\n\n    if (valuesLength !== namedParametersLength) {\n      const message = `The ${valuesString} values 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 value = values.getValue(index);\n\n        namedParameter.matchValue(value, context);\n      }\n    });\n\n    context.debug(`...matched the ${valuesString} values 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 } = dom,\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 } = dom,\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","domAssigned","NamedParameters","string","array","getString","getArray","getLength","length","getNamedParameter","index","namedParameter","someNamedParameter","callback","some","forEachNamedParameter","forEach","matchValues","values","context","valuesString","namedParametersString","trace","valuesLength","namedParametersLength","message","exception","Exception","fromMessage","value","getValue","matchValue","debug","matchNamedParameter","namedParameterString","namedParameterA","namedParameterMatches","namedParameterB","namedParameterBMatchesNamedParameterA","matchNamedParameters","namedParameters","fromObjectAssignmentNode","objectAssignmentNode","objectAssignmentNamedParametersNode","namedParametersNode","namedParametersFromNamedParametersNode","name","dom","namedParameterNodes","arrayFromNamedParameterNodes","stringFromArray","NamedParameter","map","namedParameterNode","fromNamedParameterNode","namedParametersSString","reduce"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/parameters/named.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../../dom\";\nimport Exception from \"../../exception\";\n\nimport { domAssigned } from \"../../dom\";\nimport { nodeQuery, nodesQuery } from \"../../utilities/query\";\n\nconst namedParameterNodesQuery = nodesQuery(\"/namedParameters/namedParameter\"),\n      objectAssignmentNamedParametersNodeQuery = nodeQuery(\"/objectAssignment/namedParameters\");\n\nexport default domAssigned(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 } = dom,\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 } = dom,\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","domAssigned","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","dom","namedParameterNodes","arrayFromNamedParameterNodes","stringFromArray","NamedParameter","map","namedParameterNode","fromNamedParameterNode","namedParametersSString","reduce"],"mappings":"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"}

package/lib/dom/parameters.js

@@ -132,22 +132,22 @@ var _default = (0, _dom.domAssigned)((_Parameters = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "matchValues",
-            value: function matchValues(values, context) {
-                var valuesString = values.getString(), parametersString = this.string; ///
-                context.trace("Matching the ".concat(valuesString, " values against the '").concat(parametersString, "' parameters..."));
-                var valuesLength = values.getLength(), parametersLength = this.getLength();
-                if (valuesLength !== parametersLength) {
-                    var message = "The ".concat(valuesString, " values and '").concat(parametersString, "' parameters are not of the same length."), exception = _exception.default.fromMessage(message);
+            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 value = values.getValue(index);
-                        parameter.matchValue(value, context);
+                        var expression = expressions.getExpression(index);
+                        parameter.matchExpression(expression, context);
                     }
                 });
-                context.debug("...matched the ".concat(valuesString, " values against the '").concat(parametersString, "' parameters."));
+                context.debug("...matched the ".concat(expressionsString, " expressions against the '").concat(parametersString, "' parameters."));
             }
         }
     ], [
@@ -195,4 +195,4 @@ function stringFromArray(array, context) {
     return string;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/parameters.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport Exception from \"../exception\";\n\nimport { UNDERSCORE } from \"../constants\";\nimport { domAssigned } from \"../dom\";\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 domAssigned(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  matchValues(values, context) {\n    const valuesString = values.getString(),\n          parametersString = this.string; ///\n\n    context.trace(`Matching the ${valuesString} values against the '${parametersString}' parameters...`);\n\n    const valuesLength = values.getLength(),\n          parametersLength = this.getLength();\n\n    if (valuesLength !== parametersLength) {\n      const message = `The ${valuesString} values 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 value = values.getValue(index);\n\n        parameter.matchValue(value, context);\n      }\n    });\n\n    context.debug(`...matched the ${valuesString} values 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 } = dom,\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 } = dom,\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","domAssigned","Parameters","string","array","getString","getArray","getLength","length","getParameter","index","parameter","forEachParameter","callback","forEach","matchValues","values","context","valuesString","parametersString","trace","valuesLength","parametersLength","message","exception","Exception","fromMessage","value","getValue","matchValue","debug","fromArrayAssignmentNode","arrayAssignmentNode","arrayAssignmentParametersNode","parametersNode","parameters","parametersFromParametersNode","fromAnonymousProcedureNode","anonymousProcedureNode","anonymousProcedureParametersNode","fromProcedureDeclarationNode","procedureDeclarationNode","procedureDeclarationParametersNode","name","dom","arrayFromParametersNode","stringFromArray","parameterNodes","map","parameterNode","Parameter","fromParameterNode","reduce","parameterString","UNDERSCORE"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/parameters.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport Exception from \"../exception\";\n\nimport { UNDERSCORE } from \"../constants\";\nimport { domAssigned } from \"../dom\";\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 domAssigned(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 } = dom,\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 } = dom,\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","domAssigned","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","dom","arrayFromParametersNode","stringFromArray","parameterNodes","map","parameterNode","Parameter","fromParameterNode","reduce","parameterString","UNDERSCORE"],"mappings":"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"}