@verbb/plugin-kit-react 1.0.10 → 2.0.0

package/dist/node_modules/jexl/dist/Lexer.js

@@ -1,152 +0,0 @@
-import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
-import { require_interopRequireDefault } from "../../@babel/runtime/helpers/interopRequireDefault.js";
-import { require_classCallCheck } from "../../@babel/runtime/helpers/classCallCheck.js";
-import { require_createClass } from "../../@babel/runtime/helpers/createClass.js";
-//#region ../node_modules/jexl/dist/Lexer.js
-var require_Lexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/;
-	var identRegex = /^[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][a-zA-Zа-яА-Я0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*$/;
-	var escEscRegex = /\\\\/;
-	var whitespaceRegex = /^\s*$/;
-	var preOpRegexElems = [
-		"'(?:(?:\\\\')|[^'])*'",
-		"\"(?:(?:\\\\\")|[^\"])*\"",
-		"\\s+",
-		"\\btrue\\b",
-		"\\bfalse\\b"
-	];
-	var postOpRegexElems = ["[a-zA-Zа-яА-Я_À-ÖØ-öø-ÿ\\$][a-zA-Z0-9а-яА-Я_À-ÖØ-öø-ÿ\\$]*", "(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)"];
-	var minusNegatesAfter = [
-		"binaryOp",
-		"unaryOp",
-		"openParen",
-		"openBracket",
-		"question",
-		"colon"
-	];
-	module.exports = /* @__PURE__ */ function() {
-		function Lexer(grammar) {
-			(0, _classCallCheck2.default)(this, Lexer);
-			this._grammar = grammar;
-		}
-		/**
-		* Splits a Jexl expression string into an array of expression elements.
-		* @param {string} str A Jexl expression string
-		* @returns {Array<string>} An array of substrings defining the functional
-		*      elements of the expression.
-		*/
-		(0, _createClass2.default)(Lexer, [
-			{
-				key: "getElements",
-				value: function getElements(str) {
-					var regex = this._getSplitRegex();
-					return str.split(regex).filter(function(elem) {
-						return elem;
-					});
-				}
-			},
-			{
-				key: "getTokens",
-				value: function getTokens(elements) {
-					var tokens = [];
-					var negate = false;
-					for (var i = 0; i < elements.length; i++) if (this._isWhitespace(elements[i])) {
-						if (tokens.length) tokens[tokens.length - 1].raw += elements[i];
-					} else if (elements[i] === "-" && this._isNegative(tokens)) negate = true;
-					else {
-						if (negate) {
-							elements[i] = "-" + elements[i];
-							negate = false;
-						}
-						tokens.push(this._createToken(elements[i]));
-					}
-					if (negate) tokens.push(this._createToken("-"));
-					return tokens;
-				}
-			},
-			{
-				key: "tokenize",
-				value: function tokenize(str) {
-					var elements = this.getElements(str);
-					return this.getTokens(elements);
-				}
-			},
-			{
-				key: "_createToken",
-				value: function _createToken(element) {
-					var token = {
-						type: "literal",
-						value: element,
-						raw: element
-					};
-					if (element[0] === "\"" || element[0] === "'") token.value = this._unquote(element);
-					else if (element.match(numericRegex)) token.value = parseFloat(element);
-					else if (element === "true" || element === "false") token.value = element === "true";
-					else if (this._grammar.elements[element]) token.type = this._grammar.elements[element].type;
-					else if (element.match(identRegex)) token.type = "identifier";
-					else throw new Error("Invalid expression token: ".concat(element));
-					return token;
-				}
-			},
-			{
-				key: "_escapeRegExp",
-				value: function _escapeRegExp(str) {
-					str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-					if (str.match(identRegex)) str = "\\b" + str + "\\b";
-					return str;
-				}
-			},
-			{
-				key: "_getSplitRegex",
-				value: function _getSplitRegex() {
-					var _this = this;
-					if (!this._splitRegex) {
-						var elemArray = Object.keys(this._grammar.elements).sort(function(a, b) {
-							return b.length - a.length;
-						}).map(function(elem) {
-							return _this._escapeRegExp(elem);
-						}, this);
-						this._splitRegex = new RegExp("(" + [
-							preOpRegexElems.join("|"),
-							elemArray.join("|"),
-							postOpRegexElems.join("|")
-						].join("|") + ")");
-					}
-					return this._splitRegex;
-				}
-			},
-			{
-				key: "_isNegative",
-				value: function _isNegative(tokens) {
-					if (!tokens.length) return true;
-					return minusNegatesAfter.some(function(type) {
-						return type === tokens[tokens.length - 1].type;
-					});
-				}
-			},
-			{
-				key: "_isWhitespace",
-				value: function _isWhitespace(str) {
-					return !!str.match(whitespaceRegex);
-				}
-			},
-			{
-				key: "_unquote",
-				value: function _unquote(str) {
-					var quote = str[0];
-					var escQuoteRegex = new RegExp("\\\\" + quote, "g");
-					return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, "\\");
-				}
-			}
-		]);
-		return Lexer;
-	}();
-}));
-//#endregion
-export default require_Lexer();
-export { require_Lexer };
-
-//# sourceMappingURL=Lexer.js.map

