@verbb/plugin-kit-react 1.0.10 → 2.0.1

package/dist/node_modules/jexl/dist/grammar.js

@@ -1,195 +0,0 @@
-import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
-//#region ../node_modules/jexl/dist/grammar.js
-var require_grammar = /* @__PURE__ */ __commonJSMin(((exports) => {
-	exports.getGrammar = function() {
-		return {
-			/**
-			* A map of all expression elements to their properties. Note that changes
-			* here may require changes in the Lexer or Parser.
-			* @type {{}}
-			*/
-			elements: {
-				".": { type: "dot" },
-				"[": { type: "openBracket" },
-				"]": { type: "closeBracket" },
-				"|": { type: "pipe" },
-				"{": { type: "openCurl" },
-				"}": { type: "closeCurl" },
-				":": { type: "colon" },
-				",": { type: "comma" },
-				"(": { type: "openParen" },
-				")": { type: "closeParen" },
-				"?": { type: "question" },
-				"+": {
-					type: "binaryOp",
-					precedence: 30,
-					eval: function _eval(left, right) {
-						return left + right;
-					}
-				},
-				"-": {
-					type: "binaryOp",
-					precedence: 30,
-					eval: function _eval(left, right) {
-						return left - right;
-					}
-				},
-				"*": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return left * right;
-					}
-				},
-				"/": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return left / right;
-					}
-				},
-				"//": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return Math.floor(left / right);
-					}
-				},
-				"%": {
-					type: "binaryOp",
-					precedence: 50,
-					eval: function _eval(left, right) {
-						return left % right;
-					}
-				},
-				"^": {
-					type: "binaryOp",
-					precedence: 50,
-					eval: function _eval(left, right) {
-						return Math.pow(left, right);
-					}
-				},
-				"==": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left == right;
-					}
-				},
-				"!=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left != right;
-					}
-				},
-				">": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left > right;
-					}
-				},
-				">=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left >= right;
-					}
-				},
-				"<": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left < right;
-					}
-				},
-				"<=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left <= right;
-					}
-				},
-				"&&": {
-					type: "binaryOp",
-					precedence: 10,
-					evalOnDemand: function evalOnDemand(left, right) {
-						return left.eval().then(function(leftVal) {
-							if (!leftVal) return leftVal;
-							return right.eval();
-						});
-					}
-				},
-				"||": {
-					type: "binaryOp",
-					precedence: 10,
-					evalOnDemand: function evalOnDemand(left, right) {
-						return left.eval().then(function(leftVal) {
-							if (leftVal) return leftVal;
-							return right.eval();
-						});
-					}
-				},
-				in: {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						if (typeof right === "string") return right.indexOf(left) !== -1;
-						if (Array.isArray(right)) return right.some(function(elem) {
-							return elem === left;
-						});
-						return false;
-					}
-				},
-				"!": {
-					type: "unaryOp",
-					precedence: Infinity,
-					eval: function _eval(right) {
-						return !right;
-					}
-				}
-			},
-			/**
-			* A map of function names to javascript functions. A Jexl function
-			* takes zero ore more arguemnts:
-			*
-			*     - {*} ...args: A variable number of arguments passed to this function.
-			*       All of these are pre-evaluated to their actual values before calling
-			*       the function.
-			*
-			* The Jexl function should return either the transformed value, or
-			* a Promises/A+ Promise object that resolves with the value and rejects
-			* or throws only when an unrecoverable error occurs. Functions should
-			* generally return undefined when they don't make sense to be used on the
-			* given value type, rather than throw/reject. An error is only
-			* appropriate when the function would normally return a value, but
-			* cannot due to some other failure.
-			*/
-			functions: {},
-			/**
-			* A map of transform names to transform functions. A transform function
-			* takes one ore more arguemnts:
-			*
-			*     - {*} val: A value to be transformed
-			*     - {*} ...args: A variable number of arguments passed to this transform.
-			*       All of these are pre-evaluated to their actual values before calling
-			*       the function.
-			*
-			* The transform function should return either the transformed value, or
-			* a Promises/A+ Promise object that resolves with the value and rejects
-			* or throws only when an unrecoverable error occurs. Transforms should
-			* generally return undefined when they don't make sense to be used on the
-			* given value type, rather than throw/reject. An error is only
-			* appropriate when the transform would normally return a value, but
-			* cannot due to some other failure.
-			*/
-			transforms: {}
-		};
-	};
-}));
-//#endregion
-export default require_grammar();
-export { require_grammar };
-
-//# sourceMappingURL=grammar.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"grammar.js","names":[],"sources":["../../../../../node_modules/jexl/dist/grammar.js"],"sourcesContent":["\"use strict\";\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\n\n/* eslint eqeqeq:0 */\nexports.getGrammar = function () {\n  return {\n    /**\n     * A map of all expression elements to their properties. Note that changes\n     * here may require changes in the Lexer or Parser.\n     * @type {{}}\n     */\n    elements: {\n      '.': {\n        type: 'dot'\n      },\n      '[': {\n        type: 'openBracket'\n      },\n      ']': {\n        type: 'closeBracket'\n      },\n      '|': {\n        type: 'pipe'\n      },\n      '{': {\n        type: 'openCurl'\n      },\n      '}': {\n        type: 'closeCurl'\n      },\n      ':': {\n        type: 'colon'\n      },\n      ',': {\n        type: 'comma'\n      },\n      '(': {\n        type: 'openParen'\n      },\n      ')': {\n        type: 'closeParen'\n      },\n      '?': {\n        type: 'question'\n      },\n      '+': {\n        type: 'binaryOp',\n        precedence: 30,\n        eval: function _eval(left, right) {\n          return left + right;\n        }\n      },\n      '-': {\n        type: 'binaryOp',\n        precedence: 30,\n        eval: function _eval(left, right) {\n          return left - right;\n        }\n      },\n      '*': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return left * right;\n        }\n      },\n      '/': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return left / right;\n        }\n      },\n      '//': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return Math.floor(left / right);\n        }\n      },\n      '%': {\n        type: 'binaryOp',\n        precedence: 50,\n        eval: function _eval(left, right) {\n          return left % right;\n        }\n      },\n      '^': {\n        type: 'binaryOp',\n        precedence: 50,\n        eval: function _eval(left, right) {\n          return Math.pow(left, right);\n        }\n      },\n      '==': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left == right;\n        }\n      },\n      '!=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left != right;\n        }\n      },\n      '>': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left > right;\n        }\n      },\n      '>=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left >= right;\n        }\n      },\n      '<': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left < right;\n        }\n      },\n      '<=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left <= right;\n        }\n      },\n      '&&': {\n        type: 'binaryOp',\n        precedence: 10,\n        evalOnDemand: function evalOnDemand(left, right) {\n          return left.eval().then(function (leftVal) {\n            if (!leftVal) return leftVal;\n            return right.eval();\n          });\n        }\n      },\n      '||': {\n        type: 'binaryOp',\n        precedence: 10,\n        evalOnDemand: function evalOnDemand(left, right) {\n          return left.eval().then(function (leftVal) {\n            if (leftVal) return leftVal;\n            return right.eval();\n          });\n        }\n      },\n      in: {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          if (typeof right === 'string') {\n            return right.indexOf(left) !== -1;\n          }\n\n          if (Array.isArray(right)) {\n            return right.some(function (elem) {\n              return elem === left;\n            });\n          }\n\n          return false;\n        }\n      },\n      '!': {\n        type: 'unaryOp',\n        precedence: Infinity,\n        eval: function _eval(right) {\n          return !right;\n        }\n      }\n    },\n\n    /**\n     * A map of function names to javascript functions. A Jexl function\n     * takes zero ore more arguemnts:\n     *\n     *     - {*} ...args: A variable number of arguments passed to this function.\n     *       All of these are pre-evaluated to their actual values before calling\n     *       the function.\n     *\n     * The Jexl function should return either the transformed value, or\n     * a Promises/A+ Promise object that resolves with the value and rejects\n     * or throws only when an unrecoverable error occurs. Functions should\n     * generally return undefined when they don't make sense to be used on the\n     * given value type, rather than throw/reject. An error is only\n     * appropriate when the function would normally return a value, but\n     * cannot due to some other failure.\n     */\n    functions: {},\n\n    /**\n     * A map of transform names to transform functions. A transform function\n     * takes one ore more arguemnts:\n     *\n     *     - {*} val: A value to be transformed\n     *     - {*} ...args: A variable number of arguments passed to this transform.\n     *       All of these are pre-evaluated to their actual values before calling\n     *       the function.\n     *\n     * The transform function should return either the transformed value, or\n     * a Promises/A+ Promise object that resolves with the value and rejects\n     * or throws only when an unrecoverable error occurs. Transforms should\n     * generally return undefined when they don't make sense to be used on the\n     * given value type, rather than throw/reject. An error is only\n     * appropriate when the transform would normally return a value, but\n     * cannot due to some other failure.\n     */\n    transforms: {}\n  };\n};"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/jexl/dist/parser/Parser.js

