occam-furtle 2.0.279 → 2.0.282

package/lib/element/query/node.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _occamquery = require("occam-query");
+var _necessary = require("necessary");
+var _occamentities = require("occam-entities");
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../../exception"));
+var _types = require("../../types");
+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 _NodeQuery;
+var first = _necessary.arrayUtilities.first, trimDoubleQuotes = _occamentities.contentUtilities.trimDoubleQuotes;
+var expressionNodeQueryNodeQuery = (0, _query.nodeQuery)("/expression/nodeQuery"), stringLiteralTerminalNodeQuery = (0, _query.nodeQuery)("/nodeQuery/@string-literal");
+var _default = (0, _elements.define)((_NodeQuery = /*#__PURE__*/ function() {
+    function NodeQuery(string, variable, query) {
+        _class_call_check(this, NodeQuery);
+        this.string = string;
+        this.variable = variable;
+        this.query = query;
+    }
+    _create_class(NodeQuery, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getVariable",
+            value: function getVariable() {
+                return this.variable;
+            }
+        },
+        {
+            key: "getQuery",
+            value: function getQuery() {
+                return this.query;
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var expression;
+                var nodeQueryString = this.string; ///
+                context.trace("Evaluating the '".concat(nodeQueryString, "' node query..."));
+                if (this.query === null) {
+                    var message = "Cannot evaluate the '".concat(nodeQueryString, "' node query because its expression is malformed."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                expression = this.variable.evaluate(context);
+                var expressionType = expression.getType();
+                if (expressionType !== _types.NODE_TYPE) {
+                    var expressionString = expression.asString(context), message1 = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type should be '").concat(_types.NODE_TYPE, "'."), exception1 = _exception.default.fromMessage(message1);
+                    throw exception1;
+                }
+                var expressionNode = expression.getNode();
+                if (expressionNode === null) {
+                    var expressionString1 = expression.asString(context), message2 = "The ".concat(expressionString1, " expression's node is null."), exception2 = _exception.default.fromMessage(message2);
+                    throw exception2;
+                }
+                var node;
+                node = expressionNode; ///
+                var nodes = this.query.execute(node), nodesLength = nodes.length;
+                if (nodesLength !== 1) {
+                    var message3 = "The length of the returned nodes is ".concat(nodesLength, " when it should be 1."), exception3 = _exception.default.fromMessage(message3);
+                    throw exception3;
+                }
+                var firstNode = first(nodes);
+                node = firstNode; ///
+                var Expression = _elements.default.Expression;
+                expression = Expression.fromNode(node, context);
+                context.debug("...evaluated the '".concat(nodeQueryString, "' node query."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(expressionNode, context) {
+                var _$nodeQuery = null;
+                var expressionNodeQueryNode = expressionNodeQueryNodeQuery(expressionNode);
+                if (expressionNodeQueryNode !== null) {
+                    var nodeQueryNode = expressionNodeQueryNode; ///
+                    _$nodeQuery = nodeQueryFromNodeQueryNode(nodeQueryNode, context);
+                }
+                return _$nodeQuery;
+            }
+        }
+    ]);
+    return NodeQuery;
+}(), _define_property(_NodeQuery, "name", "NodeQuery"), _NodeQuery));
+function nodeQueryFromNodeQueryNode(nodeQueryNode, context) {
+    var Variable = _elements.default.Variable, NodeQuery = _elements.default.NodeQuery, node = nodeQueryNode, string = context.nodeAsString(node), expressionString = expressionStringFromNodeQueryNode(nodeQueryNode, context), variable = Variable.fromNodeQueryNode(nodeQueryNode, context), query = _occamquery.Query.fromExpressionString(expressionString), _$nodeQuery = new NodeQuery(string, variable, query);
+    return _$nodeQuery;
+}
+function expressionStringFromNodeQueryNode(nodeQueryNode, context) {
+    var stringLiteralTerminalNode = stringLiteralTerminalNodeQuery(nodeQueryNode), stringLiteralTerminalNodeContent = stringLiteralTerminalNode.getContent(), expressionString = trimDoubleQuotes(stringLiteralTerminalNodeContent);
+    return expressionString;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/query/node.js"],"sourcesContent":["\"use strict\";\n\nimport { Query } from \"occam-query\";\nimport { arrayUtilities } from \"necessary\";\nimport { contentUtilities } from \"occam-entities\";\n\nimport elements from \"../../elements\";\nimport Exception from \"../../exception\";\n\nimport { define } from \"../../elements\";\nimport { NODE_TYPE } from \"../../types\";\nimport { nodeQuery } from \"../../utilities/query\";\n\nconst { first } = arrayUtilities,\n      { trimDoubleQuotes } = contentUtilities;\n\nconst expressionNodeQueryNodeQuery = nodeQuery(\"/expression/nodeQuery\"),\n      stringLiteralTerminalNodeQuery = nodeQuery(\"/nodeQuery/@string-literal\");\n\nexport default define(class NodeQuery {\n  constructor(string, variable, query) {\n    this.string = string;\n    this.variable = variable;\n    this.query = query;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  getQuery() {\n    return this.query;\n  }\n\n  evaluate(context) {\n    let expression;\n\n    const nodeQueryString = this.string;  ///\n\n    context.trace(`Evaluating the '${nodeQueryString}' node query...`);\n\n    if (this.query === null) {\n      const message = `Cannot evaluate the '${nodeQueryString}' node query because its expression is malformed.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    expression = this.variable.evaluate(context);\n\n    const expressionType = expression.getType();\n\n    if (expressionType !== NODE_TYPE) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODE_TYPE}'.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const expressionNode = expression.getNode();\n\n    if (expressionNode === null) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's node is null.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    let node;\n\n    node = expressionNode; ///\n\n    const nodes = this.query.execute(node),\n          nodesLength = nodes.length;\n\n    if (nodesLength !== 1) {\n      const message = `The length of the returned nodes is ${nodesLength} when it should be 1.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const firstNode = first(nodes);\n\n    node = firstNode; ///\n\n    const { Expression } = elements;\n\n    expression = Expression.fromNode(node, context);\n\n    context.debug(`...evaluated the '${nodeQueryString}' node query.`);\n\n    return expression;\n  }\n\n  static name = \"NodeQuery\";\n\n  static fromExpressionNode(expressionNode, context) {\n    let nodeQuery = null;\n\n    const expressionNodeQueryNode = expressionNodeQueryNodeQuery(expressionNode);\n\n    if (expressionNodeQueryNode !== null) {\n      const nodeQueryNode = expressionNodeQueryNode; ///\n\n      nodeQuery = nodeQueryFromNodeQueryNode(nodeQueryNode, context);\n    }\n\n    return nodeQuery;\n  }\n});\n\nfunction nodeQueryFromNodeQueryNode(nodeQueryNode, context) {\n  const { Variable, NodeQuery } = elements,\n        node = nodeQueryNode, ///\n        string = context.nodeAsString(node),\n        expressionString = expressionStringFromNodeQueryNode(nodeQueryNode, context),\n        variable = Variable.fromNodeQueryNode(nodeQueryNode, context),\n        query = Query.fromExpressionString(expressionString),\n        nodeQuery = new NodeQuery(string, variable, query);\n\n  return nodeQuery;\n}\n\nfunction expressionStringFromNodeQueryNode(nodeQueryNode, context) {\n  const stringLiteralTerminalNode = stringLiteralTerminalNodeQuery(nodeQueryNode),\n        stringLiteralTerminalNodeContent = stringLiteralTerminalNode.getContent(),\n        expressionString = trimDoubleQuotes(stringLiteralTerminalNodeContent);\n\n  return expressionString;\n}\n"],"names":["first","arrayUtilities","trimDoubleQuotes","contentUtilities","expressionNodeQueryNodeQuery","nodeQuery","stringLiteralTerminalNodeQuery","define","NodeQuery","string","variable","query","getString","getVariable","getQuery","evaluate","context","expression","nodeQueryString","trace","message","exception","Exception","fromMessage","expressionType","getType","NODE_TYPE","expressionString","asString","expressionNode","getNode","node","nodes","execute","nodesLength","length","firstNode","Expression","elements","fromNode","debug","fromExpressionNode","expressionNodeQueryNode","nodeQueryNode","nodeQueryFromNodeQueryNode","name","Variable","nodeAsString","expressionStringFromNodeQueryNode","fromNodeQueryNode","Query","fromExpressionString","stringLiteralTerminalNode","stringLiteralTerminalNodeContent","getContent"],"mappings":"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"}

package/lib/element/query/nodes.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _occamquery = require("occam-query");
+var _occamentities = require("occam-entities");
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../../exception"));
+var _query = require("../../utilities/query");
+var _types = require("../../types");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _NodesQuery;
+var trimDoubleQuotes = _occamentities.contentUtilities.trimDoubleQuotes;
+var expressionNodesQueryNodeQuery = (0, _query.nodeQuery)("/expression/nodesQuery"), stringLiteralTerminalNodesQuery = (0, _query.nodeQuery)("/nodesQuery/@string-literal");
+var _default = (0, _elements.define)((_NodesQuery = /*#__PURE__*/ function() {
+    function NodesQuery(string, variable, query) {
+        _class_call_check(this, NodesQuery);
+        this.string = string;
+        this.variable = variable;
+        this.query = query;
+    }
+    _create_class(NodesQuery, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getVariable",
+            value: function getVariable() {
+                return this.variable;
+            }
+        },
+        {
+            key: "getQuery",
+            value: function getQuery() {
+                return this.query;
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var expression;
+                var nodesQueryString = this.string; ///
+                context.trace("Evaluating the '".concat(nodesQueryString, "' nodes query..."));
+                if (this.query === null) {
+                    var message = "Cannot evaluate the '".concat(nodesQueryString, "' nodes query because its expression is malformed."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                expression = this.variable.evaluate(context);
+                var expressionType = expression.getType();
+                if (expressionType !== _types.NODE_TYPE) {
+                    var expressionString = expression.asString(context), message1 = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type should be '").concat(_types.NODE_TYPE, "'."), exception1 = _exception.default.fromMessage(message1);
+                    throw exception1;
+                }
+                var expressionNode = expression.getNode();
+                if (expressionNode === null) {
+                    var expressionString1 = expression.asString(context), message2 = "The ".concat(expressionString1, " expression's node is null."), exception2 = _exception.default.fromMessage(message2);
+                    throw exception2;
+                }
+                var node;
+                node = expressionNode; ///
+                var nodes = this.query.execute(node);
+                var Expression = _elements.default.Expression;
+                expression = Expression.fromNodes(nodes, context);
+                context.debug("...evaluated the '".concat(nodesQueryString, "' nodes query."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(expressionNode, context) {
+                var nodesQuery = null;
+                var expressionNodesQueryNode = expressionNodesQueryNodeQuery(expressionNode);
+                if (expressionNodesQueryNode !== null) {
+                    var nodesQueryNode = expressionNodesQueryNode; ///
+                    nodesQuery = nodesQueryFromNodesQueryNode(nodesQueryNode, context);
+                }
+                return nodesQuery;
+            }
+        }
+    ]);
+    return NodesQuery;
+}(), _define_property(_NodesQuery, "name", "NodesQuery"), _NodesQuery));
+function nodesQueryFromNodesQueryNode(nodesQueryNode, context) {
+    var Variable = _elements.default.Variable, NodesQuery = _elements.default.NodesQuery, node = nodesQueryNode, string = context.nodeAsString(node), expressionString = expressionStringFromNodesQueryNode(nodesQueryNode, context), variable = Variable.fromNodesQueryNode(nodesQueryNode, context), query = _occamquery.Query.fromExpressionString(expressionString), nodesQuery = new NodesQuery(string, variable, query);
+    return nodesQuery;
+}
+function expressionStringFromNodesQueryNode(nodesQueryNode, context) {
+    var stringLiteralTerminalNode = stringLiteralTerminalNodesQuery(nodesQueryNode), stringLiteralTerminalNodeContent = stringLiteralTerminalNode.getContent(), expressionString = trimDoubleQuotes(stringLiteralTerminalNodeContent);
+    return expressionString;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/query/nodes.js"],"sourcesContent":["\"use strict\";\n\nimport { Query } from \"occam-query\";\nimport { contentUtilities } from \"occam-entities\";\n\nimport elements from \"../../elements\";\nimport Exception from \"../../exception\";\n\nimport { define } from \"../../elements\";\nimport { nodeQuery } from \"../../utilities/query\";\nimport { NODE_TYPE } from \"../../types\";\n\nconst { trimDoubleQuotes } = contentUtilities;\n\nconst expressionNodesQueryNodeQuery = nodeQuery(\"/expression/nodesQuery\"),\n      stringLiteralTerminalNodesQuery = nodeQuery(\"/nodesQuery/@string-literal\");\n\nexport default define(class NodesQuery {\n  constructor(string, variable, query) {\n    this.string = string;\n    this.variable = variable;\n    this.query = query;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  getQuery() {\n    return this.query;\n  }\n\n  evaluate(context) {\n    let expression;\n\n    const nodesQueryString = this.string;  ///\n\n    context.trace(`Evaluating the '${nodesQueryString}' nodes query...`);\n\n    if (this.query === null) {\n      const message = `Cannot evaluate the '${nodesQueryString}' nodes query because its expression is malformed.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    expression = this.variable.evaluate(context);\n\n    const expressionType = expression.getType();\n\n    if (expressionType !== NODE_TYPE) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODE_TYPE}'.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const expressionNode = expression.getNode();\n\n    if (expressionNode === null) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's node is null.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    let node;\n\n    node = expressionNode; ///\n\n    const nodes = this.query.execute(node);\n\n    const { Expression } = elements;\n\n    expression = Expression.fromNodes(nodes, context);\n\n    context.debug(`...evaluated the '${nodesQueryString}' nodes query.`);\n\n    return expression;\n  }\n\n  static name = \"NodesQuery\";\n\n  static fromExpressionNode(expressionNode, context) {\n    let nodesQuery = null;\n\n    const expressionNodesQueryNode = expressionNodesQueryNodeQuery(expressionNode);\n\n    if (expressionNodesQueryNode !== null) {\n      const nodesQueryNode = expressionNodesQueryNode; ///\n\n      nodesQuery = nodesQueryFromNodesQueryNode(nodesQueryNode, context);\n    }\n\n    return nodesQuery;\n  }\n});\n\nfunction nodesQueryFromNodesQueryNode(nodesQueryNode, context) {\n  const { Variable, NodesQuery } = elements,\n        node = nodesQueryNode,  ///\n        string = context.nodeAsString(node),\n        expressionString = expressionStringFromNodesQueryNode(nodesQueryNode, context),\n        variable = Variable.fromNodesQueryNode(nodesQueryNode, context),\n        query = Query.fromExpressionString(expressionString),\n        nodesQuery = new NodesQuery(string, variable, query);\n\n  return nodesQuery;\n}\n\nfunction expressionStringFromNodesQueryNode(nodesQueryNode, context) {\n  const stringLiteralTerminalNode = stringLiteralTerminalNodesQuery(nodesQueryNode),\n        stringLiteralTerminalNodeContent = stringLiteralTerminalNode.getContent(),\n        expressionString = trimDoubleQuotes(stringLiteralTerminalNodeContent);\n\n  return expressionString;\n}\n"],"names":["trimDoubleQuotes","contentUtilities","expressionNodesQueryNodeQuery","nodeQuery","stringLiteralTerminalNodesQuery","define","NodesQuery","string","variable","query","getString","getVariable","getQuery","evaluate","context","expression","nodesQueryString","trace","message","exception","Exception","fromMessage","expressionType","getType","NODE_TYPE","expressionString","asString","expressionNode","getNode","node","nodes","execute","Expression","elements","fromNodes","debug","fromExpressionNode","nodesQuery","expressionNodesQueryNode","nodesQueryNode","nodesQueryFromNodesQueryNode","name","Variable","nodeAsString","expressionStringFromNodesQueryNode","fromNodesQueryNode","Query","fromExpressionString","stringLiteralTerminalNode","stringLiteralTerminalNodeContent","getContent"],"mappings":"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"}

package/lib/element/reduce.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../elements"));
+var _exception = /*#__PURE__*/ _interop_require_default(require("../exception"));
+var _query = require("../utilities/query");
+var _types = require("../types");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Reduce;
+var expressionReduceNodeQuery = (0, _query.nodeQuery)("/expression/reduce");
+var _default = (0, _elements.define)((_Reduce = /*#__PURE__*/ function() {
+    function Reduce(string, variable, initialExpression, anonymousProcedure) {
+        _class_call_check(this, Reduce);
+        this.string = string;
+        this.variable = variable;
+        this.initialExpression = initialExpression;
+        this.anonymousProcedure = anonymousProcedure;
+    }
+    _create_class(Reduce, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getVariable",
+            value: function getVariable() {
+                return this.variable;
+            }
+        },
+        {
+            key: "getInitialExpression",
+            value: function getInitialExpression() {
+                return this.initialExpression;
+            }
+        },
+        {
+            key: "getAnonymousProcedure",
+            value: function getAnonymousProcedure() {
+                return this.anonymousProcedure;
+            }
+        },
+        {
+            key: "evaluate",
+            value: function evaluate(context) {
+                var _this = this;
+                var expression;
+                var reduceString = this.getString();
+                context.trace("Evaluating the '".concat(reduceString, "' reduce..."));
+                expression = this.variable.evaluate(context);
+                var expressionType = expression.getType();
+                if (expressionType !== _types.NODES_TYPE) {
+                    var expressionString = expression.asString(context), message = "The ".concat(expressionString, " expression's '").concat(expressionType, "' type should be '").concat(_types.NODES_TYPE, "'."), exception = _exception.default.fromMessage(message);
+                    throw exception;
+                }
+                var nodes = expression.getNodes(), initialExpression = this.initialExpression.evaluate(context);
+                expression = nodes.reduce(function(currentExpression, node) {
+                    var expression;
+                    var Expression = _elements.default.Expression, Expressions = _elements.default.Expressions;
+                    expression = currentExpression; ///
+                    var expressions = Expressions.fromExpression(expression, context);
+                    expression = Expression.fromNode(node, context);
+                    expressions.addExpression(expression);
+                    expression = _this.anonymousProcedure.call(expressions, context);
+                    return expression;
+                }, initialExpression);
+                context.trace("...evaluated the '".concat(reduceString, "' reduce."));
+                return expression;
+            }
+        }
+    ], [
+        {
+            key: "fromExpressionNode",
+            value: function fromExpressionNode(expressionNode, context) {
+                var reduce = null;
+                var expressionReduceNode = expressionReduceNodeQuery(expressionNode);
+                if (expressionReduceNode !== null) {
+                    var reduceNode = expressionReduceNode; ///
+                    reduce = reduceFromReduceNode(reduceNode, context);
+                }
+                return reduce;
+            }
+        }
+    ]);
+    return Reduce;
+}(), _define_property(_Reduce, "name", "Reduce"), _Reduce));
+function reduceFromReduceNode(reduceNode, context) {
+    var Reduce = _elements.default.Reduce, Variable = _elements.default.Variable, Expression = _elements.default.Expression, AnonymousProcedure = _elements.default.AnonymousProcedure, expression = Expression.fromReduceNode(reduceNode, context), variable = Variable.fromReduceNode(reduceNode, context), initialExpression = expression, anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context), string = stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure), reduce = new Reduce(string, variable, initialExpression, anonymousProcedure);
+    return reduce;
+}
+function stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure) {
+    var variableString = variable.getString(), initialExpressionString = initialExpression.getString(), anonymousProcedureString = anonymousProcedure.getString(), string = "Reduce(".concat(variableString, ", ").concat(anonymousProcedureString, ", ").concat(initialExpressionString, ")");
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/reduce.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\nimport Exception from \"../exception\";\n\nimport { define } from \"../elements\";\nimport { nodeQuery } from \"../utilities/query\";\nimport { NODES_TYPE } from \"../types\";\n\nconst expressionReduceNodeQuery = nodeQuery(\"/expression/reduce\");\n\nexport default define(class Reduce {\n  constructor(string, variable, initialExpression, anonymousProcedure) {\n    this.string = string;\n    this.variable = variable;\n    this.initialExpression = initialExpression;\n    this.anonymousProcedure = anonymousProcedure;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  getInitialExpression() {\n    return this.initialExpression;\n  }\n\n  getAnonymousProcedure() {\n    return this.anonymousProcedure;\n  }\n\n  evaluate(context) {\n    let expression;\n\n    const reduceString = this.getString();\n\n    context.trace(`Evaluating the '${reduceString}' reduce...`);\n\n    expression = this.variable.evaluate(context);\n\n    const expressionType = expression.getType();\n\n    if (expressionType !== NODES_TYPE) {\n      const expressionString = expression.asString(context),\n            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODES_TYPE}'.`,\n            exception = Exception.fromMessage(message);\n\n      throw exception;\n    }\n\n    const nodes = expression.getNodes(),\n          initialExpression = this.initialExpression.evaluate(context);\n\n    expression = nodes.reduce((currentExpression, node) => {\n      let expression;\n\n      const { Expression, Expressions } = elements;\n\n      expression = currentExpression; ///\n\n      const expressions = Expressions.fromExpression(expression, context);\n\n      expression = Expression.fromNode(node, context);\n\n      expressions.addExpression(expression);\n\n      expression = this.anonymousProcedure.call(expressions, context);\n\n      return expression;\n    }, initialExpression);\n\n    context.trace(`...evaluated the '${reduceString}' reduce.`);\n\n    return expression;\n  }\n\n  static name = \"Reduce\";\n\n  static fromExpressionNode(expressionNode, context) {\n    let reduce = null;\n\n    const expressionReduceNode = expressionReduceNodeQuery(expressionNode);\n\n    if (expressionReduceNode !== null) {\n      const reduceNode = expressionReduceNode; ///\n\n      reduce = reduceFromReduceNode(reduceNode, context);\n    }\n\n    return reduce;\n  }\n});\n\nfunction reduceFromReduceNode(reduceNode, context) {\n  const { Reduce, Variable, Expression, AnonymousProcedure } = elements,\n        expression = Expression.fromReduceNode(reduceNode, context),\n        variable = Variable.fromReduceNode(reduceNode, context),\n        initialExpression = expression, ///\n        anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context),\n        string = stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure),\n        reduce = new Reduce(string, variable, initialExpression, anonymousProcedure);\n\n  return reduce;\n}\n\nfunction stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure) {\n  const variableString = variable.getString(),\n        initialExpressionString = initialExpression.getString(),\n        anonymousProcedureString = anonymousProcedure.getString(),\n        string = `Reduce(${variableString}, ${anonymousProcedureString}, ${initialExpressionString})`;\n\n  return string;\n}\n"],"names":["expressionReduceNodeQuery","nodeQuery","define","Reduce","string","variable","initialExpression","anonymousProcedure","getString","getVariable","getInitialExpression","getAnonymousProcedure","evaluate","context","expression","reduceString","trace","expressionType","getType","NODES_TYPE","expressionString","asString","message","exception","Exception","fromMessage","nodes","getNodes","reduce","currentExpression","node","Expression","elements","Expressions","expressions","fromExpression","fromNode","addExpression","call","fromExpressionNode","expressionNode","expressionReduceNode","reduceNode","reduceFromReduceNode","name","Variable","AnonymousProcedure","fromReduceNode","stringFromVariableInitialExpressionAndAnonymousProcedure","variableString","initialExpressionString","anonymousProcedureString"],"mappings":"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"}