package/dist/node_modules/jexl/dist/Lexer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Lexer.js","names":[],"sources":["../../../../../node_modules/jexl/dist/Lexer.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar numericRegex = /^-?(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)$/;\nvar identRegex = /^[a-zA-Zа-яА-Я_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u00FF$][a-zA-Zа-яА-Я0-9_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u00FF$]*$/;\nvar escEscRegex = /\\\\\\\\/;\nvar whitespaceRegex = /^\\s*$/;\nvar preOpRegexElems = [// Strings\n\"'(?:(?:\\\\\\\\')|[^'])*'\", '\"(?:(?:\\\\\\\\\")|[^\"])*\"', // Whitespace\n'\\\\s+', // Booleans\n'\\\\btrue\\\\b', '\\\\bfalse\\\\b'];\nvar postOpRegexElems = [// Identifiers\n\"[a-zA-Z\\u0430-\\u044F\\u0410-\\u042F_\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\xFF\\\\$][a-zA-Z0-9\\u0430-\\u044F\\u0410-\\u042F_\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\xFF\\\\$]*\", // Numerics (without negative symbol)\n'(?:(?:[0-9]*\\\\.[0-9]+)|[0-9]+)'];\nvar minusNegatesAfter = ['binaryOp', 'unaryOp', 'openParen', 'openBracket', 'question', 'colon'];\n/**\n * Lexer is a collection of stateless, statically-accessed functions for the\n * lexical parsing of a Jexl string.  Its responsibility is to identify the\n * \"parts of speech\" of a Jexl expression, and tokenize and label each, but\n * to do only the most minimal syntax checking; the only errors the Lexer\n * should be concerned with are if it's unable to identify the utility of\n * any of its tokens.  Errors stemming from these tokens not being in a\n * sensible configuration should be left for the Parser to handle.\n * @type {{}}\n */\n\nvar Lexer = /*#__PURE__*/function () {\n  function Lexer(grammar) {\n    (0, _classCallCheck2.default)(this, Lexer);\n    this._grammar = grammar;\n  }\n  /**\n   * Splits a Jexl expression string into an array of expression elements.\n   * @param {string} str A Jexl expression string\n   * @returns {Array<string>} An array of substrings defining the functional\n   *      elements of the expression.\n   */\n\n\n  (0, _createClass2.default)(Lexer, [{\n    key: \"getElements\",\n    value: function getElements(str) {\n      var regex = this._getSplitRegex();\n\n      return str.split(regex).filter(function (elem) {\n        // Remove empty strings\n        return elem;\n      });\n    }\n    /**\n     * Converts an array of expression elements into an array of tokens.  Note that\n     * the resulting array may not equal the element array in length, as any\n     * elements that consist only of whitespace get appended to the previous\n     * token's \"raw\" property.  For the structure of a token object, please see\n     * {@link Lexer#tokenize}.\n     * @param {Array<string>} elements An array of Jexl expression elements to be\n     *      converted to tokens\n     * @returns {Array<{type, value, raw}>} an array of token objects.\n     */\n\n  }, {\n    key: \"getTokens\",\n    value: function getTokens(elements) {\n      var tokens = [];\n      var negate = false;\n\n      for (var i = 0; i < elements.length; i++) {\n        if (this._isWhitespace(elements[i])) {\n          if (tokens.length) {\n            tokens[tokens.length - 1].raw += elements[i];\n          }\n        } else if (elements[i] === '-' && this._isNegative(tokens)) {\n          negate = true;\n        } else {\n          if (negate) {\n            elements[i] = '-' + elements[i];\n            negate = false;\n          }\n\n          tokens.push(this._createToken(elements[i]));\n        }\n      } // Catch a - at the end of the string. Let the parser handle that issue.\n\n\n      if (negate) {\n        tokens.push(this._createToken('-'));\n      }\n\n      return tokens;\n    }\n    /**\n     * Converts a Jexl string into an array of tokens.  Each token is an object\n     * in the following format:\n     *\n     *     {\n     *         type: <string>,\n     *         [name]: <string>,\n     *         value: <boolean|number|string>,\n     *         raw: <string>\n     *     }\n     *\n     * Type is one of the following:\n     *\n     *      literal, identifier, binaryOp, unaryOp\n     *\n     * OR, if the token is a control character its type is the name of the element\n     * defined in the Grammar.\n     *\n     * Name appears only if the token is a control string found in\n     * {@link grammar#elements}, and is set to the name of the element.\n     *\n     * Value is the value of the token in the correct type (boolean or numeric as\n     * appropriate). Raw is the string representation of this value taken directly\n     * from the expression string, including any trailing spaces.\n     * @param {string} str The Jexl string to be tokenized\n     * @returns {Array<{type, value, raw}>} an array of token objects.\n     * @throws {Error} if the provided string contains an invalid token.\n     */\n\n  }, {\n    key: \"tokenize\",\n    value: function tokenize(str) {\n      var elements = this.getElements(str);\n      return this.getTokens(elements);\n    }\n    /**\n     * Creates a new token object from an element of a Jexl string. See\n     * {@link Lexer#tokenize} for a description of the token object.\n     * @param {string} element The element from which a token should be made\n     * @returns {{value: number|boolean|string, [name]: string, type: string,\n     *      raw: string}} a token object describing the provided element.\n     * @throws {Error} if the provided string is not a valid expression element.\n     * @private\n     */\n\n  }, {\n    key: \"_createToken\",\n    value: function _createToken(element) {\n      var token = {\n        type: 'literal',\n        value: element,\n        raw: element\n      };\n\n      if (element[0] === '\"' || element[0] === \"'\") {\n        token.value = this._unquote(element);\n      } else if (element.match(numericRegex)) {\n        token.value = parseFloat(element);\n      } else if (element === 'true' || element === 'false') {\n        token.value = element === 'true';\n      } else if (this._grammar.elements[element]) {\n        token.type = this._grammar.elements[element].type;\n      } else if (element.match(identRegex)) {\n        token.type = 'identifier';\n      } else {\n        throw new Error(\"Invalid expression token: \".concat(element));\n      }\n\n      return token;\n    }\n    /**\n     * Escapes a string so that it can be treated as a string literal within a\n     * regular expression.\n     * @param {string} str The string to be escaped\n     * @returns {string} the RegExp-escaped string.\n     * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions\n     * @private\n     */\n\n  }, {\n    key: \"_escapeRegExp\",\n    value: function _escapeRegExp(str) {\n      str = str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n      if (str.match(identRegex)) {\n        str = '\\\\b' + str + '\\\\b';\n      }\n\n      return str;\n    }\n    /**\n     * Gets a RegEx object appropriate for splitting a Jexl string into its core\n     * elements.\n     * @returns {RegExp} An element-splitting RegExp object\n     * @private\n     */\n\n  }, {\n    key: \"_getSplitRegex\",\n    value: function _getSplitRegex() {\n      var _this = this;\n\n      if (!this._splitRegex) {\n        // Sort by most characters to least, then regex escape each\n        var elemArray = Object.keys(this._grammar.elements).sort(function (a, b) {\n          return b.length - a.length;\n        }).map(function (elem) {\n          return _this._escapeRegExp(elem);\n        }, this);\n        this._splitRegex = new RegExp('(' + [preOpRegexElems.join('|'), elemArray.join('|'), postOpRegexElems.join('|')].join('|') + ')');\n      }\n\n      return this._splitRegex;\n    }\n    /**\n     * Determines whether the addition of a '-' token should be interpreted as a\n     * negative symbol for an upcoming number, given an array of tokens already\n     * processed.\n     * @param {Array<Object>} tokens An array of tokens already processed\n     * @returns {boolean} true if adding a '-' should be considered a negative\n     *      symbol; false otherwise\n     * @private\n     */\n\n  }, {\n    key: \"_isNegative\",\n    value: function _isNegative(tokens) {\n      if (!tokens.length) return true;\n      return minusNegatesAfter.some(function (type) {\n        return type === tokens[tokens.length - 1].type;\n      });\n    }\n    /**\n     * A utility function to determine if a string consists of only space\n     * characters.\n     * @param {string} str A string to be tested\n     * @returns {boolean} true if the string is empty or consists of only spaces;\n     *      false otherwise.\n     * @private\n     */\n\n  }, {\n    key: \"_isWhitespace\",\n    value: function _isWhitespace(str) {\n      return !!str.match(whitespaceRegex);\n    }\n    /**\n     * Removes the beginning and trailing quotes from a string, unescapes any\n     * escaped quotes on its interior, and unescapes any escaped escape\n     * characters. Note that this function is not defensive; it assumes that the\n     * provided string is not empty, and that its first and last characters are\n     * actually quotes.\n     * @param {string} str A string whose first and last characters are quotes\n     * @returns {string} a string with the surrounding quotes stripped and escapes\n     *      properly processed.\n     * @private\n     */\n\n  }, {\n    key: \"_unquote\",\n    value: function _unquote(str) {\n      var quote = str[0];\n      var escQuoteRegex = new RegExp('\\\\\\\\' + quote, 'g');\n      return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, '\\\\');\n    }\n  }]);\n  return Lexer;\n}();\n\nmodule.exports = Lexer;"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/jexl/dist/PromiseSync.js

@@ -1,87 +0,0 @@
-import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
-import { require_interopRequireDefault } from "../../@babel/runtime/helpers/interopRequireDefault.js";
-import { require_classCallCheck } from "../../@babel/runtime/helpers/classCallCheck.js";
-import { require_createClass } from "../../@babel/runtime/helpers/createClass.js";
-//#region ../node_modules/jexl/dist/PromiseSync.js
-var require_PromiseSync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var PromiseSync = /* @__PURE__ */ function() {
-		function PromiseSync(fn) {
-			(0, _classCallCheck2.default)(this, PromiseSync);
-			fn(this._resolve.bind(this), this._reject.bind(this));
-		}
-		(0, _createClass2.default)(PromiseSync, [
-			{
-				key: "catch",
-				value: function _catch(rejected) {
-					if (this.error) try {
-						this._resolve(rejected(this.error));
-					} catch (e) {
-						this._reject(e);
-					}
-					return this;
-				}
-			},
-			{
-				key: "then",
-				value: function then(resolved, rejected) {
-					if (!this.error) try {
-						this._resolve(resolved(this.value));
-					} catch (e) {
-						this._reject(e);
-					}
-					if (rejected) this.catch(rejected);
-					return this;
-				}
-			},
-			{
-				key: "_reject",
-				value: function _reject(error) {
-					this.value = void 0;
-					this.error = error;
-				}
-			},
-			{
-				key: "_resolve",
-				value: function _resolve(val) {
-					if (val instanceof PromiseSync) if (val.error) this._reject(val.error);
-					else this._resolve(val.value);
-					else {
-						this.value = val;
-						this.error = void 0;
-					}
-				}
-			}
-		]);
-		return PromiseSync;
-	}();
-	PromiseSync.all = function(vals) {
-		return new PromiseSync(function(resolve) {
-			resolve(vals.map(function(val) {
-				while (val instanceof PromiseSync) {
-					if (val.error) throw Error(val.error);
-					val = val.value;
-				}
-				return val;
-			}));
-		});
-	};
-	PromiseSync.resolve = function(val) {
-		return new PromiseSync(function(resolve) {
-			return resolve(val);
-		});
-	};
-	PromiseSync.reject = function(error) {
-		return new PromiseSync(function(resolve, reject) {
-			return reject(error);
-		});
-	};
-	module.exports = PromiseSync;
-}));
-//#endregion
-export default require_PromiseSync();
-export { require_PromiseSync };
-
-//# sourceMappingURL=PromiseSync.js.map

