@math.gl/core 5.0.0-alpha.17 → 5.0.0-alpha.19

package/dist/expressions/index.cjs

@@ -0,0 +1,1483 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/expressions/index.js
+var index_exports = {};
+__export(index_exports, {
+  BASIC_MATH_FUNCTION_LIBRARY: () => BASIC_MATH_FUNCTION_LIBRARY,
+  ExpressionFunctionRegistry: () => ExpressionFunctionRegistry,
+  addBinaryOp: () => addBinaryOp,
+  addUnaryOp: () => addUnaryOp,
+  compile: () => compile,
+  compileAsync: () => compileAsync,
+  eval: () => evaluateExpression,
+  evalAsync: () => evalAsync,
+  mergeFunctionLibraries: () => mergeFunctionLibraries,
+  parse: () => parse,
+  parseExpressionString: () => parseExpressionString
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/expressions/function-registry.js
+var FUNCTION_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var DISALLOWED_FUNCTION_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var ExpressionFunctionRegistry = class {
+  /**
+   * Creates a function registry.
+   *
+   * @param functionTables - Function tables to register in order.
+   * @throws If a table contains an invalid or duplicate function name.
+   */
+  constructor(functionTables = []) {
+    this.functions = /* @__PURE__ */ Object.create(null);
+    for (const functionTable of functionTables) {
+      this.registerFunctions(functionTable);
+    }
+  }
+  /**
+   * Registers one named function.
+   *
+   * @param name - Identifier used to call the function from an expression.
+   * @param fn - JavaScript function invoked with evaluated expression arguments.
+   * @param options - Duplicate registration behavior.
+   * @returns This registry.
+   * @throws If the name is invalid, the value is not a function, or the name is
+   * already registered and replacement was not requested.
+   */
+  registerFunction(name, fn, options = {}) {
+    validateFunction(name, fn);
+    if (this.hasFunction(name) && !options.replace) {
+      throw new Error(`Expression function "${name}" is already registered.`);
+    }
+    this.functions[name] = fn;
+    return this;
+  }
+  /**
+   * Registers all entries in a function table.
+   *
+   * @param functionTable - Map from expression identifiers to JavaScript functions.
+   * @param options - Duplicate registration behavior.
+   * @returns This registry.
+   * @throws If any entry is invalid or conflicts with an existing registration.
+   *
+   * @remarks
+   * Validation is atomic: no entries are registered when any entry is invalid.
+   */
+  registerFunctions(functionTable, options = {}) {
+    const entries = Object.entries(functionTable);
+    const names = /* @__PURE__ */ new Set();
+    for (const [name, fn] of entries) {
+      validateFunction(name, fn);
+      if (names.has(name) || this.hasFunction(name) && !options.replace) {
+        throw new Error(`Expression function "${name}" is already registered.`);
+      }
+      names.add(name);
+    }
+    for (const [name, fn] of entries) {
+      this.functions[name] = fn;
+    }
+    return this;
+  }
+  /**
+   * Removes a registered function.
+   *
+   * @param name - Function name to remove.
+   * @returns `true` when a function was removed.
+   */
+  unregisterFunction(name) {
+    if (!this.hasFunction(name)) {
+      return false;
+    }
+    return delete this.functions[name];
+  }
+  /**
+   * Tests whether a function is registered.
+   *
+   * @param name - Function name to inspect.
+   * @returns `true` when the registry contains the name.
+   */
+  hasFunction(name) {
+    return Object.prototype.hasOwnProperty.call(this.functions, name);
+  }
+  /**
+   * Returns a registered function.
+   *
+   * @param name - Function name to retrieve.
+   * @returns The registered function, or `undefined`.
+   */
+  getFunction(name) {
+    return this.functions[name];
+  }
+  /**
+   * Returns an immutable snapshot of all registered functions.
+   *
+   * @returns A frozen function table.
+   */
+  getFunctionTable() {
+    return Object.freeze({ ...this.functions });
+  }
+};
+function validateFunction(name, fn) {
+  if (!FUNCTION_NAME_PATTERN.test(name) || DISALLOWED_FUNCTION_NAMES.has(name)) {
+    throw new Error(`Invalid expression function name "${name}".`);
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError(`Expression function "${name}" must be a function.`);
+  }
+}
+
+// dist/expressions/vendor/jsep/runtime.js
+var Hooks = class {
+  /**
+   * @callback HookCallback
+   * @this {*|Jsep} this
+   * @param {Jsep} env
+   * @returns: void
+   */
+  /**
+   * Adds the given callback to the list of callbacks for the given hook.
+   *
+   * The callback will be invoked when the hook it is registered for is run.
+   *
+   * One callback function can be registered to multiple hooks and the same hook multiple times.
+   *
+   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+   * @public
+   */
+  add(name, callback, first) {
+    if (typeof arguments[0] != "string") {
+      for (let name2 in arguments[0]) {
+        this.add(name2, arguments[0][name2], arguments[1]);
+      }
+    } else {
+      (Array.isArray(name) ? name : [name]).forEach(function(name2) {
+        this[name2] = this[name2] || [];
+        if (callback) {
+          this[name2][first ? "unshift" : "push"](callback);
+        }
+      }, this);
+    }
+  }
+  /**
+   * Runs a hook invoking all registered callbacks with the given environment variables.
+   *
+   * Callbacks will be invoked synchronously and in the order in which they were registered.
+   *
+   * @param {string} name The name of the hook.
+   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+   * @public
+   */
+  run(name, env) {
+    this[name] = this[name] || [];
+    this[name].forEach(function(callback) {
+      callback.call(env && env.context ? env.context : env, env);
+    });
+  }
+};
+var Plugins = class {
+  constructor(jsep22) {
+    this.jsep = jsep22;
+    this.registered = {};
+  }
+  /**
+   * @callback PluginSetup
+   * @this {Jsep} jsep
+   * @returns: void
+   */
+  /**
+   * Adds the given plugin(s) to the registry
+   *
+   * @param {object} plugins
+   * @param {string} plugins.name The name of the plugin
+   * @param {PluginSetup} plugins.init The init function
+   * @public
+   */
+  register(...plugins) {
+    plugins.forEach((plugin) => {
+      if (typeof plugin !== "object" || !plugin.name || !plugin.init) {
+        throw new Error("Invalid JSEP plugin format");
+      }
+      if (this.registered[plugin.name]) {
+        return;
+      }
+      plugin.init(this.jsep);
+      this.registered[plugin.name] = plugin;
+    });
+  }
+};
+var Jsep = class _Jsep {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    return "1.4.0";
+  }
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return "JavaScript Expression Parser (JSEP) v" + _Jsep.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(op_name) {
+    _Jsep.max_unop_len = Math.max(op_name.length, _Jsep.max_unop_len);
+    _Jsep.unary_ops[op_name] = 1;
+    return _Jsep;
+  }
+  /**
+   * @method jsep.addBinaryOp
+   * @param {string} op_name The name of the binary op to add
+   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+   * @returns {Jsep}
+   */
+  static addBinaryOp(op_name, precedence, isRightAssociative) {
+    _Jsep.max_binop_len = Math.max(op_name.length, _Jsep.max_binop_len);
+    _Jsep.binary_ops[op_name] = precedence;
+    if (isRightAssociative) {
+      _Jsep.right_associative.add(op_name);
+    } else {
+      _Jsep.right_associative.delete(op_name);
+    }
+    return _Jsep;
+  }
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(char) {
+    _Jsep.additional_identifier_chars.add(char);
+    return _Jsep;
+  }
+  /**
+   * @method addLiteral
+   * @param {string} literal_name The name of the literal to add
+   * @param {*} literal_value The value of the literal
+   * @returns {Jsep}
+   */
+  static addLiteral(literal_name, literal_value) {
+    _Jsep.literals[literal_name] = literal_value;
+    return _Jsep;
+  }
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(op_name) {
+    delete _Jsep.unary_ops[op_name];
+    if (op_name.length === _Jsep.max_unop_len) {
+      _Jsep.max_unop_len = _Jsep.getMaxKeyLen(_Jsep.unary_ops);
+    }
+    return _Jsep;
+  }
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    _Jsep.unary_ops = {};
+    _Jsep.max_unop_len = 0;
+    return _Jsep;
+  }
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(char) {
+    _Jsep.additional_identifier_chars.delete(char);
+    return _Jsep;
+  }
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(op_name) {
+    delete _Jsep.binary_ops[op_name];
+    if (op_name.length === _Jsep.max_binop_len) {
+      _Jsep.max_binop_len = _Jsep.getMaxKeyLen(_Jsep.binary_ops);
+    }
+    _Jsep.right_associative.delete(op_name);
+    return _Jsep;
+  }
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    _Jsep.binary_ops = {};
+    _Jsep.max_binop_len = 0;
+    return _Jsep;
+  }
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(literal_name) {
+    delete _Jsep.literals[literal_name];
+    return _Jsep;
+  }
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    _Jsep.literals = {};
+    return _Jsep;
+  }
+  // ==================== END CONFIG ============================
+  /**
+   * @returns {string}
+   */
+  get char() {
+    return this.expr.charAt(this.index);
+  }
+  /**
+   * @returns {number}
+   */
+  get code() {
+    return this.expr.charCodeAt(this.index);
+  }
+  /**
+   * @param {string} expr a string with the passed in express
+   * @returns Jsep
+   */
+  constructor(expr) {
+    this.expr = expr;
+    this.index = 0;
+  }
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(expr) {
+    return new _Jsep(expr).parse();
+  }
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(obj) {
+    return Math.max(0, ...Object.keys(obj).map((k) => k.length));
+  }
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(ch) {
+    return ch >= 48 && ch <= 57;
+  }
+  /**
+   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+   * @param {string} op_val
+   * @returns {number}
+   */
+  static binaryPrecedence(op_val) {
+    return _Jsep.binary_ops[op_val] || 0;
+  }
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(ch) {
+    return ch >= 65 && ch <= 90 || // A...Z
+    ch >= 97 && ch <= 122 || // a...z
+    ch >= 128 && !_Jsep.binary_ops[String.fromCharCode(ch)] || // any non-ASCII that is not an operator
+    _Jsep.additional_identifier_chars.has(String.fromCharCode(ch));
+  }
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(ch) {
+    return _Jsep.isIdentifierStart(ch) || _Jsep.isDecimalDigit(ch);
+  }
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(message) {
+    const error = new Error(message + " at character " + this.index);
+    error.index = this.index;
+    error.description = message;
+    throw error;
+  }
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(name, node) {
+    if (_Jsep.hooks[name]) {
+      const env = { context: this, node };
+      _Jsep.hooks.run(name, env);
+      return env.node;
+    }
+    return node;
+  }
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(name) {
+    if (_Jsep.hooks[name]) {
+      const env = { context: this };
+      _Jsep.hooks[name].find(function(callback) {
+        callback.call(env.context, env);
+        return env.node;
+      });
+      return env.node;
+    }
+  }
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let ch = this.code;
+    while (ch === _Jsep.SPACE_CODE || ch === _Jsep.TAB_CODE || ch === _Jsep.LF_CODE || ch === _Jsep.CR_CODE) {
+      ch = this.expr.charCodeAt(++this.index);
+    }
+    this.runHook("gobble-spaces");
+  }
+  /**
+   * Top-level method to parse all expressions and returns compound or single node
+   * @returns {jsep.Expression}
+   */
+  parse() {
+    this.runHook("before-all");
+    const nodes = this.gobbleExpressions();
+    const node = nodes.length === 1 ? nodes[0] : {
+      type: _Jsep.COMPOUND,
+      body: nodes
+    };
+    return this.runHook("after-all", node);
+  }
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(untilICode) {
+    let nodes = [], ch_i, node;
+    while (this.index < this.expr.length) {
+      ch_i = this.code;
+      if (ch_i === _Jsep.SEMCOL_CODE || ch_i === _Jsep.COMMA_CODE) {
+        this.index++;
+      } else {
+        if (node = this.gobbleExpression()) {
+          nodes.push(node);
+        } else if (this.index < this.expr.length) {
+          if (ch_i === untilICode) {
+            break;
+          }
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+      }
+    }
+    return nodes;
+  }
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+    this.gobbleSpaces();
+    return this.runHook("after-expression", node);
+  }
+  /**
+   * Search for the operation portion of the string (e.g. `+`, `===`)
+   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+   * and move down from 3 to 2 to 1 character until a matching binary operation is found
+   * then, return that binary operation
+   * @returns {string|boolean}
+   */
+  gobbleBinaryOp() {
+    this.gobbleSpaces();
+    let to_check = this.expr.substr(this.index, _Jsep.max_binop_len);
+    let tc_len = to_check.length;
+    while (tc_len > 0) {
+      if (_Jsep.binary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+        this.index += tc_len;
+        return to_check;
+      }
+      to_check = to_check.substr(0, --tc_len);
+    }
+    return false;
+  }
+  /**
+   * This function is responsible for gobbling an individual expression,
+   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+   * @returns {?jsep.BinaryExpression}
+   */
+  gobbleBinaryExpression() {
+    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+    left = this.gobbleToken();
+    if (!left) {
+      return left;
+    }
+    biop = this.gobbleBinaryOp();
+    if (!biop) {
+      return left;
+    }
+    biop_info = { value: biop, prec: _Jsep.binaryPrecedence(biop), right_a: _Jsep.right_associative.has(biop) };
+    right = this.gobbleToken();
+    if (!right) {
+      this.throwError("Expected expression after " + biop);
+    }
+    stack = [left, biop_info, right];
+    while (biop = this.gobbleBinaryOp()) {
+      prec = _Jsep.binaryPrecedence(biop);
+      if (prec === 0) {
+        this.index -= biop.length;
+        break;
+      }
+      biop_info = { value: biop, prec, right_a: _Jsep.right_associative.has(biop) };
+      cur_biop = biop;
+      const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+        right = stack.pop();
+        biop = stack.pop().value;
+        left = stack.pop();
+        node = {
+          type: _Jsep.BINARY_EXP,
+          operator: biop,
+          left,
+          right
+        };
+        stack.push(node);
+      }
+      node = this.gobbleToken();
+      if (!node) {
+        this.throwError("Expected expression after " + cur_biop);
+      }
+      stack.push(biop_info, node);
+    }
+    i = stack.length - 1;
+    node = stack[i];
+    while (i > 1) {
+      node = {
+        type: _Jsep.BINARY_EXP,
+        operator: stack[i - 1].value,
+        left: stack[i - 2],
+        right: node
+      };
+      i -= 2;
+    }
+    return node;
+  }
+  /**
+   * An individual part of a binary expression:
+   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleToken() {
+    let ch, to_check, tc_len, node;
+    this.gobbleSpaces();
+    node = this.searchHook("gobble-token");
+    if (node) {
+      return this.runHook("after-token", node);
+    }
+    ch = this.code;
+    if (_Jsep.isDecimalDigit(ch) || ch === _Jsep.PERIOD_CODE) {
+      return this.gobbleNumericLiteral();
+    }
+    if (ch === _Jsep.SQUOTE_CODE || ch === _Jsep.DQUOTE_CODE) {
+      node = this.gobbleStringLiteral();
+    } else if (ch === _Jsep.OBRACK_CODE) {
+      node = this.gobbleArray();
+    } else {
+      to_check = this.expr.substr(this.index, _Jsep.max_unop_len);
+      tc_len = to_check.length;
+      while (tc_len > 0) {
+        if (_Jsep.unary_ops.hasOwnProperty(to_check) && (!_Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !_Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+          this.index += tc_len;
+          const argument = this.gobbleToken();
+          if (!argument) {
+            this.throwError("missing unaryOp argument");
+          }
+          return this.runHook("after-token", {
+            type: _Jsep.UNARY_EXP,
+            operator: to_check,
+            argument,
+            prefix: true
+          });
+        }
+        to_check = to_check.substr(0, --tc_len);
+      }
+      if (_Jsep.isIdentifierStart(ch)) {
+        node = this.gobbleIdentifier();
+        if (_Jsep.literals.hasOwnProperty(node.name)) {
+          node = {
+            type: _Jsep.LITERAL,
+            value: _Jsep.literals[node.name],
+            raw: node.name
+          };
+        } else if (node.name === _Jsep.this_str) {
+          node = { type: _Jsep.THIS_EXP };
+        }
+      } else if (ch === _Jsep.OPAREN_CODE) {
+        node = this.gobbleGroup();
+      }
+    }
+    if (!node) {
+      return this.runHook("after-token", false);
+    }
+    node = this.gobbleTokenProperty(node);
+    return this.runHook("after-token", node);
+  }
+  /**
+   * Gobble properties of of identifiers/strings/arrays/groups.
+   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+   * It also gobbles function calls:
+   * e.g. `Math.acos(obj.angle)`
+   * @param {jsep.Expression} node
+   * @returns {jsep.Expression}
+   */
+  gobbleTokenProperty(node) {
+    this.gobbleSpaces();
+    let ch = this.code;
+    while (ch === _Jsep.PERIOD_CODE || ch === _Jsep.OBRACK_CODE || ch === _Jsep.OPAREN_CODE || ch === _Jsep.QUMARK_CODE) {
+      let optional;
+      if (ch === _Jsep.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== _Jsep.PERIOD_CODE) {
+          break;
+        }
+        optional = true;
+        this.index += 2;
+        this.gobbleSpaces();
+        ch = this.code;
+      }
+      this.index++;
+      if (ch === _Jsep.OBRACK_CODE) {
+        node = {
+          type: _Jsep.MEMBER_EXP,
+          computed: true,
+          object: node,
+          property: this.gobbleExpression()
+        };
+        if (!node.property) {
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+        this.gobbleSpaces();
+        ch = this.code;
+        if (ch !== _Jsep.CBRACK_CODE) {
+          this.throwError("Unclosed [");
+        }
+        this.index++;
+      } else if (ch === _Jsep.OPAREN_CODE) {
+        node = {
+          type: _Jsep.CALL_EXP,
+          "arguments": this.gobbleArguments(_Jsep.CPAREN_CODE),
+          callee: node
+        };
+      } else if (ch === _Jsep.PERIOD_CODE || optional) {
+        if (optional) {
+          this.index--;
+        }
+        this.gobbleSpaces();
+        node = {
+          type: _Jsep.MEMBER_EXP,
+          computed: false,
+          object: node,
+          property: this.gobbleIdentifier()
+        };
+      }
+      if (optional) {
+        node.optional = true;
+      }
+      this.gobbleSpaces();
+      ch = this.code;
+    }
+    return node;
+  }
+  /**
+   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+   * @returns {jsep.Literal}
+   */
+  gobbleNumericLiteral() {
+    let number = "", ch, chCode;
+    while (_Jsep.isDecimalDigit(this.code)) {
+      number += this.expr.charAt(this.index++);
+    }
+    if (this.code === _Jsep.PERIOD_CODE) {
+      number += this.expr.charAt(this.index++);
+      while (_Jsep.isDecimalDigit(this.code)) {
+        number += this.expr.charAt(this.index++);
+      }
+    }
+    ch = this.char;
+    if (ch === "e" || ch === "E") {
+      number += this.expr.charAt(this.index++);
+      ch = this.char;
+      if (ch === "+" || ch === "-") {
+        number += this.expr.charAt(this.index++);
+      }
+      while (_Jsep.isDecimalDigit(this.code)) {
+        number += this.expr.charAt(this.index++);
+      }
+      if (!_Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
+        this.throwError("Expected exponent (" + number + this.char + ")");
+      }
+    }
+    chCode = this.code;
+    if (_Jsep.isIdentifierStart(chCode)) {
+      this.throwError("Variable names cannot start with a number (" + number + this.char + ")");
+    } else if (chCode === _Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === _Jsep.PERIOD_CODE) {
+      this.throwError("Unexpected period");
+    }
+    return {
+      type: _Jsep.LITERAL,
+      value: parseFloat(number),
+      raw: number
+    };
+  }
+  /**
+   * Parses a string literal, staring with single or double quotes with basic support for escape codes
+   * e.g. `"hello world"`, `'this is\nJSEP'`
+   * @returns {jsep.Literal}
+   */
+  gobbleStringLiteral() {
+    let str = "";
+    const startIndex = this.index;
+    const quote = this.expr.charAt(this.index++);
+    let closed = false;
+    while (this.index < this.expr.length) {
+      let ch = this.expr.charAt(this.index++);
+      if (ch === quote) {
+        closed = true;
+        break;
+      } else if (ch === "\\") {
+        ch = this.expr.charAt(this.index++);
+        switch (ch) {
+          case "n":
+            str += "\n";
+            break;
+          case "r":
+            str += "\r";
+            break;
+          case "t":
+            str += "	";
+            break;
+          case "b":
+            str += "\b";
+            break;
+          case "f":
+            str += "\f";
+            break;
+          case "v":
+            str += "\v";
+            break;
+          default:
+            str += ch;
+        }
+      } else {
+        str += ch;
+      }
+    }
+    if (!closed) {
+      this.throwError('Unclosed quote after "' + str + '"');
+    }
+    return {
+      type: _Jsep.LITERAL,
+      value: str,
+      raw: this.expr.substring(startIndex, this.index)
+    };
+  }
+  /**
+   * Gobbles only identifiers
+   * e.g.: `foo`, `_value`, `$x1`
+   * Also, this function checks if that identifier is a literal:
+   * (e.g. `true`, `false`, `null`) or `this`
+   * @returns {jsep.Identifier}
+   */
+  gobbleIdentifier() {
+    let ch = this.code, start = this.index;
+    if (_Jsep.isIdentifierStart(ch)) {
+      this.index++;
+    } else {
+      this.throwError("Unexpected " + this.char);
+    }
+    while (this.index < this.expr.length) {
+      ch = this.code;
+      if (_Jsep.isIdentifierPart(ch)) {
+        this.index++;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: _Jsep.IDENTIFIER,
+      name: this.expr.slice(start, this.index)
+    };
+  }
+  /**
+   * Gobbles a list of arguments within the context of a function call
+   * or array literal. This function also assumes that the opening character
+   * `(` or `[` has already been gobbled, and gobbles expressions and commas
+   * until the terminator character `)` or `]` is encountered.
+   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+   * @param {number} termination
+   * @returns {jsep.Expression[]}
+   */
+  gobbleArguments(termination) {
+    const args = [];
+    let closed = false;
+    let separator_count = 0;
+    while (this.index < this.expr.length) {
+      this.gobbleSpaces();
+      let ch_i = this.code;
+      if (ch_i === termination) {
+        closed = true;
+        this.index++;
+        if (termination === _Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
+          this.throwError("Unexpected token " + String.fromCharCode(termination));
+        }
+        break;
+      } else if (ch_i === _Jsep.COMMA_CODE) {
+        this.index++;
+        separator_count++;
+        if (separator_count !== args.length) {
+          if (termination === _Jsep.CPAREN_CODE) {
+            this.throwError("Unexpected token ,");
+          } else if (termination === _Jsep.CBRACK_CODE) {
+            for (let arg = args.length; arg < separator_count; arg++) {
+              args.push(null);
+            }
+          }
+        }
+      } else if (args.length !== separator_count && separator_count !== 0) {
+        this.throwError("Expected comma");
+      } else {
+        const node = this.gobbleExpression();
+        if (!node || node.type === _Jsep.COMPOUND) {
+          this.throwError("Expected comma");
+        }
+        args.push(node);
+      }
+    }
+    if (!closed) {
+      this.throwError("Expected " + String.fromCharCode(termination));
+    }
+    return args;
+  }
+  /**
+   * Responsible for parsing a group of things within parentheses `()`
+   * that have no identifier in front (so not a function call)
+   * This function assumes that it needs to gobble the opening parenthesis
+   * and then tries to gobble everything within that parenthesis, assuming
+   * that the next thing it should see is the close parenthesis. If not,
+   * then the expression probably doesn't have a `)`
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleGroup() {
+    this.index++;
+    let nodes = this.gobbleExpressions(_Jsep.CPAREN_CODE);
+    if (this.code === _Jsep.CPAREN_CODE) {
+      this.index++;
+      if (nodes.length === 1) {
+        return nodes[0];
+      } else if (!nodes.length) {
+        return false;
+      } else {
+        return {
+          type: _Jsep.SEQUENCE_EXP,
+          expressions: nodes
+        };
+      }
+    } else {
+      this.throwError("Unclosed (");
+    }
+  }
+  /**
+   * Responsible for parsing Array literals `[1, 2, 3]`
+   * This function assumes that it needs to gobble the opening bracket
+   * and then tries to gobble the expressions as arguments.
+   * @returns {jsep.ArrayExpression}
+   */
+  gobbleArray() {
+    this.index++;
+    return {
+      type: _Jsep.ARRAY_EXP,
+      elements: this.gobbleArguments(_Jsep.CBRACK_CODE)
+    };
+  }
+};
+var hooks = new Hooks();
+Object.assign(Jsep, {
+  hooks,
+  plugins: new Plugins(Jsep),
+  // Node Types
+  // ----------
+  // This is the full set of types that any JSEP node can be.
+  // Store them here to save space when minified
+  COMPOUND: "Compound",
+  SEQUENCE_EXP: "SequenceExpression",
+  IDENTIFIER: "Identifier",
+  MEMBER_EXP: "MemberExpression",
+  LITERAL: "Literal",
+  THIS_EXP: "ThisExpression",
+  CALL_EXP: "CallExpression",
+  UNARY_EXP: "UnaryExpression",
+  BINARY_EXP: "BinaryExpression",
+  ARRAY_EXP: "ArrayExpression",
+  TAB_CODE: 9,
+  LF_CODE: 10,
+  CR_CODE: 13,
+  SPACE_CODE: 32,
+  PERIOD_CODE: 46,
+  // '.'
+  COMMA_CODE: 44,
+  // ','
+  SQUOTE_CODE: 39,
+  // single quote
+  DQUOTE_CODE: 34,
+  // double quotes
+  OPAREN_CODE: 40,
+  // (
+  CPAREN_CODE: 41,
+  // )
+  OBRACK_CODE: 91,
+  // [
+  CBRACK_CODE: 93,
+  // ]
+  QUMARK_CODE: 63,
+  // ?
+  SEMCOL_CODE: 59,
+  // ;
+  COLON_CODE: 58,
+  // :
+  // Operations
+  // ----------
+  // Use a quickly-accessible map to store all of the unary operators
+  // Values are set to `1` (it really doesn't matter)
+  unary_ops: {
+    "-": 1,
+    "!": 1,
+    "~": 1,
+    "+": 1
+  },
+  // Also use a map for the binary operations but set their values to their
+  // binary precedence for quick reference (higher number = higher precedence)
+  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+  binary_ops: {
+    "||": 1,
+    "??": 1,
+    "&&": 2,
+    "|": 3,
+    "^": 4,
+    "&": 5,
+    "==": 6,
+    "!=": 6,
+    "===": 6,
+    "!==": 6,
+    "<": 7,
+    ">": 7,
+    "<=": 7,
+    ">=": 7,
+    "<<": 8,
+    ">>": 8,
+    ">>>": 8,
+    "+": 9,
+    "-": 9,
+    "*": 10,
+    "/": 10,
+    "%": 10,
+    "**": 11
+  },
+  // sets specific binary_ops as right-associative
+  right_associative: /* @__PURE__ */ new Set(["**"]),
+  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+  additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]),
+  // Literals
+  // ----------
+  // Store the values to return for the various literals we may encounter
+  literals: {
+    "true": true,
+    "false": false,
+    "null": null
+  },
+  // Except for `this`, which is special. This could be changed to something like `'self'` as well
+  this_str: "this"
+});
+Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+var jsep = (expr) => new Jsep(expr).parse();
+var stdClassProps = Object.getOwnPropertyNames(class Test {
+});
+Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => {
+  jsep[m] = Jsep[m];
+});
+jsep.Jsep = Jsep;
+var CONDITIONAL_EXP = "ConditionalExpression";
+var ternary = {
+  name: "ternary",
+  init(jsep22) {
+    jsep22.hooks.add("after-expression", function gobbleTernary(env) {
+      if (env.node && this.code === jsep22.QUMARK_CODE) {
+        this.index++;
+        const test = env.node;
+        const consequent = this.gobbleExpression();
+        if (!consequent) {
+          this.throwError("Expected expression");
+        }
+        this.gobbleSpaces();
+        if (this.code === jsep22.COLON_CODE) {
+          this.index++;
+          const alternate = this.gobbleExpression();
+          if (!alternate) {
+            this.throwError("Expected expression");
+          }
+          env.node = {
+            type: CONDITIONAL_EXP,
+            test,
+            consequent,
+            alternate
+          };
+          if (test.operator && jsep22.binary_ops[test.operator] <= 0.9) {
+            let newTest = test;
+            while (newTest.right.operator && jsep22.binary_ops[newTest.right.operator] <= 0.9) {
+              newTest = newTest.right;
+            }
+            env.node.test = newTest.right;
+            newTest.right = env.node;
+            env.node = test;
+          }
+        } else {
+          this.throwError("Expected :");
+        }
+      }
+    });
+  }
+};
+jsep.plugins.register(ternary);
+var runtime_default = jsep;
+
+// dist/lib/math-utils.js
+var EPSILON14 = 1e-14;
+var PI_OVER_TWO = Math.PI / 2;
+var PI_OVER_FOUR = Math.PI / 4;
+var PI_OVER_SIX = Math.PI / 6;
+var PI = Math.PI;
+var TWO_PI = Math.PI * 2;
+
+// dist/lib/common.js
+var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+var DEFAULT_CONFIG = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true,
+  _cartographicRadians: false
+};
+globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+var config = globalThis.mathgl.config;
+function isArray(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function toRadians(degrees2) {
+  return radians(degrees2);
+}
+function toDegrees(radians2) {
+  return degrees(radians2);
+}
+function radians(degrees2, result) {
+  return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+}
+function degrees(radians2, result) {
+  return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+}
+function safeMod(m, n) {
+  if (Math.sign(m) === Math.sign(n) && Math.abs(m) < Math.abs(n)) {
+    return m;
+  }
+  return (m % n + n) % n;
+}
+function normalizeAngle(angle, range) {
+  switch (range) {
+    case "negative-pi-to-pi":
+      return negativePiToPi(angle);
+    case "zero-to-two-pi":
+      return zeroToTwoPi(angle);
+    default:
+      return angle;
+  }
+}
+function zeroToTwoPi(angle) {
+  if (angle >= 0 && angle <= TWO_PI) {
+    return angle;
+  }
+  const remainder = safeMod(angle, TWO_PI);
+  if (Math.abs(remainder) < EPSILON14 && Math.abs(angle) > EPSILON14) {
+    return TWO_PI;
+  }
+  return remainder;
+}
+function negativePiToPi(angle) {
+  if (angle >= -PI && angle <= PI) {
+    return angle;
+  }
+  return zeroToTwoPi(angle + PI) - PI;
+}
+function clamp(value, min, max) {
+  return map(value, (value2) => Math.max(min, Math.min(max, value2)));
+}
+function lerp(a, b, t) {
+  if (isArray(a)) {
+    return a.map((ai, i) => lerp(ai, b[i], t));
+  }
+  return t * b + (1 - t) * a;
+}
+function duplicateArray(array) {
+  return array.clone ? array.clone() : new Array(array.length);
+}
+function map(value, func, result) {
+  if (isArray(value)) {
+    const array = value;
+    result = result || duplicateArray(array);
+    for (let i = 0; i < result.length && i < array.length; ++i) {
+      const val = typeof value === "number" ? value : value[i];
+      result[i] = func(val, i, result);
+    }
+    return result;
+  }
+  return func(value);
+}
+
+// dist/expressions/function-libraries.js
+var BASIC_MATH_FUNCTION_LIBRARY = {
+  abs: Math.abs,
+  acos: Math.acos,
+  asin: Math.asin,
+  atan: Math.atan,
+  ceil: Math.ceil,
+  clamp,
+  cos: Math.cos,
+  degrees,
+  exp: Math.exp,
+  floor: Math.floor,
+  lerp,
+  log: Math.log,
+  max: Math.max,
+  min: Math.min,
+  normalizeAngle,
+  pow: Math.pow,
+  radians,
+  round: Math.round,
+  safeMod,
+  sign: Math.sign,
+  sin: Math.sin,
+  sqrt: Math.sqrt,
+  tan: Math.tan,
+  toDegrees,
+  toRadians,
+  trunc: Math.trunc
+};
+function mergeFunctionLibraries(context, options) {
+  var _a, _b;
+  if (!((_a = options == null ? void 0 : options.libraries) == null ? void 0 : _a.length)) {
+    if (!(options == null ? void 0 : options.registry)) {
+      return context;
+    }
+  }
+  return Object.assign({}, (_b = options.registry) == null ? void 0 : _b.getFunctionTable(), ...options.libraries || [], context);
+}
+
+// dist/expressions/expression-eval.js
+var jsep2 = runtime_default;
+var DEFAULT_PRECEDENCE = {
+  "||": 1,
+  "&&": 2,
+  "|": 3,
+  "^": 4,
+  "&": 5,
+  "==": 6,
+  "!=": 6,
+  "===": 6,
+  "!==": 6,
+  "<": 7,
+  ">": 7,
+  "<=": 7,
+  ">=": 7,
+  "<<": 8,
+  ">>": 8,
+  ">>>": 8,
+  "+": 9,
+  "-": 9,
+  "*": 10,
+  "/": 10,
+  "%": 10
+};
+var binops = {
+  "||": (a, b) => a || b,
+  "&&": (a, b) => a && b,
+  "|": (a, b) => a | b,
+  "^": (a, b) => a ^ b,
+  "&": (a, b) => a & b,
+  "==": (a, b) => {
+    return a == b;
+  },
+  "!=": (a, b) => {
+    return a != b;
+  },
+  "===": (a, b) => a === b,
+  "!==": (a, b) => a !== b,
+  "<": (a, b) => a < b,
+  ">": (a, b) => a > b,
+  "<=": (a, b) => a <= b,
+  ">=": (a, b) => a >= b,
+  "<<": (a, b) => a << b,
+  ">>": (a, b) => a >> b,
+  ">>>": (a, b) => a >>> b,
+  "+": (a, b) => {
+    return a + b;
+  },
+  "-": (a, b) => a - b,
+  "*": (a, b) => a * b,
+  "/": (a, b) => a / b,
+  "%": (a, b) => a % b
+};
+var unops = {
+  "-": (a) => -a,
+  "+": (a) => {
+    return +a;
+  },
+  "~": (a) => ~a,
+  "!": (a) => !a
+};
+function evaluateArray(list, context) {
+  return list.map((value) => evaluate(value, context));
+}
+async function evaluateArrayAsync(list, context) {
+  return await Promise.all(list.map((value) => evalAsync(value, context)));
+}
+function evaluateMember(node, context) {
+  const object = evaluate(node.object, context);
+  const key = node.computed ? evaluate(node.property, context) : node.property.name;
+  if (/^__proto__|prototype|constructor$/.test(key)) {
+    throw new Error(`Access to member "${key}" disallowed.`);
+  }
+  return [object, object == null ? void 0 : object[key]];
+}
+async function evaluateMemberAsync(node, context) {
+  const object = await evalAsync(node.object, context);
+  const key = node.computed ? await evalAsync(node.property, context) : node.property.name;
+  if (/^__proto__|prototype|constructor$/.test(key)) {
+    throw new Error(`Access to member "${key}" disallowed.`);
+  }
+  return [object, object == null ? void 0 : object[key]];
+}
+function evaluateExpression(node, context, options) {
+  const expression = node;
+  const mergedContext = mergeFunctionLibraries(context, options);
+  switch (expression.type) {
+    case "ArrayExpression":
+      return evaluateArray(expression.elements, mergedContext);
+    case "BinaryExpression":
+      if (expression.operator === "||") {
+        return evaluate(expression.left, mergedContext) || evaluate(expression.right, mergedContext);
+      }
+      if (expression.operator === "&&") {
+        return evaluate(expression.left, mergedContext) && evaluate(expression.right, mergedContext);
+      }
+      return binops[expression.operator](evaluate(expression.left, mergedContext), evaluate(expression.right, mergedContext));
+    case "CallExpression": {
+      let caller;
+      let fn;
+      if (expression.callee.type === "MemberExpression") {
+        const member = evaluateMember(expression.callee, mergedContext);
+        caller = member[0];
+        fn = member[1];
+      } else {
+        fn = evaluate(expression.callee, mergedContext);
+      }
+      if (typeof fn !== "function") {
+        return void 0;
+      }
+      return fn.apply(caller, evaluateArray(expression.arguments, mergedContext));
+    }
+    case "ConditionalExpression":
+      return evaluate(expression.test, mergedContext) ? evaluate(expression.consequent, mergedContext) : evaluate(expression.alternate, mergedContext);
+    case "Identifier":
+      return mergedContext[expression.name];
+    case "Literal":
+      return expression.value;
+    case "MemberExpression":
+      return evaluateMember(expression, mergedContext)[1];
+    case "ThisExpression":
+      return mergedContext;
+    case "UnaryExpression":
+      return unops[expression.operator](evaluate(expression.argument, mergedContext));
+    default:
+      return void 0;
+  }
+}
+function evaluate(node, context) {
+  return evaluateExpression(node, context);
+}
+async function evalAsync(node, context, options) {
+  const expression = node;
+  const mergedContext = mergeFunctionLibraries(context, options);
+  switch (expression.type) {
+    case "ArrayExpression":
+      return await evaluateArrayAsync(expression.elements, mergedContext);
+    case "BinaryExpression":
+      if (expression.operator === "||") {
+        return await evalAsync(expression.left, mergedContext) || await evalAsync(expression.right, mergedContext);
+      }
+      if (expression.operator === "&&") {
+        return await evalAsync(expression.left, mergedContext) && await evalAsync(expression.right, mergedContext);
+      }
+      return binops[expression.operator](await evalAsync(expression.left, mergedContext), await evalAsync(expression.right, mergedContext));
+    case "CallExpression": {
+      let caller;
+      let fn;
+      if (expression.callee.type === "MemberExpression") {
+        const member = await evaluateMemberAsync(expression.callee, mergedContext);
+        caller = member[0];
+        fn = member[1];
+      } else {
+        fn = await evalAsync(expression.callee, mergedContext);
+      }
+      if (typeof fn !== "function") {
+        return void 0;
+      }
+      return await fn.apply(caller, await evaluateArrayAsync(expression.arguments, mergedContext));
+    }
+    case "ConditionalExpression":
+      return await evalAsync(expression.test, mergedContext) ? await evalAsync(expression.consequent, mergedContext) : await evalAsync(expression.alternate, mergedContext);
+    case "Identifier":
+      return mergedContext[expression.name];
+    case "Literal":
+      return expression.value;
+    case "MemberExpression":
+      return (await evaluateMemberAsync(expression, mergedContext))[1];
+    case "ThisExpression":
+      return mergedContext;
+    case "UnaryExpression":
+      return unops[expression.operator](await evalAsync(expression.argument, mergedContext));
+    default:
+      return void 0;
+  }
+}
+function compile(expression, options) {
+  const ast = parse(expression);
+  return (context) => evaluateExpression(ast, context, options);
+}
+function compileAsync(expression, options) {
+  const ast = parse(expression);
+  return (context) => evalAsync(ast, context, options);
+}
+function addUnaryOp(operator, fn) {
+  jsep2.addUnaryOp(operator);
+  unops[operator] = fn;
+}
+function addBinaryOp(operator, precedenceOrFn, fn) {
+  if (fn) {
+    jsep2.addBinaryOp(operator, precedenceOrFn);
+    binops[operator] = fn;
+    return;
+  }
+  jsep2.addBinaryOp(operator, DEFAULT_PRECEDENCE[operator] || 1);
+  binops[operator] = precedenceOrFn;
+}
+function parse(expression) {
+  return typeof expression === "string" ? jsep2(expression) : expression;
+}
+
+// dist/expressions/get.js
+function get(container, compositeKey) {
+  let value = container;
+  for (const key of getKeys(compositeKey)) {
+    value = isObject(value) ? value[key] : void 0;
+  }
+  return value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+var keyMap = {};
+function getKeys(compositeKey) {
+  let keyList = keyMap[compositeKey];
+  if (!keyList) {
+    keyList = compositeKey.split(".");
+    keyMap[compositeKey] = keyList;
+  }
+  return keyList;
+}
+
+// dist/expressions/parse-expression-string.js
+var cachedExpressionMap = {
+  "-": (object) => object
+};
+function parseExpressionString(propValue) {
+  if (propValue in cachedExpressionMap) {
+    return cachedExpressionMap[propValue];
+  }
+  const ast = parse(propValue);
+  const func = ast.type === "Identifier" ? (row) => get(row, propValue) : compileAst(ast);
+  cachedExpressionMap[propValue] = func;
+  return func;
+}
+function compileAst(ast) {
+  traverse(ast, (node) => {
+    if (node.type === "CallExpression") {
+      throw new Error("Function calls not allowed in expression accessors");
+    }
+  });
+  return (row) => evaluateExpression(ast, row);
+}
+function traverse(node, visitor) {
+  if (Array.isArray(node)) {
+    node.forEach((element) => traverse(element, visitor));
+    return;
+  }
+  if (node && typeof node === "object") {
+    if (isNodeLike(node)) {
+      visitor(node);
+    }
+    for (const key in node) {
+      traverse(node[key], visitor);
+    }
+  }
+}
+function isNodeLike(node) {
+  return "type" in node && typeof node.type === "string";
+}
+//# sourceMappingURL=index.cjs.map