@@ -1,135 +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";
-import { require_states } from "./states.js";
-//#region ../node_modules/jexl/dist/parser/Parser.js
-var require_Parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var handlers = require_handlers();
-	var states = require_states().states;
-	module.exports = /* @__PURE__ */ function() {
-		function Parser(grammar, prefix, stopMap) {
-			(0, _classCallCheck2.default)(this, Parser);
-			this._grammar = grammar;
-			this._state = "expectOperand";
-			this._tree = null;
-			this._exprStr = prefix || "";
-			this._relative = false;
-			this._stopMap = stopMap || {};
-		}
-		/**
-		* Processes a new token into the AST and manages the transitions of the state
-		* machine.
-		* @param {{type: <string>}} token A token object, as provided by the
-		*      {@link Lexer#tokenize} function.
-		* @throws {Error} if a token is added when the Parser has been marked as
-		*      complete by {@link #complete}, or if an unexpected token type is added.
-		* @returns {boolean|*} the stopState value if this parser encountered a token
-		*      in the stopState mapb false if tokens can continue.
-		*/
-		(0, _createClass2.default)(Parser, [
-			{
-				key: "addToken",
-				value: function addToken(token) {
-					if (this._state === "complete") throw new Error("Cannot add a new token to a completed Parser");
-					var state = states[this._state];
-					var startExpr = this._exprStr;
-					this._exprStr += token.raw;
-					if (state.subHandler) {
-						if (!this._subParser) this._startSubExpression(startExpr);
-						var stopState = this._subParser.addToken(token);
-						if (stopState) {
-							this._endSubExpression();
-							if (this._parentStop) return stopState;
-							this._state = stopState;
-						}
-					} else if (state.tokenTypes[token.type]) {
-						var typeOpts = state.tokenTypes[token.type];
-						var handleFunc = handlers[token.type];
-						if (typeOpts.handler) handleFunc = typeOpts.handler;
-						if (handleFunc) handleFunc.call(this, token);
-						if (typeOpts.toState) this._state = typeOpts.toState;
-					} else if (this._stopMap[token.type]) return this._stopMap[token.type];
-					else throw new Error("Token ".concat(token.raw, " (").concat(token.type, ") unexpected in expression: ").concat(this._exprStr));
-					return false;
-				}
-			},
-			{
-				key: "addTokens",
-				value: function addTokens(tokens) {
-					tokens.forEach(this.addToken, this);
-				}
-			},
-			{
-				key: "complete",
-				value: function complete() {
-					if (this._cursor && !states[this._state].completable) throw new Error("Unexpected end of expression: ".concat(this._exprStr));
-					if (this._subParser) this._endSubExpression();
-					this._state = "complete";
-					return this._cursor ? this._tree : null;
-				}
-			},
-			{
-				key: "isRelative",
-				value: function isRelative() {
-					return this._relative;
-				}
-			},
-			{
-				key: "_endSubExpression",
-				value: function _endSubExpression() {
-					states[this._state].subHandler.call(this, this._subParser.complete());
-					this._subParser = null;
-				}
-			},
-			{
-				key: "_placeAtCursor",
-				value: function _placeAtCursor(node) {
-					if (!this._cursor) this._tree = node;
-					else {
-						this._cursor.right = node;
-						this._setParent(node, this._cursor);
-					}
-					this._cursor = node;
-				}
-			},
-			{
-				key: "_placeBeforeCursor",
-				value: function _placeBeforeCursor(node) {
-					this._cursor = this._cursor._parent;
-					this._placeAtCursor(node);
-				}
-			},
-			{
-				key: "_setParent",
-				value: function _setParent(node, parent) {
-					Object.defineProperty(node, "_parent", {
-						value: parent,
-						writable: true
-					});
-				}
-			},
-			{
-				key: "_startSubExpression",
-				value: function _startSubExpression(exprStr) {
-					var endStates = states[this._state].endStates;
-					if (!endStates) {
-						this._parentStop = true;
-						endStates = this._stopMap;
-					}
-					this._subParser = new Parser(this._grammar, exprStr, endStates);
-				}
-			}
-		]);
-		return Parser;
-	}();
-}));
-//#endregion
-export default require_Parser();
-export { require_Parser };
-
-//# sourceMappingURL=Parser.js.map