package/dist/node_modules/jexl/dist/PromiseSync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PromiseSync.js","names":[],"sources":["../../../../../node_modules/jexl/dist/PromiseSync.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar PromiseSync = /*#__PURE__*/function () {\n  function PromiseSync(fn) {\n    (0, _classCallCheck2.default)(this, PromiseSync);\n    fn(this._resolve.bind(this), this._reject.bind(this));\n  }\n\n  (0, _createClass2.default)(PromiseSync, [{\n    key: \"catch\",\n    value: function _catch(rejected) {\n      if (this.error) {\n        try {\n          this._resolve(rejected(this.error));\n        } catch (e) {\n          this._reject(e);\n        }\n      }\n\n      return this;\n    }\n  }, {\n    key: \"then\",\n    value: function then(resolved, rejected) {\n      if (!this.error) {\n        try {\n          this._resolve(resolved(this.value));\n        } catch (e) {\n          this._reject(e);\n        }\n      }\n\n      if (rejected) this.catch(rejected);\n      return this;\n    }\n  }, {\n    key: \"_reject\",\n    value: function _reject(error) {\n      this.value = undefined;\n      this.error = error;\n    }\n  }, {\n    key: \"_resolve\",\n    value: function _resolve(val) {\n      if (val instanceof PromiseSync) {\n        if (val.error) {\n          this._reject(val.error);\n        } else {\n          this._resolve(val.value);\n        }\n      } else {\n        this.value = val;\n        this.error = undefined;\n      }\n    }\n  }]);\n  return PromiseSync;\n}();\n\nPromiseSync.all = function (vals) {\n  return new PromiseSync(function (resolve) {\n    var resolved = vals.map(function (val) {\n      while (val instanceof PromiseSync) {\n        if (val.error) throw Error(val.error);\n        val = val.value;\n      }\n\n      return val;\n    });\n    resolve(resolved);\n  });\n};\n\nPromiseSync.resolve = function (val) {\n  return new PromiseSync(function (resolve) {\n    return resolve(val);\n  });\n};\n\nPromiseSync.reject = function (error) {\n  return new PromiseSync(function (resolve, reject) {\n    return reject(error);\n  });\n};\n\nmodule.exports = PromiseSync;"],"x_google_ignoreList":[0],"mappings":";;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,cAA2B,2BAAY;EACzC,SAAS,YAAY,IAAI;AACvB,IAAC,GAAG,iBAAiB,SAAS,MAAM,YAAY;AAChD,MAAG,KAAK,SAAS,KAAK,KAAK,EAAE,KAAK,QAAQ,KAAK,KAAK,CAAC;;AAGvD,GAAC,GAAG,cAAc,SAAS,aAAa;GAAC;IACvC,KAAK;IACL,OAAO,SAAS,OAAO,UAAU;AAC/B,SAAI,KAAK,MACP,KAAI;AACF,WAAK,SAAS,SAAS,KAAK,MAAM,CAAC;cAC5B,GAAG;AACV,WAAK,QAAQ,EAAE;;AAInB,YAAO;;IAEV;GAAE;IACD,KAAK;IACL,OAAO,SAAS,KAAK,UAAU,UAAU;AACvC,SAAI,CAAC,KAAK,MACR,KAAI;AACF,WAAK,SAAS,SAAS,KAAK,MAAM,CAAC;cAC5B,GAAG;AACV,WAAK,QAAQ,EAAE;;AAInB,SAAI,SAAU,MAAK,MAAM,SAAS;AAClC,YAAO;;IAEV;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ,OAAO;AAC7B,UAAK,QAAQ,KAAA;AACb,UAAK,QAAQ;;IAEhB;GAAE;IACD,KAAK;IACL,OAAO,SAAS,SAAS,KAAK;AAC5B,SAAI,eAAe,YACjB,KAAI,IAAI,MACN,MAAK,QAAQ,IAAI,MAAM;SAEvB,MAAK,SAAS,IAAI,MAAM;UAErB;AACL,WAAK,QAAQ;AACb,WAAK,QAAQ,KAAA;;;IAGlB;GAAC,CAAC;AACH,SAAO;IACN;AAEH,aAAY,MAAM,SAAU,MAAM;AAChC,SAAO,IAAI,YAAY,SAAU,SAAS;AASxC,WARe,KAAK,IAAI,SAAU,KAAK;AACrC,WAAO,eAAe,aAAa;AACjC,SAAI,IAAI,MAAO,OAAM,MAAM,IAAI,MAAM;AACrC,WAAM,IAAI;;AAGZ,WAAO;KAEO,CAAC;IACjB;;AAGJ,aAAY,UAAU,SAAU,KAAK;AACnC,SAAO,IAAI,YAAY,SAAU,SAAS;AACxC,UAAO,QAAQ,IAAI;IACnB;;AAGJ,aAAY,SAAS,SAAU,OAAO;AACpC,SAAO,IAAI,YAAY,SAAU,SAAS,QAAQ;AAChD,UAAO,OAAO,MAAM;IACpB;;AAGJ,QAAO,UAAU"}

package/dist/node_modules/jexl/dist/evaluator/Evaluator.js

@@ -1,98 +0,0 @@
-import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
-import { require_interopRequireDefault } from "../../../@babel/runtime/helpers/interopRequireDefault.js";
-import { require_classCallCheck } from "../../../@babel/runtime/helpers/classCallCheck.js";
-import { require_createClass } from "../../../@babel/runtime/helpers/createClass.js";
-import { require_handlers } from "./handlers.js";
-//#region ../node_modules/jexl/dist/evaluator/Evaluator.js
-var require_Evaluator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var handlers = require_handlers();
-	module.exports = /* @__PURE__ */ function() {
-		function Evaluator(grammar, context, relativeContext) {
-			var promise = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Promise;
-			(0, _classCallCheck2.default)(this, Evaluator);
-			this._grammar = grammar;
-			this._context = context || {};
-			this._relContext = relativeContext || this._context;
-			this.Promise = promise;
-		}
-		/**
-		* Evaluates an expression tree within the configured context.
-		* @param {{}} ast An expression tree object
-		* @returns {Promise<*>} resolves with the resulting value of the expression.
-		*/
-		(0, _createClass2.default)(Evaluator, [
-			{
-				key: "eval",
-				value: function _eval(ast) {
-					var _this = this;
-					return this.Promise.resolve().then(function() {
-						return handlers[ast.type].call(_this, ast);
-					});
-				}
-			},
-			{
-				key: "evalArray",
-				value: function evalArray(arr) {
-					var _this2 = this;
-					return this.Promise.all(arr.map(function(elem) {
-						return _this2.eval(elem);
-					}));
-				}
-			},
-			{
-				key: "evalMap",
-				value: function evalMap(map) {
-					var _this3 = this;
-					var keys = Object.keys(map);
-					var result = {};
-					var asts = keys.map(function(key) {
-						return _this3.eval(map[key]);
-					});
-					return this.Promise.all(asts).then(function(vals) {
-						vals.forEach(function(val, idx) {
-							result[keys[idx]] = val;
-						});
-						return result;
-					});
-				}
-			},
-			{
-				key: "_filterRelative",
-				value: function _filterRelative(subject, expr) {
-					var _this4 = this;
-					var promises = [];
-					if (!Array.isArray(subject)) subject = subject === void 0 ? [] : [subject];
-					subject.forEach(function(elem) {
-						var evalInst = new Evaluator(_this4._grammar, _this4._context, elem, _this4.Promise);
-						promises.push(evalInst.eval(expr));
-					});
-					return this.Promise.all(promises).then(function(values) {
-						var results = [];
-						values.forEach(function(value, idx) {
-							if (value) results.push(subject[idx]);
-						});
-						return results;
-					});
-				}
-			},
-			{
-				key: "_filterStatic",
-				value: function _filterStatic(subject, expr) {
-					return this.eval(expr).then(function(res) {
-						if (typeof res === "boolean") return res ? subject : void 0;
-						return subject[res];
-					});
-				}
-			}
-		]);
-		return Evaluator;
-	}();
-}));
-//#endregion
-export default require_Evaluator();
-export { require_Evaluator };
-
-//# sourceMappingURL=Evaluator.js.map

package/dist/node_modules/jexl/dist/evaluator/Evaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evaluator.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/evaluator/Evaluator.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar handlers = require('./handlers');\n/**\n * The Evaluator takes a Jexl expression tree as generated by the\n * {@link Parser} and calculates its value within a given context. The\n * collection of transforms, context, and a relative context to be used as the\n * root for relative identifiers, are all specific to an Evaluator instance.\n * When any of these things change, a new instance is required.  However, a\n * single instance can be used to simultaneously evaluate many different\n * expressions, and does not have to be reinstantiated for each.\n * @param {{}} grammar A grammar object against which to evaluate the expression\n *      tree\n * @param {{}} [context] A map of variable keys to their values. This will be\n *      accessed to resolve the value of each non-relative identifier. Any\n *      Promise values will be passed to the expression as their resolved\n *      value.\n * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed\n *      to resolve the value of a relative identifier.\n * @param {function} promise A constructor for the Promise class to be used;\n *      probably either Promise or PromiseSync.\n */\n\n\nvar Evaluator = /*#__PURE__*/function () {\n  function Evaluator(grammar, context, relativeContext) {\n    var promise = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Promise;\n    (0, _classCallCheck2.default)(this, Evaluator);\n    this._grammar = grammar;\n    this._context = context || {};\n    this._relContext = relativeContext || this._context;\n    this.Promise = promise;\n  }\n  /**\n   * Evaluates an expression tree within the configured context.\n   * @param {{}} ast An expression tree object\n   * @returns {Promise<*>} resolves with the resulting value of the expression.\n   */\n\n\n  (0, _createClass2.default)(Evaluator, [{\n    key: \"eval\",\n    value: function _eval(ast) {\n      var _this = this;\n\n      return this.Promise.resolve().then(function () {\n        return handlers[ast.type].call(_this, ast);\n      });\n    }\n    /**\n     * Simultaneously evaluates each expression within an array, and delivers the\n     * response as an array with the resulting values at the same indexes as their\n     * originating expressions.\n     * @param {Array<string>} arr An array of expression strings to be evaluated\n     * @returns {Promise<Array<{}>>} resolves with the result array\n     */\n\n  }, {\n    key: \"evalArray\",\n    value: function evalArray(arr) {\n      var _this2 = this;\n\n      return this.Promise.all(arr.map(function (elem) {\n        return _this2.eval(elem);\n      }));\n    }\n    /**\n     * Simultaneously evaluates each expression within a map, and delivers the\n     * response as a map with the same keys, but with the evaluated result for each\n     * as their value.\n     * @param {{}} map A map of expression names to expression trees to be\n     *      evaluated\n     * @returns {Promise<{}>} resolves with the result map.\n     */\n\n  }, {\n    key: \"evalMap\",\n    value: function evalMap(map) {\n      var _this3 = this;\n\n      var keys = Object.keys(map);\n      var result = {};\n      var asts = keys.map(function (key) {\n        return _this3.eval(map[key]);\n      });\n      return this.Promise.all(asts).then(function (vals) {\n        vals.forEach(function (val, idx) {\n          result[keys[idx]] = val;\n        });\n        return result;\n      });\n    }\n    /**\n     * Applies a filter expression with relative identifier elements to a subject.\n     * The intent is for the subject to be an array of subjects that will be\n     * individually used as the relative context against the provided expression\n     * tree. Only the elements whose expressions result in a truthy value will be\n     * included in the resulting array.\n     *\n     * If the subject is not an array of values, it will be converted to a single-\n     * element array before running the filter.\n     * @param {*} subject The value to be filtered usually an array. If this value is\n     *      not an array, it will be converted to an array with this value as the\n     *      only element.\n     * @param {{}} expr The expression tree to run against each subject. If the\n     *      tree evaluates to a truthy result, then the value will be included in\n     *      the returned array otherwise, it will be eliminated.\n     * @returns {Promise<Array>} resolves with an array of values that passed the\n     *      expression filter.\n     * @private\n     */\n\n  }, {\n    key: \"_filterRelative\",\n    value: function _filterRelative(subject, expr) {\n      var _this4 = this;\n\n      var promises = [];\n\n      if (!Array.isArray(subject)) {\n        subject = subject === undefined ? [] : [subject];\n      }\n\n      subject.forEach(function (elem) {\n        var evalInst = new Evaluator(_this4._grammar, _this4._context, elem, _this4.Promise);\n        promises.push(evalInst.eval(expr));\n      });\n      return this.Promise.all(promises).then(function (values) {\n        var results = [];\n        values.forEach(function (value, idx) {\n          if (value) {\n            results.push(subject[idx]);\n          }\n        });\n        return results;\n      });\n    }\n    /**\n     * Applies a static filter expression to a subject value.  If the filter\n     * expression evaluates to boolean true, the subject is returned if false,\n     * undefined.\n     *\n     * For any other resulting value of the expression, this function will attempt\n     * to respond with the property at that name or index of the subject.\n     * @param {*} subject The value to be filtered.  Usually an Array (for which\n     *      the expression would generally resolve to a numeric index) or an\n     *      Object (for which the expression would generally resolve to a string\n     *      indicating a property name)\n     * @param {{}} expr The expression tree to run against the subject\n     * @returns {Promise<*>} resolves with the value of the drill-down.\n     * @private\n     */\n\n  }, {\n    key: \"_filterStatic\",\n    value: function _filterStatic(subject, expr) {\n      return this.eval(expr).then(function (res) {\n        if (typeof res === 'boolean') {\n          return res ? subject : undefined;\n        }\n\n        return subject[res];\n      });\n    }\n  }]);\n  return Evaluator;\n}();\n\nmodule.exports = Evaluator;"],"x_google_ignoreList":[0],"mappings":";;;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,WAAA,kBAAA;AAsKJ,QAAO,UAAU,gBAhJY,WAAY;EACvC,SAAS,UAAU,SAAS,SAAS,iBAAiB;GACpD,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK;AAClF,IAAC,GAAG,iBAAiB,SAAS,MAAM,UAAU;AAC9C,QAAK,WAAW;AAChB,QAAK,WAAW,WAAW,EAAE;AAC7B,QAAK,cAAc,mBAAmB,KAAK;AAC3C,QAAK,UAAU;;;;;;;AASjB,GAAC,GAAG,cAAc,SAAS,WAAW;GAAC;IACrC,KAAK;IACL,OAAO,SAAS,MAAM,KAAK;KACzB,IAAI,QAAQ;AAEZ,YAAO,KAAK,QAAQ,SAAS,CAAC,KAAK,WAAY;AAC7C,aAAO,SAAS,IAAI,MAAM,KAAK,OAAO,IAAI;OAC1C;;IAUL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,UAAU,KAAK;KAC7B,IAAI,SAAS;AAEb,YAAO,KAAK,QAAQ,IAAI,IAAI,IAAI,SAAU,MAAM;AAC9C,aAAO,OAAO,KAAK,KAAK;OACxB,CAAC;;IAWN;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ,KAAK;KAC3B,IAAI,SAAS;KAEb,IAAI,OAAO,OAAO,KAAK,IAAI;KAC3B,IAAI,SAAS,EAAE;KACf,IAAI,OAAO,KAAK,IAAI,SAAU,KAAK;AACjC,aAAO,OAAO,KAAK,IAAI,KAAK;OAC5B;AACF,YAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,SAAU,MAAM;AACjD,WAAK,QAAQ,SAAU,KAAK,KAAK;AAC/B,cAAO,KAAK,QAAQ;QACpB;AACF,aAAO;OACP;;IAsBL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,gBAAgB,SAAS,MAAM;KAC7C,IAAI,SAAS;KAEb,IAAI,WAAW,EAAE;AAEjB,SAAI,CAAC,MAAM,QAAQ,QAAQ,CACzB,WAAU,YAAY,KAAA,IAAY,EAAE,GAAG,CAAC,QAAQ;AAGlD,aAAQ,QAAQ,SAAU,MAAM;MAC9B,IAAI,WAAW,IAAI,UAAU,OAAO,UAAU,OAAO,UAAU,MAAM,OAAO,QAAQ;AACpF,eAAS,KAAK,SAAS,KAAK,KAAK,CAAC;OAClC;AACF,YAAO,KAAK,QAAQ,IAAI,SAAS,CAAC,KAAK,SAAU,QAAQ;MACvD,IAAI,UAAU,EAAE;AAChB,aAAO,QAAQ,SAAU,OAAO,KAAK;AACnC,WAAI,MACF,SAAQ,KAAK,QAAQ,KAAK;QAE5B;AACF,aAAO;OACP;;IAkBL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,cAAc,SAAS,MAAM;AAC3C,YAAO,KAAK,KAAK,KAAK,CAAC,KAAK,SAAU,KAAK;AACzC,UAAI,OAAO,QAAQ,UACjB,QAAO,MAAM,UAAU,KAAA;AAGzB,aAAO,QAAQ;OACf;;IAEL;GAAC,CAAC;AACH,SAAO;IAGQ"}

package/dist/node_modules/jexl/dist/evaluator/handlers.js

@@ -1,162 +0,0 @@
-import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
-import { require_interopRequireDefault } from "../../../@babel/runtime/helpers/interopRequireDefault.js";
-import { require_toConsumableArray } from "../../../@babel/runtime/helpers/toConsumableArray.js";
-//#region ../node_modules/jexl/dist/evaluator/handlers.js
-var require_handlers = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var _toConsumableArray2 = require_interopRequireDefault()(require_toConsumableArray());
-	var poolNames = {
-		functions: "Jexl Function",
-		transforms: "Transform"
-	};
-	/**
-	* Evaluates an ArrayLiteral by returning its value, with each element
-	* independently run through the evaluator.
-	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
-	*      ObjectLiteral as the top node
-	* @returns {Promise.<[]>} resolves to a map contained evaluated values.
-	* @private
-	*/
-	exports.ArrayLiteral = function(ast) {
-		return this.evalArray(ast.value);
-	};
-	/**
-	* Evaluates a BinaryExpression node by running the Grammar's evaluator for
-	* the given operator. Note that binary expressions support two types of
-	* evaluators: `eval` is called with the left and right operands pre-evaluated.
-	* `evalOnDemand`, if it exists, will be called with the left and right operands
-	* each individually wrapped in an object with an "eval" function that returns
-	* a promise with the resulting value. This allows the binary expression to
-	* evaluate the operands conditionally.
-	* @param {{type: 'BinaryExpression', operator: <string>, left: {},
-	*      right: {}}} ast An expression tree with a BinaryExpression as the top
-	*      node
-	* @returns {Promise<*>} resolves with the value of the BinaryExpression.
-	* @private
-	*/
-	exports.BinaryExpression = function(ast) {
-		var _this = this;
-		var grammarOp = this._grammar.elements[ast.operator];
-		if (grammarOp.evalOnDemand) {
-			var wrap = function wrap(subAst) {
-				return { eval: function _eval() {
-					return _this.eval(subAst);
-				} };
-			};
-			return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));
-		}
-		return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function(arr) {
-			return grammarOp.eval(arr[0], arr[1]);
-		});
-	};
-	/**
-	* Evaluates a ConditionalExpression node by first evaluating its test branch,
-	* and resolving with the consequent branch if the test is truthy, or the
-	* alternate branch if it is not. If there is no consequent branch, the test
-	* result will be used instead.
-	* @param {{type: 'ConditionalExpression', test: {}, consequent: {},
-	*      alternate: {}}} ast An expression tree with a ConditionalExpression as
-	*      the top node
-	* @private
-	*/
-	exports.ConditionalExpression = function(ast) {
-		var _this2 = this;
-		return this.eval(ast.test).then(function(res) {
-			if (res) {
-				if (ast.consequent) return _this2.eval(ast.consequent);
-				return res;
-			}
-			return _this2.eval(ast.alternate);
-		});
-	};
-	/**
-	* Evaluates a FilterExpression by applying it to the subject value.
-	* @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
-	*      subject: {}}} ast An expression tree with a FilterExpression as the top
-	*      node
-	* @returns {Promise<*>} resolves with the value of the FilterExpression.
-	* @private
-	*/
-	exports.FilterExpression = function(ast) {
-		var _this3 = this;
-		return this.eval(ast.subject).then(function(subject) {
-			if (ast.relative) return _this3._filterRelative(subject, ast.expr);
-			return _this3._filterStatic(subject, ast.expr);
-		});
-	};
-	/**
-	* Evaluates an Identifier by either stemming from the evaluated 'from'
-	* expression tree or accessing the context provided when this Evaluator was
-	* constructed.
-	* @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
-	*      tree with an Identifier as the top node
-	* @returns {Promise<*>|*} either the identifier's value, or a Promise that
-	*      will resolve with the identifier's value.
-	* @private
-	*/
-	exports.Identifier = function(ast) {
-		if (!ast.from) return ast.relative ? this._relContext[ast.value] : this._context[ast.value];
-		return this.eval(ast.from).then(function(context) {
-			if (context === void 0 || context === null) return;
-			if (Array.isArray(context)) context = context[0];
-			return context[ast.value];
-		});
-	};
-	/**
-	* Evaluates a Literal by returning its value property.
-	* @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
-	*      tree with a Literal as its only node
-	* @returns {string|number|boolean} The value of the Literal node
-	* @private
-	*/
-	exports.Literal = function(ast) {
-		return ast.value;
-	};
-	/**
-	* Evaluates an ObjectLiteral by returning its value, with each key
-	* independently run through the evaluator.
-	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
-	*      ObjectLiteral as the top node
-	* @returns {Promise<{}>} resolves to a map contained evaluated values.
-	* @private
-	*/
-	exports.ObjectLiteral = function(ast) {
-		return this.evalMap(ast.value);
-	};
-	/**
-	* Evaluates a FunctionCall node by applying the supplied arguments to a
-	* function defined in one of the grammar's function pools.
-	* @param {{type: 'FunctionCall', name: <string>}} ast An
-	*      expression tree with a FunctionCall as the top node
-	* @returns {Promise<*>|*} the value of the function call, or a Promise that
-	*      will resolve with the resulting value.
-	* @private
-	*/
-	exports.FunctionCall = function(ast) {
-		var poolName = poolNames[ast.pool];
-		if (!poolName) throw new Error("Corrupt AST: Pool '".concat(ast.pool, "' not found"));
-		var func = this._grammar[ast.pool][ast.name];
-		if (!func) throw new Error("".concat(poolName, " ").concat(ast.name, " is not defined."));
-		return this.evalArray(ast.args || []).then(function(args) {
-			return func.apply(void 0, (0, _toConsumableArray2.default)(args));
-		});
-	};
-	/**
-	* Evaluates a Unary expression by passing the right side through the
-	* operator's eval function.
-	* @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
-	*      expression tree with a UnaryExpression as the top node
-	* @returns {Promise<*>} resolves with the value of the UnaryExpression.
-	* @constructor
-	*/
-	exports.UnaryExpression = function(ast) {
-		var _this4 = this;
-		return this.eval(ast.right).then(function(right) {
-			return _this4._grammar.elements[ast.operator].eval(right);
-		});
-	};
-}));
-//#endregion
-export default require_handlers();
-export { require_handlers };
-
-//# sourceMappingURL=handlers.js.map