package/dist/node_modules/jexl/dist/parser/Parser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Parser.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/parser/Parser.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\nvar states = require('./states').states;\n/**\n * The Parser is a state machine that converts tokens from the {@link Lexer}\n * into an Abstract Syntax Tree (AST), capable of being evaluated in any\n * context by the {@link Evaluator}.  The Parser expects that all tokens\n * provided to it are legal and typed properly according to the grammar, but\n * accepts that the tokens may still be in an invalid order or in some other\n * unparsable configuration that requires it to throw an Error.\n * @param {{}} grammar The grammar object to use to parse Jexl strings\n * @param {string} [prefix] A string prefix to prepend to the expression string\n *      for error messaging purposes.  This is useful for when a new Parser is\n *      instantiated to parse an subexpression, as the parent Parser's\n *      expression string thus far can be passed for a more user-friendly\n *      error message.\n * @param {{}} [stopMap] A mapping of token types to any truthy value. When the\n *      token type is encountered, the parser will return the mapped value\n *      instead of boolean false.\n */\n\n\nvar Parser = /*#__PURE__*/function () {\n  function Parser(grammar, prefix, stopMap) {\n    (0, _classCallCheck2.default)(this, Parser);\n    this._grammar = grammar;\n    this._state = 'expectOperand';\n    this._tree = null;\n    this._exprStr = prefix || '';\n    this._relative = false;\n    this._stopMap = stopMap || {};\n  }\n  /**\n   * Processes a new token into the AST and manages the transitions of the state\n   * machine.\n   * @param {{type: <string>}} token A token object, as provided by the\n   *      {@link Lexer#tokenize} function.\n   * @throws {Error} if a token is added when the Parser has been marked as\n   *      complete by {@link #complete}, or if an unexpected token type is added.\n   * @returns {boolean|*} the stopState value if this parser encountered a token\n   *      in the stopState mapb false if tokens can continue.\n   */\n\n\n  (0, _createClass2.default)(Parser, [{\n    key: \"addToken\",\n    value: function addToken(token) {\n      if (this._state === 'complete') {\n        throw new Error('Cannot add a new token to a completed Parser');\n      }\n\n      var state = states[this._state];\n      var startExpr = this._exprStr;\n      this._exprStr += token.raw;\n\n      if (state.subHandler) {\n        if (!this._subParser) {\n          this._startSubExpression(startExpr);\n        }\n\n        var stopState = this._subParser.addToken(token);\n\n        if (stopState) {\n          this._endSubExpression();\n\n          if (this._parentStop) return stopState;\n          this._state = stopState;\n        }\n      } else if (state.tokenTypes[token.type]) {\n        var typeOpts = state.tokenTypes[token.type];\n        var handleFunc = handlers[token.type];\n\n        if (typeOpts.handler) {\n          handleFunc = typeOpts.handler;\n        }\n\n        if (handleFunc) {\n          handleFunc.call(this, token);\n        }\n\n        if (typeOpts.toState) {\n          this._state = typeOpts.toState;\n        }\n      } else if (this._stopMap[token.type]) {\n        return this._stopMap[token.type];\n      } else {\n        throw new Error(\"Token \".concat(token.raw, \" (\").concat(token.type, \") unexpected in expression: \").concat(this._exprStr));\n      }\n\n      return false;\n    }\n    /**\n     * Processes an array of tokens iteratively through the {@link #addToken}\n     * function.\n     * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by\n     *      the {@link Lexer#tokenize} function.\n     */\n\n  }, {\n    key: \"addTokens\",\n    value: function addTokens(tokens) {\n      tokens.forEach(this.addToken, this);\n    }\n    /**\n     * Marks this Parser instance as completed and retrieves the full AST.\n     * @returns {{}|null} a full expression tree, ready for evaluation by the\n     *      {@link Evaluator#eval} function, or null if no tokens were passed to\n     *      the parser before complete was called\n     * @throws {Error} if the parser is not in a state where it's legal to end\n     *      the expression, indicating that the expression is incomplete\n     */\n\n  }, {\n    key: \"complete\",\n    value: function complete() {\n      if (this._cursor && !states[this._state].completable) {\n        throw new Error(\"Unexpected end of expression: \".concat(this._exprStr));\n      }\n\n      if (this._subParser) {\n        this._endSubExpression();\n      }\n\n      this._state = 'complete';\n      return this._cursor ? this._tree : null;\n    }\n    /**\n     * Indicates whether the expression tree contains a relative path identifier.\n     * @returns {boolean} true if a relative identifier exists false otherwise.\n     */\n\n  }, {\n    key: \"isRelative\",\n    value: function isRelative() {\n      return this._relative;\n    }\n    /**\n     * Ends a subexpression by completing the subParser and passing its result\n     * to the subHandler configured in the current state.\n     * @private\n     */\n\n  }, {\n    key: \"_endSubExpression\",\n    value: function _endSubExpression() {\n      states[this._state].subHandler.call(this, this._subParser.complete());\n\n      this._subParser = null;\n    }\n    /**\n     * Places a new tree node at the current position of the cursor (to the 'right'\n     * property) and then advances the cursor to the new node. This function also\n     * handles setting the parent of the new node.\n     * @param {{type: <string>}} node A node to be added to the AST\n     * @private\n     */\n\n  }, {\n    key: \"_placeAtCursor\",\n    value: function _placeAtCursor(node) {\n      if (!this._cursor) {\n        this._tree = node;\n      } else {\n        this._cursor.right = node;\n\n        this._setParent(node, this._cursor);\n      }\n\n      this._cursor = node;\n    }\n    /**\n     * Places a tree node before the current position of the cursor, replacing\n     * the node that the cursor currently points to. This should only be called in\n     * cases where the cursor is known to exist, and the provided node already\n     * contains a pointer to what's at the cursor currently.\n     * @param {{type: <string>}} node A node to be added to the AST\n     * @private\n     */\n\n  }, {\n    key: \"_placeBeforeCursor\",\n    value: function _placeBeforeCursor(node) {\n      this._cursor = this._cursor._parent;\n\n      this._placeAtCursor(node);\n    }\n    /**\n     * Sets the parent of a node by creating a non-enumerable _parent property\n     * that points to the supplied parent argument.\n     * @param {{type: <string>}} node A node of the AST on which to set a new\n     *      parent\n     * @param {{type: <string>}} parent An existing node of the AST to serve as the\n     *      parent of the new node\n     * @private\n     */\n\n  }, {\n    key: \"_setParent\",\n    value: function _setParent(node, parent) {\n      Object.defineProperty(node, '_parent', {\n        value: parent,\n        writable: true\n      });\n    }\n    /**\n     * Prepares the Parser to accept a subexpression by (re)instantiating the\n     * subParser.\n     * @param {string} [exprStr] The expression string to prefix to the new Parser\n     * @private\n     */\n\n  }, {\n    key: \"_startSubExpression\",\n    value: function _startSubExpression(exprStr) {\n      var endStates = states[this._state].endStates;\n\n      if (!endStates) {\n        this._parentStop = true;\n        endStates = this._stopMap;\n      }\n\n      this._subParser = new Parser(this._grammar, exprStr, endStates);\n    }\n  }]);\n  return Parser;\n}();\n\nmodule.exports = Parser;"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -1,205 +0,0 @@
-import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
-//#region ../node_modules/jexl/dist/parser/handlers.js
-var require_handlers = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* Handles a subexpression that's used to define a transform argument's value.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.argVal = function(ast) {
-		if (ast) this._cursor.args.push(ast);
-	};
-	/**
-	* Handles new array literals by adding them as a new node in the AST,
-	* initialized with an empty array.
-	*/
-	exports.arrayStart = function() {
-		this._placeAtCursor({
-			type: "ArrayLiteral",
-			value: []
-		});
-	};
-	/**
-	* Handles a subexpression representing an element of an array literal.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.arrayVal = function(ast) {
-		if (ast) this._cursor.value.push(ast);
-	};
-	/**
-	* Handles tokens of type 'binaryOp', indicating an operation that has two
-	* inputs: a left side and a right side.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.binaryOp = function(token) {
-		var precedence = this._grammar.elements[token.value].precedence || 0;
-		var parent = this._cursor._parent;
-		while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {
-			this._cursor = parent;
-			parent = parent._parent;
-		}
-		var node = {
-			type: "BinaryExpression",
-			operator: token.value,
-			left: this._cursor
-		};
-		this._setParent(this._cursor, node);
-		this._cursor = parent;
-		this._placeAtCursor(node);
-	};
-	/**
-	* Handles successive nodes in an identifier chain.  More specifically, it
-	* sets values that determine how the following identifier gets placed in the
-	* AST.
-	*/
-	exports.dot = function() {
-		this._nextIdentEncapsulate = this._cursor && this._cursor.type !== "UnaryExpression" && (this._cursor.type !== "BinaryExpression" || this._cursor.type === "BinaryExpression" && this._cursor.right);
-		this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;
-		if (this._nextIdentRelative) this._relative = true;
-	};
-	/**
-	* Handles a subexpression used for filtering an array returned by an
-	* identifier chain.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.filter = function(ast) {
-		this._placeBeforeCursor({
-			type: "FilterExpression",
-			expr: ast,
-			relative: this._subParser.isRelative(),
-			subject: this._cursor
-		});
-	};
-	/**
-	* Handles identifier tokens when used to indicate the name of a function to
-	* be called.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.functionCall = function() {
-		this._placeBeforeCursor({
-			type: "FunctionCall",
-			name: this._cursor.value,
-			args: [],
-			pool: "functions"
-		});
-	};
-	/**
-	* Handles identifier tokens by adding them as a new node in the AST.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.identifier = function(token) {
-		var node = {
-			type: "Identifier",
-			value: token.value
-		};
-		if (this._nextIdentEncapsulate) {
-			node.from = this._cursor;
-			this._placeBeforeCursor(node);
-			this._nextIdentEncapsulate = false;
-		} else {
-			if (this._nextIdentRelative) {
-				node.relative = true;
-				this._nextIdentRelative = false;
-			}
-			this._placeAtCursor(node);
-		}
-	};
-	/**
-	* Handles literal values, such as strings, booleans, and numerics, by adding
-	* them as a new node in the AST.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.literal = function(token) {
-		this._placeAtCursor({
-			type: "Literal",
-			value: token.value
-		});
-	};
-	/**
-	* Queues a new object literal key to be written once a value is collected.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.objKey = function(token) {
-		this._curObjKey = token.value;
-	};
-	/**
-	* Handles new object literals by adding them as a new node in the AST,
-	* initialized with an empty object.
-	*/
-	exports.objStart = function() {
-		this._placeAtCursor({
-			type: "ObjectLiteral",
-			value: {}
-		});
-	};
-	/**
-	* Handles an object value by adding its AST to the queued key on the object
-	* literal node currently at the cursor.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.objVal = function(ast) {
-		this._cursor.value[this._curObjKey] = ast;
-	};
-	/**
-	* Handles traditional subexpressions, delineated with the groupStart and
-	* groupEnd elements.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.subExpression = function(ast) {
-		this._placeAtCursor(ast);
-	};
-	/**
-	* Handles a completed alternate subexpression of a ternary operator.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.ternaryEnd = function(ast) {
-		this._cursor.alternate = ast;
-	};
-	/**
-	* Handles a completed consequent subexpression of a ternary operator.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.ternaryMid = function(ast) {
-		this._cursor.consequent = ast;
-	};
-	/**
-	* Handles the start of a new ternary expression by encapsulating the entire
-	* AST in a ConditionalExpression node, and using the existing tree as the
-	* test element.
-	*/
-	exports.ternaryStart = function() {
-		this._tree = {
-			type: "ConditionalExpression",
-			test: this._tree
-		};
-		this._cursor = this._tree;
-	};
-	/**
-	* Handles identifier tokens when used to indicate the name of a transform to
-	* be applied.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.transform = function(token) {
-		this._placeBeforeCursor({
-			type: "FunctionCall",
-			name: token.value,
-			args: [this._cursor],
-			pool: "transforms"
-		});
-	};
-	/**
-	* Handles token of type 'unaryOp', indicating that the operation has only
-	* one input: a right side.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.unaryOp = function(token) {
-		this._placeAtCursor({
-			type: "UnaryExpression",
-			operator: token.value
-		});
-	};
-}));
-//#endregion
-export default require_handlers();
-export { require_handlers };
-
-//# sourceMappingURL=handlers.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/parser/handlers.js"],"sourcesContent":["\"use strict\";\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\n\n/**\n * Handles a subexpression that's used to define a transform argument's value.\n * @param {{type: <string>}} ast The subexpression tree\n */\nexports.argVal = function (ast) {\n  if (ast) this._cursor.args.push(ast);\n};\n/**\n * Handles new array literals by adding them as a new node in the AST,\n * initialized with an empty array.\n */\n\n\nexports.arrayStart = function () {\n  this._placeAtCursor({\n    type: 'ArrayLiteral',\n    value: []\n  });\n};\n/**\n * Handles a subexpression representing an element of an array literal.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.arrayVal = function (ast) {\n  if (ast) {\n    this._cursor.value.push(ast);\n  }\n};\n/**\n * Handles tokens of type 'binaryOp', indicating an operation that has two\n * inputs: a left side and a right side.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.binaryOp = function (token) {\n  var precedence = this._grammar.elements[token.value].precedence || 0;\n  var parent = this._cursor._parent;\n\n  while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {\n    this._cursor = parent;\n    parent = parent._parent;\n  }\n\n  var node = {\n    type: 'BinaryExpression',\n    operator: token.value,\n    left: this._cursor\n  };\n\n  this._setParent(this._cursor, node);\n\n  this._cursor = parent;\n\n  this._placeAtCursor(node);\n};\n/**\n * Handles successive nodes in an identifier chain.  More specifically, it\n * sets values that determine how the following identifier gets placed in the\n * AST.\n */\n\n\nexports.dot = function () {\n  this._nextIdentEncapsulate = this._cursor && this._cursor.type !== 'UnaryExpression' && (this._cursor.type !== 'BinaryExpression' || this._cursor.type === 'BinaryExpression' && this._cursor.right);\n  this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;\n\n  if (this._nextIdentRelative) {\n    this._relative = true;\n  }\n};\n/**\n * Handles a subexpression used for filtering an array returned by an\n * identifier chain.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.filter = function (ast) {\n  this._placeBeforeCursor({\n    type: 'FilterExpression',\n    expr: ast,\n    relative: this._subParser.isRelative(),\n    subject: this._cursor\n  });\n};\n/**\n * Handles identifier tokens when used to indicate the name of a function to\n * be called.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.functionCall = function () {\n  this._placeBeforeCursor({\n    type: 'FunctionCall',\n    name: this._cursor.value,\n    args: [],\n    pool: 'functions'\n  });\n};\n/**\n * Handles identifier tokens by adding them as a new node in the AST.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.identifier = function (token) {\n  var node = {\n    type: 'Identifier',\n    value: token.value\n  };\n\n  if (this._nextIdentEncapsulate) {\n    node.from = this._cursor;\n\n    this._placeBeforeCursor(node);\n\n    this._nextIdentEncapsulate = false;\n  } else {\n    if (this._nextIdentRelative) {\n      node.relative = true;\n      this._nextIdentRelative = false;\n    }\n\n    this._placeAtCursor(node);\n  }\n};\n/**\n * Handles literal values, such as strings, booleans, and numerics, by adding\n * them as a new node in the AST.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.literal = function (token) {\n  this._placeAtCursor({\n    type: 'Literal',\n    value: token.value\n  });\n};\n/**\n * Queues a new object literal key to be written once a value is collected.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.objKey = function (token) {\n  this._curObjKey = token.value;\n};\n/**\n * Handles new object literals by adding them as a new node in the AST,\n * initialized with an empty object.\n */\n\n\nexports.objStart = function () {\n  this._placeAtCursor({\n    type: 'ObjectLiteral',\n    value: {}\n  });\n};\n/**\n * Handles an object value by adding its AST to the queued key on the object\n * literal node currently at the cursor.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.objVal = function (ast) {\n  this._cursor.value[this._curObjKey] = ast;\n};\n/**\n * Handles traditional subexpressions, delineated with the groupStart and\n * groupEnd elements.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.subExpression = function (ast) {\n  this._placeAtCursor(ast);\n};\n/**\n * Handles a completed alternate subexpression of a ternary operator.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.ternaryEnd = function (ast) {\n  this._cursor.alternate = ast;\n};\n/**\n * Handles a completed consequent subexpression of a ternary operator.\n * @param {{type: <string>}} ast The subexpression tree\n */\n\n\nexports.ternaryMid = function (ast) {\n  this._cursor.consequent = ast;\n};\n/**\n * Handles the start of a new ternary expression by encapsulating the entire\n * AST in a ConditionalExpression node, and using the existing tree as the\n * test element.\n */\n\n\nexports.ternaryStart = function () {\n  this._tree = {\n    type: 'ConditionalExpression',\n    test: this._tree\n  };\n  this._cursor = this._tree;\n};\n/**\n * Handles identifier tokens when used to indicate the name of a transform to\n * be applied.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.transform = function (token) {\n  this._placeBeforeCursor({\n    type: 'FunctionCall',\n    name: token.value,\n    args: [this._cursor],\n    pool: 'transforms'\n  });\n};\n/**\n * Handles token of type 'unaryOp', indicating that the operation has only\n * one input: a right side.\n * @param {{type: <string>}} token A token object\n */\n\n\nexports.unaryOp = function (token) {\n  this._placeAtCursor({\n    type: 'UnaryExpression',\n    operator: token.value\n  });\n};"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAWA,SAAQ,SAAS,SAAU,KAAK;AAC9B,MAAI,IAAK,MAAK,QAAQ,KAAK,KAAK,IAAI;;;;;;AAQtC,SAAQ,aAAa,WAAY;AAC/B,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,EAAE;GACV,CAAC;;;;;;AAQJ,SAAQ,WAAW,SAAU,KAAK;AAChC,MAAI,IACF,MAAK,QAAQ,MAAM,KAAK,IAAI;;;;;;;AAUhC,SAAQ,WAAW,SAAU,OAAO;EAClC,IAAI,aAAa,KAAK,SAAS,SAAS,MAAM,OAAO,cAAc;EACnE,IAAI,SAAS,KAAK,QAAQ;AAE1B,SAAO,UAAU,OAAO,YAAY,KAAK,SAAS,SAAS,OAAO,UAAU,cAAc,YAAY;AACpG,QAAK,UAAU;AACf,YAAS,OAAO;;EAGlB,IAAI,OAAO;GACT,MAAM;GACN,UAAU,MAAM;GAChB,MAAM,KAAK;GACZ;AAED,OAAK,WAAW,KAAK,SAAS,KAAK;AAEnC,OAAK,UAAU;AAEf,OAAK,eAAe,KAAK;;;;;;;AAS3B,SAAQ,MAAM,WAAY;AACxB,OAAK,wBAAwB,KAAK,WAAW,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ,SAAS,sBAAsB,KAAK,QAAQ;AAC9L,OAAK,qBAAqB,CAAC,KAAK,WAAW,KAAK,WAAW,CAAC,KAAK;AAEjE,MAAI,KAAK,mBACP,MAAK,YAAY;;;;;;;AAUrB,SAAQ,SAAS,SAAU,KAAK;AAC9B,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM;GACN,UAAU,KAAK,WAAW,YAAY;GACtC,SAAS,KAAK;GACf,CAAC;;;;;;;AASJ,SAAQ,eAAe,WAAY;AACjC,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM,KAAK,QAAQ;GACnB,MAAM,EAAE;GACR,MAAM;GACP,CAAC;;;;;;AAQJ,SAAQ,aAAa,SAAU,OAAO;EACpC,IAAI,OAAO;GACT,MAAM;GACN,OAAO,MAAM;GACd;AAED,MAAI,KAAK,uBAAuB;AAC9B,QAAK,OAAO,KAAK;AAEjB,QAAK,mBAAmB,KAAK;AAE7B,QAAK,wBAAwB;SACxB;AACL,OAAI,KAAK,oBAAoB;AAC3B,SAAK,WAAW;AAChB,SAAK,qBAAqB;;AAG5B,QAAK,eAAe,KAAK;;;;;;;;AAU7B,SAAQ,UAAU,SAAU,OAAO;AACjC,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,MAAM;GACd,CAAC;;;;;;AAQJ,SAAQ,SAAS,SAAU,OAAO;AAChC,OAAK,aAAa,MAAM;;;;;;AAQ1B,SAAQ,WAAW,WAAY;AAC7B,OAAK,eAAe;GAClB,MAAM;GACN,OAAO,EAAE;GACV,CAAC;;;;;;;AASJ,SAAQ,SAAS,SAAU,KAAK;AAC9B,OAAK,QAAQ,MAAM,KAAK,cAAc;;;;;;;AASxC,SAAQ,gBAAgB,SAAU,KAAK;AACrC,OAAK,eAAe,IAAI;;;;;;AAQ1B,SAAQ,aAAa,SAAU,KAAK;AAClC,OAAK,QAAQ,YAAY;;;;;;AAQ3B,SAAQ,aAAa,SAAU,KAAK;AAClC,OAAK,QAAQ,aAAa;;;;;;;AAS5B,SAAQ,eAAe,WAAY;AACjC,OAAK,QAAQ;GACX,MAAM;GACN,MAAM,KAAK;GACZ;AACD,OAAK,UAAU,KAAK;;;;;;;AAStB,SAAQ,YAAY,SAAU,OAAO;AACnC,OAAK,mBAAmB;GACtB,MAAM;GACN,MAAM,MAAM;GACZ,MAAM,CAAC,KAAK,QAAQ;GACpB,MAAM;GACP,CAAC;;;;;;;AASJ,SAAQ,UAAU,SAAU,OAAO;AACjC,OAAK,eAAe;GAClB,MAAM;GACN,UAAU,MAAM;GACjB,CAAC"}