package/dist/node_modules/jexl/dist/evaluator/handlers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/evaluator/handlers.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar poolNames = {\n  functions: 'Jexl Function',\n  transforms: 'Transform'\n};\n/**\n * Evaluates an ArrayLiteral by returning its value, with each element\n * independently run through the evaluator.\n * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an\n *      ObjectLiteral as the top node\n * @returns {Promise.<[]>} resolves to a map contained evaluated values.\n * @private\n */\n\nexports.ArrayLiteral = function (ast) {\n  return this.evalArray(ast.value);\n};\n/**\n * Evaluates a BinaryExpression node by running the Grammar's evaluator for\n * the given operator. Note that binary expressions support two types of\n * evaluators: `eval` is called with the left and right operands pre-evaluated.\n * `evalOnDemand`, if it exists, will be called with the left and right operands\n * each individually wrapped in an object with an \"eval\" function that returns\n * a promise with the resulting value. This allows the binary expression to\n * evaluate the operands conditionally.\n * @param {{type: 'BinaryExpression', operator: <string>, left: {},\n *      right: {}}} ast An expression tree with a BinaryExpression as the top\n *      node\n * @returns {Promise<*>} resolves with the value of the BinaryExpression.\n * @private\n */\n\n\nexports.BinaryExpression = function (ast) {\n  var _this = this;\n\n  var grammarOp = this._grammar.elements[ast.operator];\n\n  if (grammarOp.evalOnDemand) {\n    var wrap = function wrap(subAst) {\n      return {\n        eval: function _eval() {\n          return _this.eval(subAst);\n        }\n      };\n    };\n\n    return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));\n  }\n\n  return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function (arr) {\n    return grammarOp.eval(arr[0], arr[1]);\n  });\n};\n/**\n * Evaluates a ConditionalExpression node by first evaluating its test branch,\n * and resolving with the consequent branch if the test is truthy, or the\n * alternate branch if it is not. If there is no consequent branch, the test\n * result will be used instead.\n * @param {{type: 'ConditionalExpression', test: {}, consequent: {},\n *      alternate: {}}} ast An expression tree with a ConditionalExpression as\n *      the top node\n * @private\n */\n\n\nexports.ConditionalExpression = function (ast) {\n  var _this2 = this;\n\n  return this.eval(ast.test).then(function (res) {\n    if (res) {\n      if (ast.consequent) {\n        return _this2.eval(ast.consequent);\n      }\n\n      return res;\n    }\n\n    return _this2.eval(ast.alternate);\n  });\n};\n/**\n * Evaluates a FilterExpression by applying it to the subject value.\n * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},\n *      subject: {}}} ast An expression tree with a FilterExpression as the top\n *      node\n * @returns {Promise<*>} resolves with the value of the FilterExpression.\n * @private\n */\n\n\nexports.FilterExpression = function (ast) {\n  var _this3 = this;\n\n  return this.eval(ast.subject).then(function (subject) {\n    if (ast.relative) {\n      return _this3._filterRelative(subject, ast.expr);\n    }\n\n    return _this3._filterStatic(subject, ast.expr);\n  });\n};\n/**\n * Evaluates an Identifier by either stemming from the evaluated 'from'\n * expression tree or accessing the context provided when this Evaluator was\n * constructed.\n * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression\n *      tree with an Identifier as the top node\n * @returns {Promise<*>|*} either the identifier's value, or a Promise that\n *      will resolve with the identifier's value.\n * @private\n */\n\n\nexports.Identifier = function (ast) {\n  if (!ast.from) {\n    return ast.relative ? this._relContext[ast.value] : this._context[ast.value];\n  }\n\n  return this.eval(ast.from).then(function (context) {\n    if (context === undefined || context === null) {\n      return undefined;\n    }\n\n    if (Array.isArray(context)) {\n      context = context[0];\n    }\n\n    return context[ast.value];\n  });\n};\n/**\n * Evaluates a Literal by returning its value property.\n * @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression\n *      tree with a Literal as its only node\n * @returns {string|number|boolean} The value of the Literal node\n * @private\n */\n\n\nexports.Literal = function (ast) {\n  return ast.value;\n};\n/**\n * Evaluates an ObjectLiteral by returning its value, with each key\n * independently run through the evaluator.\n * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an\n *      ObjectLiteral as the top node\n * @returns {Promise<{}>} resolves to a map contained evaluated values.\n * @private\n */\n\n\nexports.ObjectLiteral = function (ast) {\n  return this.evalMap(ast.value);\n};\n/**\n * Evaluates a FunctionCall node by applying the supplied arguments to a\n * function defined in one of the grammar's function pools.\n * @param {{type: 'FunctionCall', name: <string>}} ast An\n *      expression tree with a FunctionCall as the top node\n * @returns {Promise<*>|*} the value of the function call, or a Promise that\n *      will resolve with the resulting value.\n * @private\n */\n\n\nexports.FunctionCall = function (ast) {\n  var poolName = poolNames[ast.pool];\n\n  if (!poolName) {\n    throw new Error(\"Corrupt AST: Pool '\".concat(ast.pool, \"' not found\"));\n  }\n\n  var pool = this._grammar[ast.pool];\n  var func = pool[ast.name];\n\n  if (!func) {\n    throw new Error(\"\".concat(poolName, \" \").concat(ast.name, \" is not defined.\"));\n  }\n\n  return this.evalArray(ast.args || []).then(function (args) {\n    return func.apply(void 0, (0, _toConsumableArray2.default)(args));\n  });\n};\n/**\n * Evaluates a Unary expression by passing the right side through the\n * operator's eval function.\n * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An\n *      expression tree with a UnaryExpression as the top node\n * @returns {Promise<*>} resolves with the value of the UnaryExpression.\n * @constructor\n */\n\n\nexports.UnaryExpression = function (ast) {\n  var _this4 = this;\n\n  return this.eval(ast.right).then(function (right) {\n    return _this4._grammar.elements[ast.operator].eval(right);\n  });\n};"],"x_google_ignoreList":[0],"mappings":";;;;;CAIA,IAAI,sBAAA,+BAAA,CAAA,2BAAA,CAAiG;CAMrG,IAAI,YAAY;EACd,WAAW;EACX,YAAY;EACb;;;;;;;;;AAUD,SAAQ,eAAe,SAAU,KAAK;AACpC,SAAO,KAAK,UAAU,IAAI,MAAM;;;;;;;;;;;;;;;;AAkBlC,SAAQ,mBAAmB,SAAU,KAAK;EACxC,IAAI,QAAQ;EAEZ,IAAI,YAAY,KAAK,SAAS,SAAS,IAAI;AAE3C,MAAI,UAAU,cAAc;GAC1B,IAAI,OAAO,SAAS,KAAK,QAAQ;AAC/B,WAAO,EACL,MAAM,SAAS,QAAQ;AACrB,YAAO,MAAM,KAAK,OAAO;OAE5B;;AAGH,UAAO,UAAU,aAAa,KAAK,IAAI,KAAK,EAAE,KAAK,IAAI,MAAM,CAAC;;AAGhE,SAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,KAAK,IAAI,KAAK,EAAE,KAAK,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAU,KAAK;AACvF,UAAO,UAAU,KAAK,IAAI,IAAI,IAAI,GAAG;IACrC;;;;;;;;;;;;AAcJ,SAAQ,wBAAwB,SAAU,KAAK;EAC7C,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,KAAK,CAAC,KAAK,SAAU,KAAK;AAC7C,OAAI,KAAK;AACP,QAAI,IAAI,WACN,QAAO,OAAO,KAAK,IAAI,WAAW;AAGpC,WAAO;;AAGT,UAAO,OAAO,KAAK,IAAI,UAAU;IACjC;;;;;;;;;;AAYJ,SAAQ,mBAAmB,SAAU,KAAK;EACxC,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,QAAQ,CAAC,KAAK,SAAU,SAAS;AACpD,OAAI,IAAI,SACN,QAAO,OAAO,gBAAgB,SAAS,IAAI,KAAK;AAGlD,UAAO,OAAO,cAAc,SAAS,IAAI,KAAK;IAC9C;;;;;;;;;;;;AAcJ,SAAQ,aAAa,SAAU,KAAK;AAClC,MAAI,CAAC,IAAI,KACP,QAAO,IAAI,WAAW,KAAK,YAAY,IAAI,SAAS,KAAK,SAAS,IAAI;AAGxE,SAAO,KAAK,KAAK,IAAI,KAAK,CAAC,KAAK,SAAU,SAAS;AACjD,OAAI,YAAY,KAAA,KAAa,YAAY,KACvC;AAGF,OAAI,MAAM,QAAQ,QAAQ,CACxB,WAAU,QAAQ;AAGpB,UAAO,QAAQ,IAAI;IACnB;;;;;;;;;AAWJ,SAAQ,UAAU,SAAU,KAAK;AAC/B,SAAO,IAAI;;;;;;;;;;AAYb,SAAQ,gBAAgB,SAAU,KAAK;AACrC,SAAO,KAAK,QAAQ,IAAI,MAAM;;;;;;;;;;;AAahC,SAAQ,eAAe,SAAU,KAAK;EACpC,IAAI,WAAW,UAAU,IAAI;AAE7B,MAAI,CAAC,SACH,OAAM,IAAI,MAAM,sBAAsB,OAAO,IAAI,MAAM,cAAc,CAAC;EAIxE,IAAI,OADO,KAAK,SAAS,IAAI,MACb,IAAI;AAEpB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,GAAG,OAAO,UAAU,IAAI,CAAC,OAAO,IAAI,MAAM,mBAAmB,CAAC;AAGhF,SAAO,KAAK,UAAU,IAAI,QAAQ,EAAE,CAAC,CAAC,KAAK,SAAU,MAAM;AACzD,UAAO,KAAK,MAAM,KAAK,IAAI,GAAG,oBAAoB,SAAS,KAAK,CAAC;IACjE;;;;;;;;;;AAYJ,SAAQ,kBAAkB,SAAU,KAAK;EACvC,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,MAAM,CAAC,KAAK,SAAU,OAAO;AAChD,UAAO,OAAO,SAAS,SAAS,IAAI,UAAU,KAAK,MAAM;IACzD"}