@uipath/common 1.202.0-preview.142 → 1.202.0-preview.145

package/dist/index.js

@@ -3810,2006 +3810,1483 @@ var init_js_yaml = __esm(() => {
   } = yaml);
 });
 
-// ../../node_modules/@jmespath-community/jmespath/dist/index.mjs
-var exports_dist = {};
-__export(exports_dist, {
-  Scope: () => Scope,
-  TYPE_ANY: () => TYPE_ANY,
-  TYPE_ARRAY: () => TYPE_ARRAY,
-  TYPE_ARRAY_ARRAY: () => TYPE_ARRAY_ARRAY,
-  TYPE_ARRAY_NUMBER: () => TYPE_ARRAY_NUMBER,
-  TYPE_ARRAY_OBJECT: () => TYPE_ARRAY_OBJECT,
-  TYPE_ARRAY_STRING: () => TYPE_ARRAY_STRING,
-  TYPE_BOOLEAN: () => TYPE_BOOLEAN,
-  TYPE_EXPREF: () => TYPE_EXPREF,
-  TYPE_NULL: () => TYPE_NULL,
-  TYPE_NUMBER: () => TYPE_NUMBER,
-  TYPE_OBJECT: () => TYPE_OBJECT,
-  TYPE_STRING: () => TYPE_STRING,
-  TreeInterpreter: () => TreeInterpreter2,
-  clearCustomFunctions: () => clearCustomFunctions,
-  compile: () => compile,
-  default: () => jmespath,
-  getCustomFunctions: () => getCustomFunctions,
-  getRegisteredFunctions: () => getRegisteredFunctions,
-  isRegistered: () => isRegistered,
-  jmespath: () => jmespath,
-  register: () => register,
-  registerFunction: () => registerFunction,
-  search: () => search,
-  tokenize: () => tokenize,
-  unregisterFunction: () => unregisterFunction
-});
-function compile(expression, options) {
-  const nodeTree = Parser_default.parse(expression, options);
-  return nodeTree;
-}
-function tokenize(expression, options) {
-  return Lexer_default.tokenize(expression, options);
-}
-function search(data, expression, options) {
-  const nodeTree = Parser_default.parse(expression, options);
-  return TreeInterpreter_default.search(nodeTree, data);
-}
-function Scope() {
-  return new ScopeChain;
-}
-var isObject = (obj) => {
-  return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
-}, strictDeepEqual = (first, second) => {
-  if (first === second) {
-    return true;
-  }
-  if (typeof first !== typeof second) {
-    return false;
-  }
-  if (Array.isArray(first) && Array.isArray(second)) {
-    if (first.length !== second.length) {
-      return false;
-    }
-    for (let i = 0;i < first.length; i += 1) {
-      if (!strictDeepEqual(first[i], second[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (isObject(first) && isObject(second)) {
-    const firstEntries = Object.entries(first);
-    const secondKeys = new Set(Object.keys(second));
-    if (firstEntries.length !== secondKeys.size) {
-      return false;
-    }
-    for (const [key, value] of firstEntries) {
-      if (!strictDeepEqual(value, second[key])) {
+// ../../node_modules/jmespath/jmespath.js
+var require_jmespath = __commonJS(function(exports) {
+  (function(exports2) {
+    function isArray(obj) {
+      if (obj !== null) {
+        return Object.prototype.toString.call(obj) === "[object Array]";
+      } else {
         return false;
       }
-      secondKeys.delete(key);
     }
-    return secondKeys.size === 0;
-  }
-  return false;
-}, isFalse = (obj) => {
-  if (obj === null || obj === undefined || obj === false) {
-    return true;
-  }
-  if (typeof obj === "string") {
-    return obj === "";
-  }
-  if (typeof obj === "object") {
-    if (Array.isArray(obj)) {
-      return obj.length === 0;
-    }
-    if (obj === null) {
-      return true;
-    }
-    return Object.keys(obj).length === 0;
-  }
-  return false;
-}, isAlpha = (ch) => {
-  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
-}, isNum = (ch) => {
-  return ch >= "0" && ch <= "9" || ch === "-";
-}, isAlphaNum = (ch) => {
-  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
-}, ensureInteger = (value) => {
-  if (!(typeof value === "number") || Math.floor(value) !== value) {
-    throw new Error("invalid-value: expecting an integer.");
-  }
-  return value;
-}, ensurePositiveInteger = (value) => {
-  if (!(typeof value === "number") || value < 0 || Math.floor(value) !== value) {
-    throw new Error("invalid-value: expecting a non-negative integer.");
-  }
-  return value;
-}, ensureNumbers = (...operands) => {
-  for (let i = 0;i < operands.length; i++) {
-    if (operands[i] === null || operands[i] === undefined) {
-      throw new Error("not-a-number: undefined");
-    }
-    if (typeof operands[i] !== "number") {
-      throw new Error("not-a-number");
-    }
-  }
-}, notZero = (n) => {
-  n = +n;
-  if (!n) {
-    throw new Error("not-a-number: divide by zero");
-  }
-  return n;
-}, add = (left, right) => {
-  ensureNumbers(left, right);
-  const result = left + right;
-  return result;
-}, sub = (left, right) => {
-  ensureNumbers(left, right);
-  const result = left - right;
-  return result;
-}, mul = (left, right) => {
-  ensureNumbers(left, right);
-  const result = left * right;
-  return result;
-}, divide = (left, right) => {
-  ensureNumbers(left, right);
-  const result = left / notZero(right);
-  return result;
-}, div = (left, right) => {
-  ensureNumbers(left, right);
-  const result = Math.floor(left / notZero(right));
-  return result;
-}, mod = (left, right) => {
-  ensureNumbers(left, right);
-  const result = left % right;
-  return result;
-}, findFirst = (subject, sub2, start, end) => {
-  if (!subject || !sub2) {
-    return null;
-  }
-  start = Math.max(ensureInteger(start = start || 0), 0);
-  end = Math.min(ensureInteger(end = end || subject.length), subject.length);
-  const offset = subject.slice(start, end).indexOf(sub2);
-  return offset === -1 ? null : offset + start;
-}, findLast = (subject, sub2, start, end) => {
-  if (!subject || !sub2) {
-    return null;
-  }
-  start = Math.max(ensureInteger(start = start || 0), 0);
-  end = Math.min(ensureInteger(end = end || subject.length), subject.length);
-  const offset = subject.slice(start, end).lastIndexOf(sub2);
-  const result = offset === -1 ? null : offset + start;
-  return result;
-}, lower = (subject) => subject.toLowerCase(), ensurePadFuncParams = (name, width, padding) => {
-  padding = padding || " ";
-  if (padding.length > 1) {
-    throw new Error(`invalid value, ${name} expects its 'pad' parameter to be a valid string with a single codepoint`);
-  }
-  ensurePositiveInteger(width);
-  return padding;
-}, padLeft = (subject, width, padding) => {
-  padding = ensurePadFuncParams("pad_left", width, padding);
-  return subject && subject.padStart(width, padding) || "";
-}, padRight = (subject, width, padding) => {
-  padding = ensurePadFuncParams("pad_right", width, padding);
-  return subject && subject.padEnd(width, padding) || "";
-}, replace = (subject, string, by, count) => {
-  if (count === 0) {
-    return subject;
-  }
-  if (!count) {
-    return subject.split(string).join(by);
-  }
-  ensurePositiveInteger(count);
-  [...Array(count).keys()].map(() => subject = subject.replace(string, by));
-  return subject;
-}, split = (subject, search2, count) => {
-  if (subject.length == 0 && search2.length === 0) {
-    return [];
-  }
-  if (count === null || count === undefined) {
-    return subject.split(search2);
-  }
-  ensurePositiveInteger(count);
-  if (count === 0) {
-    return [subject];
-  }
-  const split2 = subject.split(search2);
-  return [...split2.slice(0, count), split2.slice(count).join(search2)];
-}, trim = (subject, chars) => {
-  return trimLeft(trimRight(subject, chars), chars);
-}, trimLeft = (subject, chars) => {
-  return trimImpl(subject, (list) => new RegExp(`^[${list}]*(.*?)`), chars);
-}, trimRight = (subject, chars) => {
-  return trimImpl(subject, (list) => new RegExp(`(.*?)[${list}]*$`), chars);
-}, trimImpl = (subject, regExper, chars) => {
-  const pattern = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : "\\s…";
-  return subject.replace(regExper(pattern), "$1");
-}, upper = (subject) => subject.toUpperCase(), basicTokens, operatorStartToken, skipChars, StreamLexer = class {
-  _current = 0;
-  _enable_legacy_literals = false;
-  tokenize(stream, options) {
-    const tokens = [];
-    this._current = 0;
-    this._enable_legacy_literals = options?.enable_legacy_literals || false;
-    let start;
-    let identifier;
-    let token;
-    while (this._current < stream.length) {
-      if (isAlpha(stream[this._current])) {
-        start = this._current;
-        identifier = this.consumeUnquotedIdentifier(stream);
-        tokens.push({
-          start,
-          type: "UnquotedIdentifier",
-          value: identifier
-        });
-      } else if (basicTokens[stream[this._current]] !== undefined) {
-        tokens.push({
-          start: this._current,
-          type: basicTokens[stream[this._current]],
-          value: stream[this._current]
-        });
-        this._current += 1;
-      } else if (stream[this._current] === "$") {
-        start = this._current;
-        if (this._current + 1 < stream.length && isAlpha(stream[this._current + 1])) {
-          this._current += 1;
-          identifier = this.consumeUnquotedIdentifier(stream);
-          tokens.push({
-            start,
-            type: "Variable",
-            value: identifier
-          });
-        } else {
-          tokens.push({
-            start,
-            type: "Root",
-            value: stream[this._current]
-          });
-          this._current += 1;
-        }
-      } else if (stream[this._current] === "-") {
-        if (this._current + 1 < stream.length && isNum(stream[this._current + 1])) {
-          const token2 = this.consumeNumber(stream);
-          token2 && tokens.push(token2);
-        } else {
-          const token2 = {
-            start: this._current,
-            type: "Minus",
-            value: "-"
-          };
-          tokens.push(token2);
-          this._current += 1;
-        }
-      } else if (isNum(stream[this._current])) {
-        token = this.consumeNumber(stream);
-        tokens.push(token);
-      } else if (stream[this._current] === "[") {
-        token = this.consumeLBracket(stream);
-        tokens.push(token);
-      } else if (stream[this._current] === '"') {
-        start = this._current;
-        identifier = this.consumeQuotedIdentifier(stream);
-        tokens.push({
-          start,
-          type: "QuotedIdentifier",
-          value: identifier
-        });
-      } else if (stream[this._current] === `'`) {
-        start = this._current;
-        identifier = this.consumeRawStringLiteral(stream);
-        tokens.push({
-          start,
-          type: "Literal",
-          value: identifier
-        });
-      } else if (stream[this._current] === "`") {
-        start = this._current;
-        const literal = this.consumeLiteral(stream);
-        tokens.push({
-          start,
-          type: "Literal",
-          value: literal
-        });
-      } else if (operatorStartToken[stream[this._current]] !== undefined) {
-        token = this.consumeOperator(stream);
-        token && tokens.push(token);
-      } else if (skipChars[stream[this._current]] !== undefined) {
-        this._current += 1;
+    function isObject(obj) {
+      if (obj !== null) {
+        return Object.prototype.toString.call(obj) === "[object Object]";
       } else {
-        const error = new Error(`Syntax error: unknown character: ${stream[this._current]}`);
-        error.name = "LexerError";
-        throw error;
+        return false;
       }
     }
-    return tokens;
-  }
-  consumeUnquotedIdentifier(stream) {
-    const start = this._current;
-    this._current += 1;
-    while (this._current < stream.length && isAlphaNum(stream[this._current])) {
-      this._current += 1;
-    }
-    return stream.slice(start, this._current);
-  }
-  consumeQuotedIdentifier(stream) {
-    const start = this._current;
-    this._current += 1;
-    const maxLength = stream.length;
-    while (stream[this._current] !== '"' && this._current < maxLength) {
-      let current = this._current;
-      if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === '"')) {
-        current += 2;
-      } else {
-        current += 1;
+    function strictDeepEqual(first, second) {
+      if (first === second) {
+        return true;
       }
-      this._current = current;
-    }
-    this._current += 1;
-    const [value, ok] = this.parseJSON(stream.slice(start, this._current));
-    if (!ok) {
-      const error = new Error(`syntax: unexpected end of JSON input`);
-      error.name = "LexerError";
-      throw error;
-    }
-    return value;
-  }
-  consumeRawStringLiteral(stream) {
-    const start = this._current;
-    this._current += 1;
-    const maxLength = stream.length;
-    while (stream[this._current] !== `'` && this._current < maxLength) {
-      let current = this._current;
-      if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === `'`)) {
-        current += 2;
-      } else {
-        current += 1;
-      }
-      this._current = current;
-    }
-    this._current += 1;
-    const literal = stream.slice(start + 1, this._current - 1);
-    return replace(replace(literal, `\\\\`, `\\`), `\\'`, `'`);
-  }
-  consumeNumber(stream) {
-    const start = this._current;
-    this._current += 1;
-    const maxLength = stream.length;
-    while (isNum(stream[this._current]) && this._current < maxLength) {
-      this._current += 1;
-    }
-    const value = parseInt(stream.slice(start, this._current), 10);
-    return { start, value, type: "Number" };
-  }
-  consumeLBracket(stream) {
-    const start = this._current;
-    this._current += 1;
-    if (stream[this._current] === "?") {
-      this._current += 1;
-      return { start, type: "Filter", value: "[?" };
-    }
-    if (stream[this._current] === "]") {
-      this._current += 1;
-      return { start, type: "Flatten", value: "[]" };
-    }
-    return { start, type: "Lbracket", value: "[" };
-  }
-  consumeOrElse(stream, peek, token, orElse) {
-    const start = this._current;
-    this._current += 1;
-    if (this._current < stream.length && stream[this._current] === peek) {
-      this._current += 1;
-      return {
-        start,
-        type: orElse,
-        value: stream.slice(start, this._current)
-      };
-    }
-    return { start, type: token, value: stream[start] };
-  }
-  consumeOperator(stream) {
-    const start = this._current;
-    const startingChar = stream[start];
-    switch (startingChar) {
-      case "!":
-        return this.consumeOrElse(stream, "=", "Not", "NE");
-      case "<":
-        return this.consumeOrElse(stream, "=", "LT", "LTE");
-      case ">":
-        return this.consumeOrElse(stream, "=", "GT", "GTE");
-      case "=":
-        return this.consumeOrElse(stream, "=", "Assign", "EQ");
-      case "&":
-        return this.consumeOrElse(stream, "&", "Expref", "And");
-      case "|":
-        return this.consumeOrElse(stream, "|", "Pipe", "Or");
-      case "/":
-        return this.consumeOrElse(stream, "/", "Divide", "Div");
-    }
-  }
-  consumeLiteral(stream) {
-    this._current += 1;
-    const start = this._current;
-    const maxLength = stream.length;
-    while (stream[this._current] !== "`" && this._current < maxLength) {
-      let current = this._current;
-      if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "`")) {
-        current += 2;
-      } else {
-        current += 1;
+      var firstType = Object.prototype.toString.call(first);
+      if (firstType !== Object.prototype.toString.call(second)) {
+        return false;
       }
-      this._current = current;
-    }
-    let literalString = stream.slice(start, this._current).trimStart();
-    literalString = literalString.replace("\\`", "`");
-    let literal = null;
-    let ok = false;
-    if (this.looksLikeJSON(literalString)) {
-      [literal, ok] = this.parseJSON(literalString);
-    }
-    if (!ok && this._enable_legacy_literals) {
-      [literal, ok] = this.parseJSON(`"${literalString}"`);
-    }
-    if (!ok) {
-      const error = new Error(`Syntax error: unexpected end of JSON input or invalid format for a JSON literal: ${stream[this._current]}`);
-      error.name = "LexerError";
-      throw error;
-    }
-    this._current += 1;
-    return literal;
-  }
-  looksLikeJSON(literalString) {
-    const startingChars = '[{"';
-    const jsonLiterals = ["true", "false", "null"];
-    const numberLooking = "-0123456789";
-    if (literalString === "") {
-      return false;
-    }
-    if (startingChars.includes(literalString[0])) {
-      return true;
-    }
-    if (jsonLiterals.includes(literalString)) {
-      return true;
-    }
-    if (numberLooking.includes(literalString[0])) {
-      const [_, ok] = this.parseJSON(literalString);
-      return ok;
-    }
-    return false;
-  }
-  parseJSON(text) {
-    try {
-      const json2 = JSON.parse(text);
-      return [json2, true];
-    } catch {
-      return [null, false];
-    }
-  }
-}, Lexer, Lexer_default, bindingPower, TokenParser = class _TokenParser {
-  index = 0;
-  tokens = [];
-  parse(expression, options) {
-    this.loadTokens(expression, options || { enable_legacy_literals: false });
-    this.index = 0;
-    const ast = this.expression(0);
-    if (this.lookahead(0) !== "EOF") {
-      const token = this.lookaheadToken(0);
-      this.errorToken(token, `Syntax error: unexpected token type: ${token.type}, value: ${token.value}`);
-    }
-    return ast;
-  }
-  loadTokens(expression, options) {
-    this.tokens = Lexer_default.tokenize(expression, options);
-    this.tokens.push({ type: "EOF", value: "", start: expression.length });
-  }
-  expression(rbp) {
-    const leftToken = this.lookaheadToken(0);
-    this.advance();
-    let left = this.nud(leftToken);
-    let currentTokenType = this.lookahead(0);
-    while (rbp < bindingPower[currentTokenType]) {
-      this.advance();
-      left = this.led(currentTokenType, left);
-      currentTokenType = this.lookahead(0);
-    }
-    return left;
-  }
-  lookahead(offset) {
-    return this.tokens[this.index + offset].type;
-  }
-  lookaheadToken(offset) {
-    return this.tokens[this.index + offset];
-  }
-  advance() {
-    this.index += 1;
-  }
-  nud(token) {
-    switch (token.type) {
-      case "Variable":
-        return { type: "Variable", name: token.value };
-      case "Literal":
-        return { type: "Literal", value: token.value };
-      case "UnquotedIdentifier": {
-        if (_TokenParser.isKeyword(token, "let") && this.lookahead(0) === "Variable") {
-          return this.parseLetExpression();
-        } else {
-          return { type: "Field", name: token.value };
+      if (isArray(first) === true) {
+        if (first.length !== second.length) {
+          return false;
         }
-      }
-      case "QuotedIdentifier":
-        if (this.lookahead(0) === "Lparen") {
-          throw new Error("Syntax error: quoted identifier not allowed for function names.");
-        } else {
-          return { type: "Field", name: token.value };
+        for (var i = 0;i < first.length; i++) {
+          if (strictDeepEqual(first[i], second[i]) === false) {
+            return false;
+          }
         }
-      case "Not": {
-        const child = this.expression(bindingPower.Not);
-        return { type: "NotExpression", child };
-      }
-      case "Minus": {
-        const child = this.expression(bindingPower.Minus);
-        return {
-          type: "Unary",
-          operator: token.type,
-          operand: child
-        };
-      }
-      case "Plus": {
-        const child = this.expression(bindingPower.Plus);
-        return {
-          type: "Unary",
-          operator: token.type,
-          operand: child
-        };
+        return true;
       }
-      case "Star": {
-        const left = { type: "Identity" };
-        return { type: "ValueProjection", left, right: this.parseProjectionRHS(bindingPower.Star) };
-      }
-      case "Filter":
-        return this.led(token.type, { type: "Identity" });
-      case "Lbrace":
-        return this.parseMultiselectHash();
-      case "Flatten": {
-        const left = {
-          type: "Flatten",
-          child: { type: "Identity" }
-        };
-        const right = this.parseProjectionRHS(bindingPower.Flatten);
-        return { type: "Projection", left, right };
-      }
-      case "Lbracket": {
-        if (this.lookahead(0) === "Number" || this.lookahead(0) === "Colon") {
-          const right = this.parseIndexExpression();
-          return this.projectIfSlice({ type: "Identity" }, right);
-        }
-        if (this.lookahead(0) === "Star" && this.lookahead(1) === "Rbracket") {
-          this.advance();
-          this.advance();
-          const right = this.parseProjectionRHS(bindingPower.Star);
-          return {
-            left: { type: "Identity" },
-            right,
-            type: "Projection"
-          };
+      if (isObject(first) === true) {
+        var keysSeen = {};
+        for (var key in first) {
+          if (hasOwnProperty.call(first, key)) {
+            if (strictDeepEqual(first[key], second[key]) === false) {
+              return false;
+            }
+            keysSeen[key] = true;
+          }
         }
-        return this.parseMultiselectList();
-      }
-      case "Current":
-        return { type: "Current" };
-      case "Root":
-        return { type: "Root" };
-      case "Expref": {
-        const child = this.expression(bindingPower.Expref);
-        return { type: "ExpressionReference", child };
+        for (var key2 in second) {
+          if (hasOwnProperty.call(second, key2)) {
+            if (keysSeen[key2] !== true) {
+              return false;
+            }
+          }
+        }
+        return true;
       }
-      case "Lparen": {
-        const expression = this.expression(0);
-        this.match("Rparen");
-        return expression;
+      return false;
+    }
+    function isFalse(obj) {
+      if (obj === "" || obj === false || obj === null) {
+        return true;
+      } else if (isArray(obj) && obj.length === 0) {
+        return true;
+      } else if (isObject(obj)) {
+        for (var key in obj) {
+          if (obj.hasOwnProperty(key)) {
+            return false;
+          }
+        }
+        return true;
+      } else {
+        return false;
       }
-      default:
-        this.errorToken(token);
     }
-  }
-  led(tokenName, left) {
-    switch (tokenName) {
-      case "Question": {
-        const trueExpr = this.expression(0);
-        this.match("Colon");
-        const falseExpr = this.expression(0);
-        return {
-          type: "Ternary",
-          condition: left,
-          trueExpr,
-          falseExpr
-        };
+    function objValues(obj) {
+      var keys = Object.keys(obj);
+      var values = [];
+      for (var i = 0;i < keys.length; i++) {
+        values.push(obj[keys[i]]);
       }
-      case "Dot": {
-        const rbp = bindingPower.Dot;
-        if (this.lookahead(0) !== "Star") {
-          const right2 = this.parseDotRHS(rbp);
-          return { type: "Subexpression", left, right: right2 };
-        }
-        this.advance();
-        const right = this.parseProjectionRHS(rbp);
-        return { type: "ValueProjection", left, right };
-      }
-      case "Pipe": {
-        const right = this.expression(bindingPower.Pipe);
-        return { type: "Pipe", left, right };
-      }
-      case "Or": {
-        const right = this.expression(bindingPower.Or);
-        return { type: "OrExpression", left, right };
-      }
-      case "And": {
-        const right = this.expression(bindingPower.And);
-        return { type: "AndExpression", left, right };
-      }
-      case "Lparen": {
-        if (left.type !== "Field") {
-          throw new Error("Syntax error: expected a Field node");
-        }
-        const name = left.name;
-        const args = this.parseCommaSeparatedExpressionsUntilToken("Rparen");
-        const node = { name, type: "Function", children: args };
-        return node;
-      }
-      case "Filter": {
-        const condition = this.expression(0);
-        this.match("Rbracket");
-        const right = this.lookahead(0) === "Flatten" ? { type: "Identity" } : this.parseProjectionRHS(bindingPower.Filter);
-        return { type: "FilterProjection", left, right, condition };
-      }
-      case "Flatten": {
-        const leftNode = { type: "Flatten", child: left };
-        const right = this.parseProjectionRHS(bindingPower.Flatten);
-        return { type: "Projection", left: leftNode, right };
-      }
-      case "Assign": {
-        const leftNode = left;
-        const right = this.expression(0);
-        return {
-          type: "Binding",
-          variable: leftNode.name,
-          reference: right
-        };
+      return values;
+    }
+    function merge2(a, b) {
+      var merged = {};
+      for (var key in a) {
+        merged[key] = a[key];
       }
-      case "EQ":
-      case "NE":
-      case "GT":
-      case "GTE":
-      case "LT":
-      case "LTE":
-        return this.parseComparator(left, tokenName);
-      case "Plus":
-      case "Minus":
-      case "Multiply":
-      case "Star":
-      case "Divide":
-      case "Modulo":
-      case "Div":
-        return this.parseArithmetic(left, tokenName);
-      case "Lbracket": {
-        const token = this.lookaheadToken(0);
-        if (token.type === "Number" || token.type === "Colon") {
-          const right2 = this.parseIndexExpression();
-          return this.projectIfSlice(left, right2);
-        }
-        this.match("Star");
-        this.match("Rbracket");
-        const right = this.parseProjectionRHS(bindingPower.Star);
-        return { type: "Projection", left, right };
+      for (var key2 in b) {
+        merged[key2] = b[key2];
       }
-      default:
-        return this.errorToken(this.lookaheadToken(0));
+      return merged;
     }
-  }
-  static isKeyword(token, keyword) {
-    return token.type === "UnquotedIdentifier" && token.value === keyword;
-  }
-  match(tokenType) {
-    if (this.lookahead(0) === tokenType) {
-      this.advance();
-      return;
+    var trimLeft;
+    if (typeof String.prototype.trimLeft === "function") {
+      trimLeft = function(str2) {
+        return str2.trimLeft();
+      };
     } else {
-      const token = this.lookaheadToken(0);
-      this.errorToken(token, `Syntax error: expected ${tokenType}, got: ${token.type}`);
-    }
-  }
-  errorToken(token, message = "") {
-    const error = new Error(message || `Syntax error: invalid token (${token.type}): "${token.value}"`);
-    error.name = "ParserError";
-    throw error;
-  }
-  parseIndexExpression() {
-    if (this.lookahead(0) === "Colon" || this.lookahead(1) === "Colon") {
-      return this.parseSliceExpression();
-    }
-    const value = Number(this.lookaheadToken(0).value);
-    this.advance();
-    this.match("Rbracket");
-    return { type: "Index", value };
-  }
-  projectIfSlice(left, right) {
-    const indexExpr = {
-      type: "IndexExpression",
-      left,
-      right
-    };
-    if (right.type === "Slice") {
-      return {
-        left: indexExpr,
-        right: this.parseProjectionRHS(bindingPower.Star),
-        type: "Projection"
+      trimLeft = function(str2) {
+        return str2.match(/^\s*(.*)/)[1];
       };
     }
-    return indexExpr;
-  }
-  parseSliceExpression() {
-    const parts = [null, null, null];
-    let index = 0;
-    let current = this.lookaheadToken(0);
-    while (current.type != "Rbracket" && index < 3) {
-      if (current.type === "Colon") {
-        index++;
-        if (index === 3) {
-          this.errorToken(this.lookaheadToken(0), "Syntax error, too many colons in slice expression");
-        }
-        this.advance();
-      } else if (current.type === "Number") {
-        const part = this.lookaheadToken(0).value;
-        parts[index] = part;
-        this.advance();
-      } else {
-        const next = this.lookaheadToken(0);
-        this.errorToken(next, `Syntax error, unexpected token: ${next.value}(${next.type})`);
-      }
-      current = this.lookaheadToken(0);
-    }
-    this.match("Rbracket");
-    const [start, stop, step] = parts;
-    return { type: "Slice", start, stop, step };
-  }
-  parseLetExpression() {
-    const separated = this.parseCommaSeparatedExpressionsUntilKeyword("in");
-    const expression = this.expression(0);
-    const bindings = separated.map((binding) => binding);
-    return {
-      type: "LetExpression",
-      bindings,
-      expression
+    var TYPE_NUMBER = 0;
+    var TYPE_ANY = 1;
+    var TYPE_STRING = 2;
+    var TYPE_ARRAY = 3;
+    var TYPE_OBJECT = 4;
+    var TYPE_BOOLEAN = 5;
+    var TYPE_EXPREF = 6;
+    var TYPE_NULL = 7;
+    var TYPE_ARRAY_NUMBER = 8;
+    var TYPE_ARRAY_STRING = 9;
+    var TYPE_NAME_TABLE = {
+      0: "number",
+      1: "any",
+      2: "string",
+      3: "array",
+      4: "object",
+      5: "boolean",
+      6: "expression",
+      7: "null",
+      8: "Array<number>",
+      9: "Array<string>"
     };
-  }
-  parseCommaSeparatedExpressionsUntilKeyword(keyword) {
-    return this.parseCommaSeparatedExpressionsUntil(() => {
-      return _TokenParser.isKeyword(this.lookaheadToken(0), keyword);
-    }, () => {
-      this.advance();
-    });
-  }
-  parseCommaSeparatedExpressionsUntilToken(token) {
-    return this.parseCommaSeparatedExpressionsUntil(() => {
-      return this.lookahead(0) === token;
-    }, () => {
-      return this.match(token);
-    });
-  }
-  parseCommaSeparatedExpressionsUntil(isEndToken, matchEndToken) {
-    const args = [];
-    let expression;
-    while (!isEndToken()) {
-      expression = this.expression(0);
-      if (this.lookahead(0) === "Comma") {
-        this.match("Comma");
-      }
-      args.push(expression);
-    }
-    matchEndToken();
-    return args;
-  }
-  parseComparator(left, comparator) {
-    const right = this.expression(bindingPower[comparator]);
-    return { type: "Comparator", name: comparator, left, right };
-  }
-  parseArithmetic(left, operator) {
-    const right = this.expression(bindingPower[operator]);
-    return { type: "Arithmetic", operator, left, right };
-  }
-  parseDotRHS(rbp) {
-    const lookahead = this.lookahead(0);
-    const exprTokens = ["UnquotedIdentifier", "QuotedIdentifier", "Star"];
-    if (exprTokens.includes(lookahead)) {
-      return this.expression(rbp);
-    }
-    if (lookahead === "Lbracket") {
-      this.match("Lbracket");
-      return this.parseMultiselectList();
-    }
-    if (lookahead === "Lbrace") {
-      this.match("Lbrace");
-      return this.parseMultiselectHash();
-    }
-    const token = this.lookaheadToken(0);
-    this.errorToken(token, `Syntax error, unexpected token: ${token.value}(${token.type})`);
-  }
-  parseProjectionRHS(rbp) {
-    if (bindingPower[this.lookahead(0)] < 10) {
-      return { type: "Identity" };
-    }
-    if (this.lookahead(0) === "Lbracket") {
-      return this.expression(rbp);
-    }
-    if (this.lookahead(0) === "Filter") {
-      return this.expression(rbp);
-    }
-    if (this.lookahead(0) === "Dot") {
-      this.match("Dot");
-      return this.parseDotRHS(rbp);
-    }
-    const token = this.lookaheadToken(0);
-    this.errorToken(token, `Syntax error, unexpected token: ${token.value}(${token.type})`);
-  }
-  parseMultiselectList() {
-    const expressions = [];
-    while (this.lookahead(0) !== "Rbracket") {
-      const expression = this.expression(0);
-      expressions.push(expression);
-      if (this.lookahead(0) === "Comma") {
-        this.match("Comma");
-        if (this.lookahead(0) === "Rbracket") {
-          throw new Error("Syntax error: unexpected token Rbracket");
-        }
-      }
-    }
-    this.match("Rbracket");
-    return { type: "MultiSelectList", children: expressions };
-  }
-  parseMultiselectHash() {
-    const pairs2 = [];
-    const identifierTypes = ["UnquotedIdentifier", "QuotedIdentifier"];
-    let keyToken;
-    let keyName;
-    let value;
-    for (;; ) {
-      keyToken = this.lookaheadToken(0);
-      if (!identifierTypes.includes(keyToken.type)) {
-        throw new Error(`Syntax error: expecting an identifier token, got: ${keyToken.type}`);
-      }
-      keyName = keyToken.value;
-      this.advance();
-      this.match("Colon");
-      value = this.expression(0);
-      pairs2.push({ value, type: "KeyValuePair", name: keyName });
-      if (this.lookahead(0) === "Comma") {
-        this.match("Comma");
-      } else if (this.lookahead(0) === "Rbrace") {
-        this.match("Rbrace");
-        break;
-      }
-    }
-    return { type: "MultiSelectHash", children: pairs2 };
-  }
-}, Parser, Parser_default, Text = class _Text {
-  _text;
-  constructor(text) {
-    this._text = text;
-  }
-  get string() {
-    return this._text;
-  }
-  get length() {
-    return this.codePoints.length;
-  }
-  compareTo(other) {
-    return _Text.compare(this, new _Text(other));
-  }
-  static get comparer() {
-    const stringComparer = (left, right) => {
-      return new _Text(left).compareTo(right);
+    var TOK_EOF = "EOF";
+    var TOK_UNQUOTEDIDENTIFIER = "UnquotedIdentifier";
+    var TOK_QUOTEDIDENTIFIER = "QuotedIdentifier";
+    var TOK_RBRACKET = "Rbracket";
+    var TOK_RPAREN = "Rparen";
+    var TOK_COMMA = "Comma";
+    var TOK_COLON = "Colon";
+    var TOK_RBRACE = "Rbrace";
+    var TOK_NUMBER = "Number";
+    var TOK_CURRENT = "Current";
+    var TOK_EXPREF = "Expref";
+    var TOK_PIPE = "Pipe";
+    var TOK_OR = "Or";
+    var TOK_AND = "And";
+    var TOK_EQ = "EQ";
+    var TOK_GT = "GT";
+    var TOK_LT = "LT";
+    var TOK_GTE = "GTE";
+    var TOK_LTE = "LTE";
+    var TOK_NE = "NE";
+    var TOK_FLATTEN = "Flatten";
+    var TOK_STAR = "Star";
+    var TOK_FILTER = "Filter";
+    var TOK_DOT = "Dot";
+    var TOK_NOT = "Not";
+    var TOK_LBRACE = "Lbrace";
+    var TOK_LBRACKET = "Lbracket";
+    var TOK_LPAREN = "Lparen";
+    var TOK_LITERAL = "Literal";
+    var basicTokens = {
+      ".": TOK_DOT,
+      "*": TOK_STAR,
+      ",": TOK_COMMA,
+      ":": TOK_COLON,
+      "{": TOK_LBRACE,
+      "}": TOK_RBRACE,
+      "]": TOK_RBRACKET,
+      "(": TOK_LPAREN,
+      ")": TOK_RPAREN,
+      "@": TOK_CURRENT
     };
-    return stringComparer;
-  }
-  static compare(left, right) {
-    const leftCp = left.codePoints;
-    const rightCp = right.codePoints;
-    for (let index = 0;index < Math.min(leftCp.length, rightCp.length); index++) {
-      if (leftCp[index] === rightCp[index]) {
-        continue;
-      }
-      return leftCp[index] - rightCp[index] > 0 ? 1 : -1;
-    }
-    return leftCp.length - rightCp.length > 0 ? 1 : -1;
-  }
-  reverse() {
-    return String.fromCodePoint(...this.codePoints.reverse());
-  }
-  get codePoints() {
-    const array = [...this._text].map((s) => s.codePointAt(0));
-    return array;
-  }
-}, createMathFunction = (mathFn) => ([value]) => mathFn(value), createStringFunction = (stringFn) => ([subject]) => stringFn(subject), createObjectFunction = (objFn) => ([obj]) => objFn(obj), Runtime = class {
-  _interpreter;
-  _functionTable;
-  _customFunctions = /* @__PURE__ */ new Set;
-  TYPE_NAME_TABLE = Object.freeze({
-    [0]: "number",
-    [1]: "any",
-    [2]: "string",
-    [3]: "array",
-    [4]: "object",
-    [5]: "boolean",
-    [6]: "expression",
-    [7]: "null",
-    [8]: "Array<number>",
-    [10]: "Array<object>",
-    [9]: "Array<string>",
-    [11]: "Array<Array<any>>"
-  });
-  constructor(interpreter) {
-    this._interpreter = interpreter;
-    this._functionTable = this.buildFunctionTable();
-  }
-  buildFunctionTable() {
-    return {
-      abs: { _func: createMathFunction(Math.abs), _signature: [{ types: [0] }] },
-      ceil: { _func: createMathFunction(Math.ceil), _signature: [{ types: [0] }] },
-      floor: { _func: createMathFunction(Math.floor), _signature: [{ types: [0] }] },
-      lower: { _func: createStringFunction(lower), _signature: [{ types: [2] }] },
-      upper: { _func: createStringFunction(upper), _signature: [{ types: [2] }] },
-      keys: { _func: createObjectFunction(Object.keys), _signature: [{ types: [4] }] },
-      values: { _func: createObjectFunction(Object.values), _signature: [{ types: [4] }] },
-      avg: { _func: this.functionAvg, _signature: [{ types: [8] }] },
-      contains: {
-        _func: this.functionContains,
-        _signature: [
-          { types: [2, 3] },
-          { types: [1] }
-        ]
-      },
-      ends_with: {
-        _func: this.functionEndsWith,
-        _signature: [{ types: [2] }, { types: [2] }]
-      },
-      find_first: {
-        _func: this.functionFindFirst,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true },
-          { types: [0], optional: true }
-        ]
-      },
-      find_last: {
-        _func: this.functionFindLast,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true },
-          { types: [0], optional: true }
-        ]
-      },
-      from_items: { _func: this.functionFromItems, _signature: [{ types: [11] }] },
-      group_by: {
-        _func: this.functionGroupBy,
-        _signature: [{ types: [3] }, { types: [6] }]
-      },
-      items: { _func: this.functionItems, _signature: [{ types: [4] }] },
-      join: {
-        _func: this.functionJoin,
-        _signature: [{ types: [2] }, { types: [9] }]
-      },
-      length: {
-        _func: this.functionLength,
-        _signature: [{ types: [2, 3, 4] }]
-      },
-      map: {
-        _func: this.functionMap,
-        _signature: [{ types: [6] }, { types: [3] }]
-      },
-      max: {
-        _func: this.functionMax,
-        _signature: [{ types: [8, 9] }]
-      },
-      max_by: {
-        _func: this.functionMaxBy,
-        _signature: [{ types: [3] }, { types: [6] }]
-      },
-      merge: { _func: this.functionMerge, _signature: [{ types: [4], variadic: true }] },
-      min: {
-        _func: this.functionMin,
-        _signature: [{ types: [8, 9] }]
-      },
-      min_by: {
-        _func: this.functionMinBy,
-        _signature: [{ types: [3] }, { types: [6] }]
-      },
-      not_null: { _func: this.functionNotNull, _signature: [{ types: [1], variadic: true }] },
-      pad_left: {
-        _func: this.functionPadLeft,
-        _signature: [
-          { types: [2] },
-          { types: [0] },
-          { types: [2], optional: true }
-        ]
-      },
-      pad_right: {
-        _func: this.functionPadRight,
-        _signature: [
-          { types: [2] },
-          { types: [0] },
-          { types: [2], optional: true }
-        ]
-      },
-      replace: {
-        _func: this.functionReplace,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true }
-        ]
-      },
-      reverse: {
-        _func: this.functionReverse,
-        _signature: [{ types: [2, 3] }]
+    var operatorStartToken = {
+      "<": true,
+      ">": true,
+      "=": true,
+      "!": true
+    };
+    var skipChars = {
+      " ": true,
+      "\t": true,
+      "\n": true
+    };
+    function isAlpha(ch) {
+      return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+    }
+    function isNum(ch) {
+      return ch >= "0" && ch <= "9" || ch === "-";
+    }
+    function isAlphaNum(ch) {
+      return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+    }
+    function Lexer() {}
+    Lexer.prototype = {
+      tokenize: function(stream) {
+        var tokens = [];
+        this._current = 0;
+        var start;
+        var identifier;
+        var token;
+        while (this._current < stream.length) {
+          if (isAlpha(stream[this._current])) {
+            start = this._current;
+            identifier = this._consumeUnquotedIdentifier(stream);
+            tokens.push({
+              type: TOK_UNQUOTEDIDENTIFIER,
+              value: identifier,
+              start
+            });
+          } else if (basicTokens[stream[this._current]] !== undefined) {
+            tokens.push({
+              type: basicTokens[stream[this._current]],
+              value: stream[this._current],
+              start: this._current
+            });
+            this._current++;
+          } else if (isNum(stream[this._current])) {
+            token = this._consumeNumber(stream);
+            tokens.push(token);
+          } else if (stream[this._current] === "[") {
+            token = this._consumeLBracket(stream);
+            tokens.push(token);
+          } else if (stream[this._current] === '"') {
+            start = this._current;
+            identifier = this._consumeQuotedIdentifier(stream);
+            tokens.push({
+              type: TOK_QUOTEDIDENTIFIER,
+              value: identifier,
+              start
+            });
+          } else if (stream[this._current] === "'") {
+            start = this._current;
+            identifier = this._consumeRawStringLiteral(stream);
+            tokens.push({
+              type: TOK_LITERAL,
+              value: identifier,
+              start
+            });
+          } else if (stream[this._current] === "`") {
+            start = this._current;
+            var literal = this._consumeLiteral(stream);
+            tokens.push({
+              type: TOK_LITERAL,
+              value: literal,
+              start
+            });
+          } else if (operatorStartToken[stream[this._current]] !== undefined) {
+            tokens.push(this._consumeOperator(stream));
+          } else if (skipChars[stream[this._current]] !== undefined) {
+            this._current++;
+          } else if (stream[this._current] === "&") {
+            start = this._current;
+            this._current++;
+            if (stream[this._current] === "&") {
+              this._current++;
+              tokens.push({ type: TOK_AND, value: "&&", start });
+            } else {
+              tokens.push({ type: TOK_EXPREF, value: "&", start });
+            }
+          } else if (stream[this._current] === "|") {
+            start = this._current;
+            this._current++;
+            if (stream[this._current] === "|") {
+              this._current++;
+              tokens.push({ type: TOK_OR, value: "||", start });
+            } else {
+              tokens.push({ type: TOK_PIPE, value: "|", start });
+            }
+          } else {
+            var error = new Error("Unknown character:" + stream[this._current]);
+            error.name = "LexerError";
+            throw error;
+          }
+        }
+        return tokens;
       },
-      sort: {
-        _func: this.functionSort,
-        _signature: [{ types: [9, 8] }]
+      _consumeUnquotedIdentifier: function(stream) {
+        var start = this._current;
+        this._current++;
+        while (this._current < stream.length && isAlphaNum(stream[this._current])) {
+          this._current++;
+        }
+        return stream.slice(start, this._current);
       },
-      sort_by: {
-        _func: this.functionSortBy,
-        _signature: [{ types: [3] }, { types: [6] }]
+      _consumeQuotedIdentifier: function(stream) {
+        var start = this._current;
+        this._current++;
+        var maxLength = stream.length;
+        while (stream[this._current] !== '"' && this._current < maxLength) {
+          var current = this._current;
+          if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === '"')) {
+            current += 2;
+          } else {
+            current++;
+          }
+          this._current = current;
+        }
+        this._current++;
+        return JSON.parse(stream.slice(start, this._current));
       },
-      split: {
-        _func: this.functionSplit,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true }
-        ]
+      _consumeRawStringLiteral: function(stream) {
+        var start = this._current;
+        this._current++;
+        var maxLength = stream.length;
+        while (stream[this._current] !== "'" && this._current < maxLength) {
+          var current = this._current;
+          if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "'")) {
+            current += 2;
+          } else {
+            current++;
+          }
+          this._current = current;
+        }
+        this._current++;
+        var literal = stream.slice(start + 1, this._current - 1);
+        return literal.replace("\\'", "'");
       },
-      starts_with: {
-        _func: this.functionStartsWith,
-        _signature: [{ types: [2] }, { types: [2] }]
+      _consumeNumber: function(stream) {
+        var start = this._current;
+        this._current++;
+        var maxLength = stream.length;
+        while (isNum(stream[this._current]) && this._current < maxLength) {
+          this._current++;
+        }
+        var value = parseInt(stream.slice(start, this._current));
+        return { type: TOK_NUMBER, value, start };
       },
-      sum: { _func: this.functionSum, _signature: [{ types: [8] }] },
-      to_array: { _func: this.functionToArray, _signature: [{ types: [1] }] },
-      to_number: { _func: this.functionToNumber, _signature: [{ types: [1] }] },
-      to_string: { _func: this.functionToString, _signature: [{ types: [1] }] },
-      trim: {
-        _func: this.functionTrim,
-        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      _consumeLBracket: function(stream) {
+        var start = this._current;
+        this._current++;
+        if (stream[this._current] === "?") {
+          this._current++;
+          return { type: TOK_FILTER, value: "[?", start };
+        } else if (stream[this._current] === "]") {
+          this._current++;
+          return { type: TOK_FLATTEN, value: "[]", start };
+        } else {
+          return { type: TOK_LBRACKET, value: "[", start };
+        }
       },
-      trim_left: {
-        _func: this.functionTrimLeft,
-        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      _consumeOperator: function(stream) {
+        var start = this._current;
+        var startingChar = stream[start];
+        this._current++;
+        if (startingChar === "!") {
+          if (stream[this._current] === "=") {
+            this._current++;
+            return { type: TOK_NE, value: "!=", start };
+          } else {
+            return { type: TOK_NOT, value: "!", start };
+          }
+        } else if (startingChar === "<") {
+          if (stream[this._current] === "=") {
+            this._current++;
+            return { type: TOK_LTE, value: "<=", start };
+          } else {
+            return { type: TOK_LT, value: "<", start };
+          }
+        } else if (startingChar === ">") {
+          if (stream[this._current] === "=") {
+            this._current++;
+            return { type: TOK_GTE, value: ">=", start };
+          } else {
+            return { type: TOK_GT, value: ">", start };
+          }
+        } else if (startingChar === "=") {
+          if (stream[this._current] === "=") {
+            this._current++;
+            return { type: TOK_EQ, value: "==", start };
+          }
+        }
       },
-      trim_right: {
-        _func: this.functionTrimRight,
-        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      _consumeLiteral: function(stream) {
+        this._current++;
+        var start = this._current;
+        var maxLength = stream.length;
+        var literal;
+        while (stream[this._current] !== "`" && this._current < maxLength) {
+          var current = this._current;
+          if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "`")) {
+            current += 2;
+          } else {
+            current++;
+          }
+          this._current = current;
+        }
+        var literalString = trimLeft(stream.slice(start, this._current));
+        literalString = literalString.replace("\\`", "`");
+        if (this._looksLikeJSON(literalString)) {
+          literal = JSON.parse(literalString);
+        } else {
+          literal = JSON.parse('"' + literalString + '"');
+        }
+        this._current++;
+        return literal;
       },
-      type: { _func: this.functionType, _signature: [{ types: [1] }] },
-      zip: { _func: this.functionZip, _signature: [{ types: [3], variadic: true }] }
-    };
-  }
-  registerFunction(name, customFunction, signature, options) {
-    const result = this._registerInternal(name, customFunction, signature, options);
-    if (!result.success) {
-      throw new Error(result.message);
-    }
-  }
-  _registerInternal(name, customFunction, signature, options = {}) {
-    if (!name || typeof name !== "string" || name.trim() === "") {
-      return {
-        success: false,
-        reason: "invalid-name",
-        message: "Function name must be a non-empty string"
-      };
-    }
-    try {
-      this.validateInputSignatures(name, signature);
-    } catch (error) {
-      return {
-        success: false,
-        reason: "invalid-signature",
-        message: error instanceof Error ? error.message : "Invalid function signature"
-      };
-    }
-    const { override = false, warn = false } = options;
-    const exists = name in this._functionTable;
-    if (exists && !override) {
-      return {
-        success: false,
-        reason: "already-exists",
-        message: `Function already defined: ${name}(). Use { override: true } to replace it.`
-      };
-    }
-    if (exists && override && warn) {
-      console.warn(`Warning: Overriding existing function: ${name}()`);
-    }
-    this._functionTable[name] = {
-      _func: customFunction.bind(this),
-      _signature: signature
-    };
-    this._customFunctions.add(name);
-    const message = exists ? `Function ${name}() overridden successfully` : `Function ${name}() registered successfully`;
-    return { success: true, message };
-  }
-  register(name, customFunction, signature, options = {}) {
-    return this._registerInternal(name, customFunction, signature, options);
-  }
-  unregister(name) {
-    if (!this._customFunctions.has(name)) {
-      return false;
-    }
-    delete this._functionTable[name];
-    this._customFunctions.delete(name);
-    return true;
-  }
-  isRegistered(name) {
-    return name in this._functionTable;
-  }
-  getRegistered() {
-    return Object.keys(this._functionTable);
-  }
-  getCustomFunctions() {
-    return Array.from(this._customFunctions);
-  }
-  clearCustomFunctions() {
-    for (const name of this._customFunctions) {
-      delete this._functionTable[name];
-    }
-    this._customFunctions.clear();
-  }
-  callFunction(name, resolvedArgs) {
-    const functionEntry = this._functionTable[name];
-    if (functionEntry === undefined) {
-      throw new Error(`Unknown function: ${name}()`);
-    }
-    this.validateArgs(name, resolvedArgs, functionEntry._signature);
-    return functionEntry._func.call(this, resolvedArgs);
-  }
-  validateInputSignatures(name, signature) {
-    for (let i = 0;i < signature.length; i += 1) {
-      if ("variadic" in signature[i] && i !== signature.length - 1) {
-        throw new Error(`Invalid arity: ${name}() 'variadic' argument ${i + 1} must occur last`);
-      }
-    }
-  }
-  validateArgs(name, args, signature) {
-    this.validateInputSignatures(name, signature);
-    this.validateArity(name, args, signature);
-    this.validateTypes(name, args, signature);
-  }
-  validateArity(name, args, signature) {
-    const numberOfRequiredArgs = signature.filter((argSignature) => !(argSignature.optional ?? false)).length;
-    const lastArgIsVariadic = signature[signature.length - 1]?.variadic ?? false;
-    const tooFewArgs = args.length < numberOfRequiredArgs;
-    const tooManyArgs = args.length > signature.length;
-    if (lastArgIsVariadic && tooFewArgs || !lastArgIsVariadic && (tooFewArgs || tooManyArgs)) {
-      const tooFewModifier = tooFewArgs && (!lastArgIsVariadic && numberOfRequiredArgs > 1 || lastArgIsVariadic) ? "at least " : "";
-      const pluralized = signature.length > 1;
-      throw new Error(`Invalid arity: ${name}() takes ${tooFewModifier}${numberOfRequiredArgs} argument${pluralized && "s" || ""} but received ${args.length}`);
-    }
-  }
-  validateTypes(name, args, signature) {
-    for (let i = 0;i < signature.length; i += 1) {
-      const currentSpec = signature[i].types;
-      const actualType = this.getTypeName(args[i]);
-      if (actualType === undefined) {
-        continue;
-      }
-      const typeMatched = currentSpec.some((expectedType) => this.typeMatches(actualType, expectedType, args[i]));
-      if (!typeMatched) {
-        const expected = currentSpec.map((typeId) => this.TYPE_NAME_TABLE[typeId]).join(" | ");
-        throw new Error(`Invalid type: ${name}() expected argument ${i + 1} to be type (${expected}) but received type ${this.TYPE_NAME_TABLE[actualType]} instead.`);
-      }
-    }
-  }
-  typeMatches(actual, expected, argValue) {
-    if (expected === 1) {
-      return true;
-    }
-    if (expected === 9 || expected === 8 || expected === 10 || expected === 11 || expected === 3) {
-      if (expected === 3) {
-        return actual === 3;
-      }
-      if (actual === 3) {
-        let subtype;
-        if (expected === 8) {
-          subtype = 0;
-        } else if (expected === 10) {
-          subtype = 4;
-        } else if (expected === 9) {
-          subtype = 2;
-        } else if (expected === 11) {
-          subtype = 3;
-        }
-        const array = argValue;
-        for (let i = 0;i < array.length; i += 1) {
-          const typeName = this.getTypeName(array[i]);
-          if (typeName !== undefined && subtype !== undefined && !this.typeMatches(typeName, subtype, array[i])) {
+      _looksLikeJSON: function(literalString) {
+        var startingChars = '[{"';
+        var jsonLiterals = ["true", "false", "null"];
+        var numberLooking = "-0123456789";
+        if (literalString === "") {
+          return false;
+        } else if (startingChars.indexOf(literalString[0]) >= 0) {
+          return true;
+        } else if (jsonLiterals.indexOf(literalString) >= 0) {
+          return true;
+        } else if (numberLooking.indexOf(literalString[0]) >= 0) {
+          try {
+            JSON.parse(literalString);
+            return true;
+          } catch (ex) {
             return false;
           }
-        }
-        return true;
-      }
-    } else {
-      return actual === expected;
-    }
-    return false;
-  }
-  getTypeName(obj) {
-    if (obj === null) {
-      return 7;
-    }
-    if (typeof obj === "string") {
-      return 2;
-    }
-    if (typeof obj === "number") {
-      return 0;
-    }
-    if (typeof obj === "boolean") {
-      return 5;
-    }
-    if (Array.isArray(obj)) {
-      return 3;
-    }
-    if (typeof obj === "object") {
-      if (obj.expref) {
-        return 6;
-      }
-      return 4;
-    }
-    return;
-  }
-  createKeyFunction(exprefNode, allowedTypes) {
-    const interpreter = this._interpreter;
-    const keyFunc = (x) => {
-      const current = interpreter.visit(exprefNode, x);
-      if (!allowedTypes.includes(this.getTypeName(current))) {
-        const msg = `Invalid type: expected one of (${allowedTypes.map((t) => this.TYPE_NAME_TABLE[t]).join(" | ")}), received ${this.TYPE_NAME_TABLE[this.getTypeName(current)]}`;
-        throw new Error(msg);
-      }
-      return current;
-    };
-    return keyFunc;
-  }
-  functionAvg = ([inputArray]) => {
-    if (!inputArray || inputArray.length == 0) {
-      return null;
-    }
-    let sum = 0;
-    for (let i = 0;i < inputArray.length; i += 1) {
-      sum += inputArray[i];
-    }
-    return sum / inputArray.length;
-  };
-  functionContains = ([
-    searchable,
-    searchValue
-  ]) => {
-    if (Array.isArray(searchable)) {
-      const array = searchable;
-      return array.includes(searchValue);
-    }
-    if (typeof searchable === "string") {
-      const text = searchable;
-      if (typeof searchValue === "string") {
-        return text.includes(searchValue);
-      }
-    }
-    return null;
-  };
-  functionEndsWith = (resolvedArgs) => {
-    const [searchStr, suffix] = resolvedArgs;
-    return searchStr.includes(suffix, searchStr.length - suffix.length);
-  };
-  functionFindFirst = this.createFindFunction(findFirst);
-  functionFindLast = this.createFindFunction(findLast);
-  createFindFunction(findFn) {
-    return (resolvedArgs) => {
-      const subject = resolvedArgs[0];
-      const search2 = resolvedArgs[1];
-      const start = resolvedArgs.length > 2 ? resolvedArgs[2] : undefined;
-      const end = resolvedArgs.length > 3 ? resolvedArgs[3] : undefined;
-      return findFn(subject, search2, start, end);
-    };
-  }
-  functionFromItems = ([array]) => {
-    array.map((pair) => {
-      if (pair.length != 2 || typeof pair[0] !== "string") {
-        throw new Error("invalid value, each array must contain two elements, a pair of string and value");
-      }
-    });
-    return Object.fromEntries(array);
-  };
-  functionGroupBy = ([array, exprefNode]) => {
-    const keyFunction = this.createKeyFunction(exprefNode, [2]);
-    return array.reduce((acc, cur) => {
-      const k = keyFunction(cur ?? {});
-      const target = acc[k] = acc[k] || [];
-      target.push(cur);
-      return acc;
-    }, {});
-  };
-  functionItems = ([inputValue]) => {
-    return Object.entries(inputValue);
-  };
-  functionJoin = (resolvedArgs) => {
-    const [joinChar, listJoin] = resolvedArgs;
-    return listJoin.join(joinChar);
-  };
-  functionLength = ([inputValue]) => {
-    if (typeof inputValue === "string") {
-      return new Text(inputValue).length;
-    }
-    if (Array.isArray(inputValue)) {
-      return inputValue.length;
-    }
-    return Object.keys(inputValue).length;
-  };
-  functionMap = ([exprefNode, elements]) => {
-    if (!this._interpreter) {
-      return [];
-    }
-    const mapped = [];
-    const interpreter = this._interpreter;
-    for (let i = 0;i < elements.length; i += 1) {
-      mapped.push(interpreter.visit(exprefNode, elements[i]));
-    }
-    return mapped;
-  };
-  functionMax = ([inputValue]) => {
-    if (!inputValue.length) {
-      return null;
-    }
-    const typeName = this.getTypeName(inputValue[0]);
-    if (typeName === 0) {
-      return Math.max(...inputValue);
-    }
-    const elements = inputValue;
-    let maxElement = elements[0];
-    for (let i = 1;i < elements.length; i += 1) {
-      if (maxElement.localeCompare(elements[i]) < 0) {
-        maxElement = elements[i];
-      }
-    }
-    return maxElement;
-  };
-  functionMaxBy = (resolvedArgs) => {
-    const exprefNode = resolvedArgs[1];
-    const resolvedArray = resolvedArgs[0];
-    const keyFunction = this.createKeyFunction(exprefNode, [0, 2]);
-    let maxNumber = -Infinity;
-    let maxRecord;
-    let current;
-    for (let i = 0;i < resolvedArray.length; i += 1) {
-      current = keyFunction && keyFunction(resolvedArray[i]);
-      if (current !== undefined && current > maxNumber) {
-        maxNumber = current;
-        maxRecord = resolvedArray[i];
-      }
-    }
-    return maxRecord || null;
-  };
-  functionMerge = (resolvedArgs) => {
-    let merged = {};
-    for (let i = 0;i < resolvedArgs.length; i += 1) {
-      const current = resolvedArgs[i];
-      merged = Object.assign(merged, current);
-    }
-    return merged;
-  };
-  functionMin = ([inputValue]) => {
-    if (!inputValue.length) {
-      return null;
-    }
-    const typeName = this.getTypeName(inputValue[0]);
-    if (typeName === 0) {
-      return Math.min(...inputValue);
-    }
-    const elements = inputValue;
-    let minElement = elements[0];
-    for (let i = 1;i < elements.length; i += 1) {
-      if (elements[i].localeCompare(minElement) < 0) {
-        minElement = elements[i];
-      }
-    }
-    return minElement;
-  };
-  functionMinBy = (resolvedArgs) => {
-    const exprefNode = resolvedArgs[1];
-    const resolvedArray = resolvedArgs[0];
-    const keyFunction = this.createKeyFunction(exprefNode, [0, 2]);
-    let minNumber = Infinity;
-    let minRecord;
-    let current;
-    for (let i = 0;i < resolvedArray.length; i += 1) {
-      current = keyFunction && keyFunction(resolvedArray[i]);
-      if (current !== undefined && current < minNumber) {
-        minNumber = current;
-        minRecord = resolvedArray[i];
-      }
-    }
-    return minRecord || null;
-  };
-  functionNotNull = (resolvedArgs) => {
-    for (let i = 0;i < resolvedArgs.length; i += 1) {
-      if (this.getTypeName(resolvedArgs[i]) !== 7) {
-        return resolvedArgs[i];
-      }
-    }
-    return null;
-  };
-  functionPadLeft = this.createPadFunction(padLeft);
-  functionPadRight = this.createPadFunction(padRight);
-  createPadFunction(padFn) {
-    return (resolvedArgs) => {
-      const subject = resolvedArgs[0];
-      const width = resolvedArgs[1];
-      const padding = resolvedArgs.length > 2 ? resolvedArgs[2] : undefined;
-      return padFn(subject, width, padding);
-    };
-  }
-  functionReplace = (resolvedArgs) => {
-    const subject = resolvedArgs[0];
-    const string = resolvedArgs[1];
-    const by = resolvedArgs[2];
-    return replace(subject, string, by, resolvedArgs.length > 3 ? resolvedArgs[3] : undefined);
-  };
-  functionSplit = (resolvedArgs) => {
-    const subject = resolvedArgs[0];
-    const search2 = resolvedArgs[1];
-    return split(subject, search2, resolvedArgs.length > 2 ? resolvedArgs[2] : undefined);
-  };
-  functionReverse = ([inputValue]) => {
-    const typeName = this.getTypeName(inputValue);
-    if (typeName === 2) {
-      return new Text(inputValue).reverse();
-    }
-    const reversedArray = inputValue.slice(0);
-    reversedArray.reverse();
-    return reversedArray;
-  };
-  functionSort = ([inputValue]) => {
-    if (inputValue.length == 0) {
-      return inputValue;
-    }
-    if (typeof inputValue[0] === "string") {
-      return [...inputValue].sort(Text.comparer);
-    }
-    return [...inputValue].sort();
-  };
-  functionSortBy = (resolvedArgs) => {
-    const sortedArray = resolvedArgs[0].slice(0);
-    if (sortedArray.length === 0) {
-      return sortedArray;
-    }
-    const interpreter = this._interpreter;
-    const exprefNode = resolvedArgs[1];
-    const requiredType = this.getTypeName(interpreter.visit(exprefNode, sortedArray[0]));
-    if (requiredType !== undefined && ![0, 2].includes(requiredType)) {
-      throw new Error(`Invalid type: unexpected type (${this.TYPE_NAME_TABLE[requiredType]})`);
-    }
-    function throwInvalidTypeError(rt, item) {
-      throw new Error(`Invalid type: expected (${rt.TYPE_NAME_TABLE[requiredType]}), received ${rt.TYPE_NAME_TABLE[rt.getTypeName(item)]}`);
-    }
-    return sortedArray.sort((a, b) => {
-      const exprA = interpreter.visit(exprefNode, a);
-      const exprB = interpreter.visit(exprefNode, b);
-      if (this.getTypeName(exprA) !== requiredType) {
-        throwInvalidTypeError(this, exprA);
-      } else if (this.getTypeName(exprB) !== requiredType) {
-        throwInvalidTypeError(this, exprB);
-      }
-      if (requiredType === 2) {
-        return Text.comparer(exprA, exprB);
-      }
-      return exprA - exprB;
-    });
-  };
-  functionStartsWith = ([searchable, searchStr]) => {
-    return searchable.startsWith(searchStr);
-  };
-  functionSum = ([inputValue]) => {
-    return inputValue.reduce((x, y) => x + y, 0);
-  };
-  functionToArray = ([inputValue]) => {
-    if (this.getTypeName(inputValue) === 3) {
-      return inputValue;
-    }
-    return [inputValue];
-  };
-  functionToNumber = ([inputValue]) => {
-    const typeName = this.getTypeName(inputValue);
-    let convertedValue;
-    if (typeName === 0) {
-      return inputValue;
-    }
-    if (typeName === 2) {
-      convertedValue = +inputValue;
-      if (!isNaN(convertedValue)) {
-        return convertedValue;
+        } else {
+          return false;
+        }
       }
-    }
-    return null;
-  };
-  functionToString = ([inputValue]) => {
-    if (this.getTypeName(inputValue) === 2) {
-      return inputValue;
-    }
-    return JSON.stringify(inputValue);
-  };
-  functionTrim = this.createTrimFunction(trim);
-  functionTrimLeft = this.createTrimFunction(trimLeft);
-  functionTrimRight = this.createTrimFunction(trimRight);
-  createTrimFunction(trimFn) {
-    return (resolvedArgs) => {
-      const subject = resolvedArgs[0];
-      const chars = resolvedArgs.length > 1 ? resolvedArgs[1] : undefined;
-      return trimFn(subject, chars);
     };
-  }
-  functionType = ([inputValue]) => {
-    switch (this.getTypeName(inputValue)) {
-      case 0:
-        return "number";
-      case 2:
-        return "string";
-      case 3:
-        return "array";
-      case 4:
-        return "object";
-      case 5:
-        return "boolean";
-      case 7:
-        return "null";
-      default:
-        throw new Error("invalid-type");
-    }
-  };
-  functionZip = (array) => {
-    const length = Math.min(...array.map((arr) => arr.length));
-    const result = Array(length).fill(null).map((_, index) => array.map((arr) => arr[index]));
-    return result;
-  };
-}, ScopeChain = class _ScopeChain {
-  inner = undefined;
-  data = {};
-  get currentScopeData() {
-    return this.data;
-  }
-  withScope(data) {
-    const outer = new _ScopeChain;
-    outer.inner = this;
-    outer.data = data;
-    return outer;
-  }
-  getValue(identifier) {
-    if (Object.prototype.hasOwnProperty.call(this.data, identifier)) {
-      return this.data[identifier];
-    }
-    if (this.inner) {
-      return this.inner.getValue(identifier);
-    }
-    return null;
-  }
-}, emptyScopeChain, TreeInterpreter = class _TreeInterpreter {
-  runtime;
-  _rootValue = null;
-  _scope;
-  constructor() {
-    this.runtime = new Runtime(this);
-    this._scope = new ScopeChain;
-  }
-  withScope(scope) {
-    const interpreter = new _TreeInterpreter;
-    interpreter.runtime._functionTable = this.runtime._functionTable;
-    interpreter._rootValue = this._rootValue;
-    interpreter._scope = this._scope.withScope(scope);
-    return interpreter;
-  }
-  search(node, value) {
-    this._rootValue = value;
-    this._scope = emptyScopeChain;
-    return this.visit(node, value);
-  }
-  visit(node, value) {
-    switch (node.type) {
-      case "Ternary": {
-        const condition = this.visit(node.condition, value);
-        if (!isFalse(condition)) {
-          return this.visit(node.trueExpr, value);
-        }
-        return this.visit(node.falseExpr, value);
-      }
-      case "Field":
-        const identifier = node.name;
-        if (value === null || typeof value !== "object" || Array.isArray(value)) {
-          return null;
+    var bindingPower = {};
+    bindingPower[TOK_EOF] = 0;
+    bindingPower[TOK_UNQUOTEDIDENTIFIER] = 0;
+    bindingPower[TOK_QUOTEDIDENTIFIER] = 0;
+    bindingPower[TOK_RBRACKET] = 0;
+    bindingPower[TOK_RPAREN] = 0;
+    bindingPower[TOK_COMMA] = 0;
+    bindingPower[TOK_RBRACE] = 0;
+    bindingPower[TOK_NUMBER] = 0;
+    bindingPower[TOK_CURRENT] = 0;
+    bindingPower[TOK_EXPREF] = 0;
+    bindingPower[TOK_PIPE] = 1;
+    bindingPower[TOK_OR] = 2;
+    bindingPower[TOK_AND] = 3;
+    bindingPower[TOK_EQ] = 5;
+    bindingPower[TOK_GT] = 5;
+    bindingPower[TOK_LT] = 5;
+    bindingPower[TOK_GTE] = 5;
+    bindingPower[TOK_LTE] = 5;
+    bindingPower[TOK_NE] = 5;
+    bindingPower[TOK_FLATTEN] = 9;
+    bindingPower[TOK_STAR] = 20;
+    bindingPower[TOK_FILTER] = 21;
+    bindingPower[TOK_DOT] = 40;
+    bindingPower[TOK_NOT] = 45;
+    bindingPower[TOK_LBRACE] = 50;
+    bindingPower[TOK_LBRACKET] = 55;
+    bindingPower[TOK_LPAREN] = 60;
+    function Parser() {}
+    Parser.prototype = {
+      parse: function(expression) {
+        this._loadTokens(expression);
+        this.index = 0;
+        var ast = this.expression(0);
+        if (this._lookahead(0) !== TOK_EOF) {
+          var t = this._lookaheadToken(0);
+          var error = new Error("Unexpected token type: " + t.type + ", value: " + t.value);
+          error.name = "ParserError";
+          throw error;
+        }
+        return ast;
+      },
+      _loadTokens: function(expression) {
+        var lexer = new Lexer;
+        var tokens = lexer.tokenize(expression);
+        tokens.push({ type: TOK_EOF, value: "", start: expression.length });
+        this.tokens = tokens;
+      },
+      expression: function(rbp) {
+        var leftToken = this._lookaheadToken(0);
+        this._advance();
+        var left = this.nud(leftToken);
+        var currentToken = this._lookahead(0);
+        while (rbp < bindingPower[currentToken]) {
+          this._advance();
+          left = this.led(currentToken, left);
+          currentToken = this._lookahead(0);
+        }
+        return left;
+      },
+      _lookahead: function(number) {
+        return this.tokens[this.index + number].type;
+      },
+      _lookaheadToken: function(number) {
+        return this.tokens[this.index + number];
+      },
+      _advance: function() {
+        this.index++;
+      },
+      nud: function(token) {
+        var left;
+        var right;
+        var expression;
+        switch (token.type) {
+          case TOK_LITERAL:
+            return { type: "Literal", value: token.value };
+          case TOK_UNQUOTEDIDENTIFIER:
+            return { type: "Field", name: token.value };
+          case TOK_QUOTEDIDENTIFIER:
+            var node = { type: "Field", name: token.value };
+            if (this._lookahead(0) === TOK_LPAREN) {
+              throw new Error("Quoted identifier not allowed for function names.");
+            }
+            return node;
+          case TOK_NOT:
+            right = this.expression(bindingPower.Not);
+            return { type: "NotExpression", children: [right] };
+          case TOK_STAR:
+            left = { type: "Identity" };
+            right = null;
+            if (this._lookahead(0) === TOK_RBRACKET) {
+              right = { type: "Identity" };
+            } else {
+              right = this._parseProjectionRHS(bindingPower.Star);
+            }
+            return { type: "ValueProjection", children: [left, right] };
+          case TOK_FILTER:
+            return this.led(token.type, { type: "Identity" });
+          case TOK_LBRACE:
+            return this._parseMultiselectHash();
+          case TOK_FLATTEN:
+            left = { type: TOK_FLATTEN, children: [{ type: "Identity" }] };
+            right = this._parseProjectionRHS(bindingPower.Flatten);
+            return { type: "Projection", children: [left, right] };
+          case TOK_LBRACKET:
+            if (this._lookahead(0) === TOK_NUMBER || this._lookahead(0) === TOK_COLON) {
+              right = this._parseIndexExpression();
+              return this._projectIfSlice({ type: "Identity" }, right);
+            } else if (this._lookahead(0) === TOK_STAR && this._lookahead(1) === TOK_RBRACKET) {
+              this._advance();
+              this._advance();
+              right = this._parseProjectionRHS(bindingPower.Star);
+              return {
+                type: "Projection",
+                children: [{ type: "Identity" }, right]
+              };
+            }
+            return this._parseMultiselectList();
+          case TOK_CURRENT:
+            return { type: TOK_CURRENT };
+          case TOK_EXPREF:
+            expression = this.expression(bindingPower.Expref);
+            return { type: "ExpressionReference", children: [expression] };
+          case TOK_LPAREN:
+            var args = [];
+            while (this._lookahead(0) !== TOK_RPAREN) {
+              if (this._lookahead(0) === TOK_CURRENT) {
+                expression = { type: TOK_CURRENT };
+                this._advance();
+              } else {
+                expression = this.expression(0);
+              }
+              args.push(expression);
+            }
+            this._match(TOK_RPAREN);
+            return args[0];
+          default:
+            this._errorToken(token);
+        }
+      },
+      led: function(tokenName, left) {
+        var right;
+        switch (tokenName) {
+          case TOK_DOT:
+            var rbp = bindingPower.Dot;
+            if (this._lookahead(0) !== TOK_STAR) {
+              right = this._parseDotRHS(rbp);
+              return { type: "Subexpression", children: [left, right] };
+            }
+            this._advance();
+            right = this._parseProjectionRHS(rbp);
+            return { type: "ValueProjection", children: [left, right] };
+          case TOK_PIPE:
+            right = this.expression(bindingPower.Pipe);
+            return { type: TOK_PIPE, children: [left, right] };
+          case TOK_OR:
+            right = this.expression(bindingPower.Or);
+            return { type: "OrExpression", children: [left, right] };
+          case TOK_AND:
+            right = this.expression(bindingPower.And);
+            return { type: "AndExpression", children: [left, right] };
+          case TOK_LPAREN:
+            var name = left.name;
+            var args = [];
+            var expression, node;
+            while (this._lookahead(0) !== TOK_RPAREN) {
+              if (this._lookahead(0) === TOK_CURRENT) {
+                expression = { type: TOK_CURRENT };
+                this._advance();
+              } else {
+                expression = this.expression(0);
+              }
+              if (this._lookahead(0) === TOK_COMMA) {
+                this._match(TOK_COMMA);
+              }
+              args.push(expression);
+            }
+            this._match(TOK_RPAREN);
+            node = { type: "Function", name, children: args };
+            return node;
+          case TOK_FILTER:
+            var condition = this.expression(0);
+            this._match(TOK_RBRACKET);
+            if (this._lookahead(0) === TOK_FLATTEN) {
+              right = { type: "Identity" };
+            } else {
+              right = this._parseProjectionRHS(bindingPower.Filter);
+            }
+            return { type: "FilterProjection", children: [left, right, condition] };
+          case TOK_FLATTEN:
+            var leftNode = { type: TOK_FLATTEN, children: [left] };
+            var rightNode = this._parseProjectionRHS(bindingPower.Flatten);
+            return { type: "Projection", children: [leftNode, rightNode] };
+          case TOK_EQ:
+          case TOK_NE:
+          case TOK_GT:
+          case TOK_GTE:
+          case TOK_LT:
+          case TOK_LTE:
+            return this._parseComparator(left, tokenName);
+          case TOK_LBRACKET:
+            var token = this._lookaheadToken(0);
+            if (token.type === TOK_NUMBER || token.type === TOK_COLON) {
+              right = this._parseIndexExpression();
+              return this._projectIfSlice(left, right);
+            }
+            this._match(TOK_STAR);
+            this._match(TOK_RBRACKET);
+            right = this._parseProjectionRHS(bindingPower.Star);
+            return { type: "Projection", children: [left, right] };
+          default:
+            this._errorToken(this._lookaheadToken(0));
+        }
+      },
+      _match: function(tokenType) {
+        if (this._lookahead(0) === tokenType) {
+          this._advance();
+        } else {
+          var t = this._lookaheadToken(0);
+          var error = new Error("Expected " + tokenType + ", got: " + t.type);
+          error.name = "ParserError";
+          throw error;
         }
-        return value[identifier] ?? null;
-      case "LetExpression": {
-        const { bindings, expression } = node;
-        let scope = {};
-        bindings.forEach((binding) => {
-          const reference = this.visit(binding, value);
-          scope = {
-            ...scope,
-            ...reference
+      },
+      _errorToken: function(token) {
+        var error = new Error("Invalid token (" + token.type + '): "' + token.value + '"');
+        error.name = "ParserError";
+        throw error;
+      },
+      _parseIndexExpression: function() {
+        if (this._lookahead(0) === TOK_COLON || this._lookahead(1) === TOK_COLON) {
+          return this._parseSliceExpression();
+        } else {
+          var node = {
+            type: "Index",
+            value: this._lookaheadToken(0).value
           };
-        });
-        return this.withScope(scope).visit(expression, value);
-      }
-      case "Binding": {
-        const { variable, reference } = node;
-        const result = this.visit(reference, value);
-        return { [variable]: result };
-      }
-      case "Variable": {
-        const variable = node.name;
-        if (!this._scope.getValue(variable) && !Object.prototype.hasOwnProperty.call(this._scope.currentScopeData, variable)) {
-          throw new Error(`Error referencing undefined variable ${variable}`);
+          this._advance();
+          this._match(TOK_RBRACKET);
+          return node;
         }
-        return this._scope.getValue(variable);
-      }
-      case "IndexExpression":
-        return this.visit(node.right, this.visit(node.left, value));
-      case "Subexpression": {
-        const result = this.visit(node.left, value);
-        return result != null ? this.visit(node.right, result) ?? null : null;
-      }
-      case "Index": {
-        if (!Array.isArray(value)) {
-          return null;
+      },
+      _projectIfSlice: function(left, right) {
+        var indexExpr = { type: "IndexExpression", children: [left, right] };
+        if (right.type === "Slice") {
+          return {
+            type: "Projection",
+            children: [indexExpr, this._parseProjectionRHS(bindingPower.Star)]
+          };
+        } else {
+          return indexExpr;
         }
-        const index = node.value < 0 ? value.length + node.value : node.value;
-        return value[index] ?? null;
-      }
-      case "Slice": {
-        if (!Array.isArray(value) && typeof value !== "string") {
-          return null;
+      },
+      _parseSliceExpression: function() {
+        var parts = [null, null, null];
+        var index = 0;
+        var currentToken = this._lookahead(0);
+        while (currentToken !== TOK_RBRACKET && index < 3) {
+          if (currentToken === TOK_COLON) {
+            index++;
+            this._advance();
+          } else if (currentToken === TOK_NUMBER) {
+            parts[index] = this._lookaheadToken(0).value;
+            this._advance();
+          } else {
+            var t = this._lookahead(0);
+            var error = new Error("Syntax error, unexpected token: " + t.value + "(" + t.type + ")");
+            error.name = "Parsererror";
+            throw error;
+          }
+          currentToken = this._lookahead(0);
+        }
+        this._match(TOK_RBRACKET);
+        return {
+          type: "Slice",
+          children: parts
+        };
+      },
+      _parseComparator: function(left, comparator) {
+        var right = this.expression(bindingPower[comparator]);
+        return { type: "Comparator", name: comparator, children: [left, right] };
+      },
+      _parseDotRHS: function(rbp) {
+        var lookahead = this._lookahead(0);
+        var exprTokens = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER, TOK_STAR];
+        if (exprTokens.indexOf(lookahead) >= 0) {
+          return this.expression(rbp);
+        } else if (lookahead === TOK_LBRACKET) {
+          this._match(TOK_LBRACKET);
+          return this._parseMultiselectList();
+        } else if (lookahead === TOK_LBRACE) {
+          this._match(TOK_LBRACE);
+          return this._parseMultiselectHash();
         }
-        const { start, stop, step } = this.computeSliceParams(value.length, node);
-        if (typeof value === "string") {
-          const chars = [...value];
-          const sliced = this.slice(chars, start, stop, step);
-          return sliced.join("");
+      },
+      _parseProjectionRHS: function(rbp) {
+        var right;
+        if (bindingPower[this._lookahead(0)] < 10) {
+          right = { type: "Identity" };
+        } else if (this._lookahead(0) === TOK_LBRACKET) {
+          right = this.expression(rbp);
+        } else if (this._lookahead(0) === TOK_FILTER) {
+          right = this.expression(rbp);
+        } else if (this._lookahead(0) === TOK_DOT) {
+          this._match(TOK_DOT);
+          right = this._parseDotRHS(rbp);
         } else {
-          return this.slice(value, start, stop, step);
+          var t = this._lookaheadToken(0);
+          var error = new Error("Sytanx error, unexpected token: " + t.value + "(" + t.type + ")");
+          error.name = "ParserError";
+          throw error;
+        }
+        return right;
+      },
+      _parseMultiselectList: function() {
+        var expressions = [];
+        while (this._lookahead(0) !== TOK_RBRACKET) {
+          var expression = this.expression(0);
+          expressions.push(expression);
+          if (this._lookahead(0) === TOK_COMMA) {
+            this._match(TOK_COMMA);
+            if (this._lookahead(0) === TOK_RBRACKET) {
+              throw new Error("Unexpected token Rbracket");
+            }
+          }
+        }
+        this._match(TOK_RBRACKET);
+        return { type: "MultiSelectList", children: expressions };
+      },
+      _parseMultiselectHash: function() {
+        var pairs2 = [];
+        var identifierTypes = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER];
+        var keyToken, keyName, value, node;
+        for (;; ) {
+          keyToken = this._lookaheadToken(0);
+          if (identifierTypes.indexOf(keyToken.type) < 0) {
+            throw new Error("Expecting an identifier token, got: " + keyToken.type);
+          }
+          keyName = keyToken.value;
+          this._advance();
+          this._match(TOK_COLON);
+          value = this.expression(0);
+          node = { type: "KeyValuePair", name: keyName, value };
+          pairs2.push(node);
+          if (this._lookahead(0) === TOK_COMMA) {
+            this._match(TOK_COMMA);
+          } else if (this._lookahead(0) === TOK_RBRACE) {
+            this._match(TOK_RBRACE);
+            break;
+          }
         }
+        return { type: "MultiSelectHash", children: pairs2 };
       }
-      case "Projection": {
-        const { left, right } = node;
-        let allowString = false;
-        if (left.type === "IndexExpression" && left.right.type === "Slice") {
-          allowString = true;
+    };
+    function TreeInterpreter(runtime) {
+      this.runtime = runtime;
+    }
+    TreeInterpreter.prototype = {
+      search: function(node, value) {
+        return this.visit(node, value);
+      },
+      visit: function(node, value) {
+        var matched, current, result, first, second, field, left, right, collected, i;
+        switch (node.type) {
+          case "Field":
+            if (value !== null && isObject(value)) {
+              field = value[node.name];
+              if (field === undefined) {
+                return null;
+              } else {
+                return field;
+              }
+            }
+            return null;
+          case "Subexpression":
+            result = this.visit(node.children[0], value);
+            for (i = 1;i < node.children.length; i++) {
+              result = this.visit(node.children[1], result);
+              if (result === null) {
+                return null;
+              }
+            }
+            return result;
+          case "IndexExpression":
+            left = this.visit(node.children[0], value);
+            right = this.visit(node.children[1], left);
+            return right;
+          case "Index":
+            if (!isArray(value)) {
+              return null;
+            }
+            var index = node.value;
+            if (index < 0) {
+              index = value.length + index;
+            }
+            result = value[index];
+            if (result === undefined) {
+              result = null;
+            }
+            return result;
+          case "Slice":
+            if (!isArray(value)) {
+              return null;
+            }
+            var sliceParams = node.children.slice(0);
+            var computed = this.computeSliceParams(value.length, sliceParams);
+            var start = computed[0];
+            var stop = computed[1];
+            var step = computed[2];
+            result = [];
+            if (step > 0) {
+              for (i = start;i < stop; i += step) {
+                result.push(value[i]);
+              }
+            } else {
+              for (i = start;i > stop; i += step) {
+                result.push(value[i]);
+              }
+            }
+            return result;
+          case "Projection":
+            var base = this.visit(node.children[0], value);
+            if (!isArray(base)) {
+              return null;
+            }
+            collected = [];
+            for (i = 0;i < base.length; i++) {
+              current = this.visit(node.children[1], base[i]);
+              if (current !== null) {
+                collected.push(current);
+              }
+            }
+            return collected;
+          case "ValueProjection":
+            base = this.visit(node.children[0], value);
+            if (!isObject(base)) {
+              return null;
+            }
+            collected = [];
+            var values = objValues(base);
+            for (i = 0;i < values.length; i++) {
+              current = this.visit(node.children[1], values[i]);
+              if (current !== null) {
+                collected.push(current);
+              }
+            }
+            return collected;
+          case "FilterProjection":
+            base = this.visit(node.children[0], value);
+            if (!isArray(base)) {
+              return null;
+            }
+            var filtered = [];
+            var finalResults = [];
+            for (i = 0;i < base.length; i++) {
+              matched = this.visit(node.children[2], base[i]);
+              if (!isFalse(matched)) {
+                filtered.push(base[i]);
+              }
+            }
+            for (var j = 0;j < filtered.length; j++) {
+              current = this.visit(node.children[1], filtered[j]);
+              if (current !== null) {
+                finalResults.push(current);
+              }
+            }
+            return finalResults;
+          case "Comparator":
+            first = this.visit(node.children[0], value);
+            second = this.visit(node.children[1], value);
+            switch (node.name) {
+              case TOK_EQ:
+                result = strictDeepEqual(first, second);
+                break;
+              case TOK_NE:
+                result = !strictDeepEqual(first, second);
+                break;
+              case TOK_GT:
+                result = first > second;
+                break;
+              case TOK_GTE:
+                result = first >= second;
+                break;
+              case TOK_LT:
+                result = first < second;
+                break;
+              case TOK_LTE:
+                result = first <= second;
+                break;
+              default:
+                throw new Error("Unknown comparator: " + node.name);
+            }
+            return result;
+          case TOK_FLATTEN:
+            var original = this.visit(node.children[0], value);
+            if (!isArray(original)) {
+              return null;
+            }
+            var merged = [];
+            for (i = 0;i < original.length; i++) {
+              current = original[i];
+              if (isArray(current)) {
+                merged.push.apply(merged, current);
+              } else {
+                merged.push(current);
+              }
+            }
+            return merged;
+          case "Identity":
+            return value;
+          case "MultiSelectList":
+            if (value === null) {
+              return null;
+            }
+            collected = [];
+            for (i = 0;i < node.children.length; i++) {
+              collected.push(this.visit(node.children[i], value));
+            }
+            return collected;
+          case "MultiSelectHash":
+            if (value === null) {
+              return null;
+            }
+            collected = {};
+            var child;
+            for (i = 0;i < node.children.length; i++) {
+              child = node.children[i];
+              collected[child.name] = this.visit(child.value, value);
+            }
+            return collected;
+          case "OrExpression":
+            matched = this.visit(node.children[0], value);
+            if (isFalse(matched)) {
+              matched = this.visit(node.children[1], value);
+            }
+            return matched;
+          case "AndExpression":
+            first = this.visit(node.children[0], value);
+            if (isFalse(first) === true) {
+              return first;
+            }
+            return this.visit(node.children[1], value);
+          case "NotExpression":
+            first = this.visit(node.children[0], value);
+            return isFalse(first);
+          case "Literal":
+            return node.value;
+          case TOK_PIPE:
+            left = this.visit(node.children[0], value);
+            return this.visit(node.children[1], left);
+          case TOK_CURRENT:
+            return value;
+          case "Function":
+            var resolvedArgs = [];
+            for (i = 0;i < node.children.length; i++) {
+              resolvedArgs.push(this.visit(node.children[i], value));
+            }
+            return this.runtime.callFunction(node.name, resolvedArgs);
+          case "ExpressionReference":
+            var refNode = node.children[0];
+            refNode.jmespathType = TOK_EXPREF;
+            return refNode;
+          default:
+            throw new Error("Unknown node type: " + node.type);
+        }
+      },
+      computeSliceParams: function(arrayLength, sliceParams) {
+        var start = sliceParams[0];
+        var stop = sliceParams[1];
+        var step = sliceParams[2];
+        var computed = [null, null, null];
+        if (step === null) {
+          step = 1;
+        } else if (step === 0) {
+          var error = new Error("Invalid slice, step cannot be 0");
+          error.name = "RuntimeError";
+          throw error;
         }
-        const base = this.visit(left, value);
-        if (allowString && typeof base === "string") {
-          return this.visit(right, base);
+        var stepValueNegative = step < 0 ? true : false;
+        if (start === null) {
+          start = stepValueNegative ? arrayLength - 1 : 0;
+        } else {
+          start = this.capSliceRange(arrayLength, start, step);
         }
-        if (!Array.isArray(base)) {
-          return null;
+        if (stop === null) {
+          stop = stepValueNegative ? -1 : arrayLength;
+        } else {
+          stop = this.capSliceRange(arrayLength, stop, step);
         }
-        const collected = [];
-        for (const elem of base) {
-          const current = this.visit(right, elem);
-          if (current !== null) {
-            collected.push(current);
+        computed[0] = start;
+        computed[1] = stop;
+        computed[2] = step;
+        return computed;
+      },
+      capSliceRange: function(arrayLength, actualValue, step) {
+        if (actualValue < 0) {
+          actualValue += arrayLength;
+          if (actualValue < 0) {
+            actualValue = step < 0 ? -1 : 0;
           }
+        } else if (actualValue >= arrayLength) {
+          actualValue = step < 0 ? arrayLength - 1 : arrayLength;
         }
-        return collected;
+        return actualValue;
       }
-      case "ValueProjection": {
-        const { left, right } = node;
-        const base = this.visit(left, value);
-        if (base === null || typeof base !== "object" || Array.isArray(base)) {
-          return null;
+    };
+    function Runtime(interpreter) {
+      this._interpreter = interpreter;
+      this.functionTable = {
+        abs: { _func: this._functionAbs, _signature: [{ types: [TYPE_NUMBER] }] },
+        avg: { _func: this._functionAvg, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+        ceil: { _func: this._functionCeil, _signature: [{ types: [TYPE_NUMBER] }] },
+        contains: {
+          _func: this._functionContains,
+          _signature: [
+            { types: [TYPE_STRING, TYPE_ARRAY] },
+            { types: [TYPE_ANY] }
+          ]
+        },
+        ends_with: {
+          _func: this._functionEndsWith,
+          _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+        },
+        floor: { _func: this._functionFloor, _signature: [{ types: [TYPE_NUMBER] }] },
+        length: {
+          _func: this._functionLength,
+          _signature: [{ types: [TYPE_STRING, TYPE_ARRAY, TYPE_OBJECT] }]
+        },
+        map: {
+          _func: this._functionMap,
+          _signature: [{ types: [TYPE_EXPREF] }, { types: [TYPE_ARRAY] }]
+        },
+        max: {
+          _func: this._functionMax,
+          _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+        },
+        merge: {
+          _func: this._functionMerge,
+          _signature: [{ types: [TYPE_OBJECT], variadic: true }]
+        },
+        max_by: {
+          _func: this._functionMaxBy,
+          _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+        },
+        sum: { _func: this._functionSum, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+        starts_with: {
+          _func: this._functionStartsWith,
+          _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+        },
+        min: {
+          _func: this._functionMin,
+          _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+        },
+        min_by: {
+          _func: this._functionMinBy,
+          _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+        },
+        type: { _func: this._functionType, _signature: [{ types: [TYPE_ANY] }] },
+        keys: { _func: this._functionKeys, _signature: [{ types: [TYPE_OBJECT] }] },
+        values: { _func: this._functionValues, _signature: [{ types: [TYPE_OBJECT] }] },
+        sort: { _func: this._functionSort, _signature: [{ types: [TYPE_ARRAY_STRING, TYPE_ARRAY_NUMBER] }] },
+        sort_by: {
+          _func: this._functionSortBy,
+          _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+        },
+        join: {
+          _func: this._functionJoin,
+          _signature: [
+            { types: [TYPE_STRING] },
+            { types: [TYPE_ARRAY_STRING] }
+          ]
+        },
+        reverse: {
+          _func: this._functionReverse,
+          _signature: [{ types: [TYPE_STRING, TYPE_ARRAY] }]
+        },
+        to_array: { _func: this._functionToArray, _signature: [{ types: [TYPE_ANY] }] },
+        to_string: { _func: this._functionToString, _signature: [{ types: [TYPE_ANY] }] },
+        to_number: { _func: this._functionToNumber, _signature: [{ types: [TYPE_ANY] }] },
+        not_null: {
+          _func: this._functionNotNull,
+          _signature: [{ types: [TYPE_ANY], variadic: true }]
+        }
+      };
+    }
+    Runtime.prototype = {
+      callFunction: function(name, resolvedArgs) {
+        var functionEntry = this.functionTable[name];
+        if (functionEntry === undefined) {
+          throw new Error("Unknown function: " + name + "()");
         }
-        const collected = [];
-        const values = Object.values(base);
-        for (const elem of values) {
-          const current = this.visit(right, elem);
-          if (current !== null) {
-            collected.push(current);
+        this._validateArgs(name, resolvedArgs, functionEntry._signature);
+        return functionEntry._func.call(this, resolvedArgs);
+      },
+      _validateArgs: function(name, args, signature) {
+        var pluralized;
+        if (signature[signature.length - 1].variadic) {
+          if (args.length < signature.length) {
+            pluralized = signature.length === 1 ? " argument" : " arguments";
+            throw new Error("ArgumentError: " + name + "() " + "takes at least" + signature.length + pluralized + " but received " + args.length);
+          }
+        } else if (args.length !== signature.length) {
+          pluralized = signature.length === 1 ? " argument" : " arguments";
+          throw new Error("ArgumentError: " + name + "() " + "takes " + signature.length + pluralized + " but received " + args.length);
+        }
+        var currentSpec;
+        var actualType;
+        var typeMatched;
+        for (var i = 0;i < signature.length; i++) {
+          typeMatched = false;
+          currentSpec = signature[i].types;
+          actualType = this._getTypeName(args[i]);
+          for (var j = 0;j < currentSpec.length; j++) {
+            if (this._typeMatches(actualType, currentSpec[j], args[i])) {
+              typeMatched = true;
+              break;
+            }
+          }
+          if (!typeMatched) {
+            var expected = currentSpec.map(function(typeIdentifier) {
+              return TYPE_NAME_TABLE[typeIdentifier];
+            }).join(",");
+            throw new Error("TypeError: " + name + "() " + "expected argument " + (i + 1) + " to be type " + expected + " but received type " + TYPE_NAME_TABLE[actualType] + " instead.");
           }
         }
-        return collected;
-      }
-      case "FilterProjection": {
-        const { left, right, condition } = node;
-        const base = this.visit(left, value);
-        if (!Array.isArray(base)) {
-          return null;
+      },
+      _typeMatches: function(actual, expected, argValue) {
+        if (expected === TYPE_ANY) {
+          return true;
         }
-        const results = [];
-        for (const elem of base) {
-          const matched = this.visit(condition, elem);
-          if (isFalse(matched)) {
-            continue;
+        if (expected === TYPE_ARRAY_STRING || expected === TYPE_ARRAY_NUMBER || expected === TYPE_ARRAY) {
+          if (expected === TYPE_ARRAY) {
+            return actual === TYPE_ARRAY;
+          } else if (actual === TYPE_ARRAY) {
+            var subtype;
+            if (expected === TYPE_ARRAY_NUMBER) {
+              subtype = TYPE_NUMBER;
+            } else if (expected === TYPE_ARRAY_STRING) {
+              subtype = TYPE_STRING;
+            }
+            for (var i = 0;i < argValue.length; i++) {
+              if (!this._typeMatches(this._getTypeName(argValue[i]), subtype, argValue[i])) {
+                return false;
+              }
+            }
+            return true;
           }
-          const result = this.visit(right, elem);
-          if (result !== null) {
-            results.push(result);
+        } else {
+          return actual === expected;
+        }
+      },
+      _getTypeName: function(obj) {
+        switch (Object.prototype.toString.call(obj)) {
+          case "[object String]":
+            return TYPE_STRING;
+          case "[object Number]":
+            return TYPE_NUMBER;
+          case "[object Array]":
+            return TYPE_ARRAY;
+          case "[object Boolean]":
+            return TYPE_BOOLEAN;
+          case "[object Null]":
+            return TYPE_NULL;
+          case "[object Object]":
+            if (obj.jmespathType === TOK_EXPREF) {
+              return TYPE_EXPREF;
+            } else {
+              return TYPE_OBJECT;
+            }
+        }
+      },
+      _functionStartsWith: function(resolvedArgs) {
+        return resolvedArgs[0].lastIndexOf(resolvedArgs[1]) === 0;
+      },
+      _functionEndsWith: function(resolvedArgs) {
+        var searchStr = resolvedArgs[0];
+        var suffix = resolvedArgs[1];
+        return searchStr.indexOf(suffix, searchStr.length - suffix.length) !== -1;
+      },
+      _functionReverse: function(resolvedArgs) {
+        var typeName = this._getTypeName(resolvedArgs[0]);
+        if (typeName === TYPE_STRING) {
+          var originalStr = resolvedArgs[0];
+          var reversedStr = "";
+          for (var i = originalStr.length - 1;i >= 0; i--) {
+            reversedStr += originalStr[i];
           }
+          return reversedStr;
+        } else {
+          var reversedArray = resolvedArgs[0].slice(0);
+          reversedArray.reverse();
+          return reversedArray;
         }
-        return results;
-      }
-      case "Arithmetic": {
-        const first = this.visit(node.left, value);
-        const second = this.visit(node.right, value);
-        switch (node.operator) {
-          case "Plus":
-            return add(first, second);
-          case "Minus":
-            return sub(first, second);
-          case "Multiply":
-          case "Star":
-            return mul(first, second);
-          case "Divide":
-            return divide(first, second);
-          case "Modulo":
-            return mod(first, second);
-          case "Div":
-            return div(first, second);
-          default:
-            throw new Error(`Syntax error: unknown arithmetic operator: ${node.operator}`);
-        }
-      }
-      case "Unary": {
-        const operand = this.visit(node.operand, value);
-        switch (node.operator) {
-          case "Plus":
-            ensureNumbers(operand);
-            return operand;
-          case "Minus":
-            ensureNumbers(operand);
-            return -operand;
-          default:
-            throw new Error(`Syntax error: unknown arithmetic operator: ${node.operator}`);
+      },
+      _functionAbs: function(resolvedArgs) {
+        return Math.abs(resolvedArgs[0]);
+      },
+      _functionCeil: function(resolvedArgs) {
+        return Math.ceil(resolvedArgs[0]);
+      },
+      _functionAvg: function(resolvedArgs) {
+        var sum = 0;
+        var inputArray = resolvedArgs[0];
+        for (var i = 0;i < inputArray.length; i++) {
+          sum += inputArray[i];
         }
-      }
-      case "Comparator": {
-        const first = this.visit(node.left, value);
-        const second = this.visit(node.right, value);
-        switch (node.name) {
-          case "EQ":
-            return strictDeepEqual(first, second);
-          case "NE":
-            return !strictDeepEqual(first, second);
+        return sum / inputArray.length;
+      },
+      _functionContains: function(resolvedArgs) {
+        return resolvedArgs[0].indexOf(resolvedArgs[1]) >= 0;
+      },
+      _functionFloor: function(resolvedArgs) {
+        return Math.floor(resolvedArgs[0]);
+      },
+      _functionLength: function(resolvedArgs) {
+        if (!isObject(resolvedArgs[0])) {
+          return resolvedArgs[0].length;
+        } else {
+          return Object.keys(resolvedArgs[0]).length;
+        }
+      },
+      _functionMap: function(resolvedArgs) {
+        var mapped = [];
+        var interpreter = this._interpreter;
+        var exprefNode = resolvedArgs[0];
+        var elements = resolvedArgs[1];
+        for (var i = 0;i < elements.length; i++) {
+          mapped.push(interpreter.visit(exprefNode, elements[i]));
+        }
+        return mapped;
+      },
+      _functionMerge: function(resolvedArgs) {
+        var merged = {};
+        for (var i = 0;i < resolvedArgs.length; i++) {
+          var current = resolvedArgs[i];
+          for (var key in current) {
+            merged[key] = current[key];
+          }
+        }
+        return merged;
+      },
+      _functionMax: function(resolvedArgs) {
+        if (resolvedArgs[0].length > 0) {
+          var typeName = this._getTypeName(resolvedArgs[0][0]);
+          if (typeName === TYPE_NUMBER) {
+            return Math.max.apply(Math, resolvedArgs[0]);
+          } else {
+            var elements = resolvedArgs[0];
+            var maxElement = elements[0];
+            for (var i = 1;i < elements.length; i++) {
+              if (maxElement.localeCompare(elements[i]) < 0) {
+                maxElement = elements[i];
+              }
+            }
+            return maxElement;
+          }
+        } else {
+          return null;
         }
-        if (typeof first !== "number" || typeof second !== "number") {
+      },
+      _functionMin: function(resolvedArgs) {
+        if (resolvedArgs[0].length > 0) {
+          var typeName = this._getTypeName(resolvedArgs[0][0]);
+          if (typeName === TYPE_NUMBER) {
+            return Math.min.apply(Math, resolvedArgs[0]);
+          } else {
+            var elements = resolvedArgs[0];
+            var minElement = elements[0];
+            for (var i = 1;i < elements.length; i++) {
+              if (elements[i].localeCompare(minElement) < 0) {
+                minElement = elements[i];
+              }
+            }
+            return minElement;
+          }
+        } else {
           return null;
         }
-        switch (node.name) {
-          case "GT":
-            return first > second;
-          case "GTE":
-            return first >= second;
-          case "LT":
-            return first < second;
-          case "LTE":
-            return first <= second;
+      },
+      _functionSum: function(resolvedArgs) {
+        var sum = 0;
+        var listToSum = resolvedArgs[0];
+        for (var i = 0;i < listToSum.length; i++) {
+          sum += listToSum[i];
         }
-      }
-      case "Flatten": {
-        const original = this.visit(node.child, value);
-        return Array.isArray(original) ? original.flat() : null;
-      }
-      case "Root":
-        return this._rootValue;
-      case "MultiSelectList": {
-        const collected = [];
-        for (const child of node.children) {
-          collected.push(this.visit(child, value));
+        return sum;
+      },
+      _functionType: function(resolvedArgs) {
+        switch (this._getTypeName(resolvedArgs[0])) {
+          case TYPE_NUMBER:
+            return "number";
+          case TYPE_STRING:
+            return "string";
+          case TYPE_ARRAY:
+            return "array";
+          case TYPE_OBJECT:
+            return "object";
+          case TYPE_BOOLEAN:
+            return "boolean";
+          case TYPE_EXPREF:
+            return "expref";
+          case TYPE_NULL:
+            return "null";
         }
-        return collected;
-      }
-      case "MultiSelectHash": {
-        const collected = {};
-        for (const child of node.children) {
-          collected[child.name] = this.visit(child.value, value);
+      },
+      _functionKeys: function(resolvedArgs) {
+        return Object.keys(resolvedArgs[0]);
+      },
+      _functionValues: function(resolvedArgs) {
+        var obj = resolvedArgs[0];
+        var keys = Object.keys(obj);
+        var values = [];
+        for (var i = 0;i < keys.length; i++) {
+          values.push(obj[keys[i]]);
+        }
+        return values;
+      },
+      _functionJoin: function(resolvedArgs) {
+        var joinChar = resolvedArgs[0];
+        var listJoin = resolvedArgs[1];
+        return listJoin.join(joinChar);
+      },
+      _functionToArray: function(resolvedArgs) {
+        if (this._getTypeName(resolvedArgs[0]) === TYPE_ARRAY) {
+          return resolvedArgs[0];
+        } else {
+          return [resolvedArgs[0]];
         }
-        return collected;
-      }
-      case "OrExpression": {
-        const result = this.visit(node.left, value);
-        if (isFalse(result)) {
-          return this.visit(node.right, value);
+      },
+      _functionToString: function(resolvedArgs) {
+        if (this._getTypeName(resolvedArgs[0]) === TYPE_STRING) {
+          return resolvedArgs[0];
+        } else {
+          return JSON.stringify(resolvedArgs[0]);
         }
-        return result;
-      }
-      case "AndExpression": {
-        const result = this.visit(node.left, value);
-        if (isFalse(result)) {
-          return result;
+      },
+      _functionToNumber: function(resolvedArgs) {
+        var typeName = this._getTypeName(resolvedArgs[0]);
+        var convertedValue;
+        if (typeName === TYPE_NUMBER) {
+          return resolvedArgs[0];
+        } else if (typeName === TYPE_STRING) {
+          convertedValue = +resolvedArgs[0];
+          if (!isNaN(convertedValue)) {
+            return convertedValue;
+          }
         }
-        return this.visit(node.right, value);
-      }
-      case "NotExpression":
-        return isFalse(this.visit(node.child, value));
-      case "Literal":
-        return node.value;
-      case "Pipe":
-        return this.visit(node.right, this.visit(node.left, value));
-      case "Function": {
-        const args = [];
-        for (const child of node.children) {
-          args.push(this.visit(child, value));
+        return null;
+      },
+      _functionNotNull: function(resolvedArgs) {
+        for (var i = 0;i < resolvedArgs.length; i++) {
+          if (this._getTypeName(resolvedArgs[i]) !== TYPE_NULL) {
+            return resolvedArgs[i];
+          }
         }
-        return this.runtime.callFunction(node.name, args);
-      }
-      case "ExpressionReference":
-        return {
-          expref: true,
-          ...node.child
+        return null;
+      },
+      _functionSort: function(resolvedArgs) {
+        var sortedArray = resolvedArgs[0].slice(0);
+        sortedArray.sort();
+        return sortedArray;
+      },
+      _functionSortBy: function(resolvedArgs) {
+        var sortedArray = resolvedArgs[0].slice(0);
+        if (sortedArray.length === 0) {
+          return sortedArray;
+        }
+        var interpreter = this._interpreter;
+        var exprefNode = resolvedArgs[1];
+        var requiredType = this._getTypeName(interpreter.visit(exprefNode, sortedArray[0]));
+        if ([TYPE_NUMBER, TYPE_STRING].indexOf(requiredType) < 0) {
+          throw new Error("TypeError");
+        }
+        var that = this;
+        var decorated = [];
+        for (var i = 0;i < sortedArray.length; i++) {
+          decorated.push([i, sortedArray[i]]);
+        }
+        decorated.sort(function(a, b) {
+          var exprA = interpreter.visit(exprefNode, a[1]);
+          var exprB = interpreter.visit(exprefNode, b[1]);
+          if (that._getTypeName(exprA) !== requiredType) {
+            throw new Error("TypeError: expected " + requiredType + ", received " + that._getTypeName(exprA));
+          } else if (that._getTypeName(exprB) !== requiredType) {
+            throw new Error("TypeError: expected " + requiredType + ", received " + that._getTypeName(exprB));
+          }
+          if (exprA > exprB) {
+            return 1;
+          } else if (exprA < exprB) {
+            return -1;
+          } else {
+            return a[0] - b[0];
+          }
+        });
+        for (var j = 0;j < decorated.length; j++) {
+          sortedArray[j] = decorated[j][1];
+        }
+        return sortedArray;
+      },
+      _functionMaxBy: function(resolvedArgs) {
+        var exprefNode = resolvedArgs[1];
+        var resolvedArray = resolvedArgs[0];
+        var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+        var maxNumber = -Infinity;
+        var maxRecord;
+        var current;
+        for (var i = 0;i < resolvedArray.length; i++) {
+          current = keyFunction(resolvedArray[i]);
+          if (current > maxNumber) {
+            maxNumber = current;
+            maxRecord = resolvedArray[i];
+          }
+        }
+        return maxRecord;
+      },
+      _functionMinBy: function(resolvedArgs) {
+        var exprefNode = resolvedArgs[1];
+        var resolvedArray = resolvedArgs[0];
+        var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+        var minNumber = Infinity;
+        var minRecord;
+        var current;
+        for (var i = 0;i < resolvedArray.length; i++) {
+          current = keyFunction(resolvedArray[i]);
+          if (current < minNumber) {
+            minNumber = current;
+            minRecord = resolvedArray[i];
+          }
+        }
+        return minRecord;
+      },
+      createKeyFunction: function(exprefNode, allowedTypes) {
+        var that = this;
+        var interpreter = this._interpreter;
+        var keyFunc = function(x) {
+          var current = interpreter.visit(exprefNode, x);
+          if (allowedTypes.indexOf(that._getTypeName(current)) < 0) {
+            var msg = "TypeError: expected one of " + allowedTypes + ", received " + that._getTypeName(current);
+            throw new Error(msg);
+          }
+          return current;
         };
-      case "Current":
-      case "Identity":
-        return value;
-    }
-  }
-  computeSliceParams(arrayLength, sliceNode) {
-    let { start, stop, step } = sliceNode;
-    if (step === null) {
-      step = 1;
-    } else if (step === 0) {
-      const error = new Error("Invalid value: slice step cannot be 0");
-      error.name = "RuntimeError";
-      throw error;
-    }
-    start = start === null ? step < 0 ? arrayLength - 1 : 0 : this.capSliceRange(arrayLength, start, step);
-    stop = stop === null ? step < 0 ? -1 : arrayLength : this.capSliceRange(arrayLength, stop, step);
-    return { start, stop, step };
-  }
-  capSliceRange(arrayLength, actualValue, step) {
-    let nextActualValue = actualValue;
-    if (nextActualValue < 0) {
-      nextActualValue += arrayLength;
-      if (nextActualValue < 0) {
-        nextActualValue = step < 0 ? -1 : 0;
-      }
-    } else if (nextActualValue >= arrayLength) {
-      nextActualValue = step < 0 ? arrayLength - 1 : arrayLength;
-    }
-    return nextActualValue;
-  }
-  slice(collection, start, end, step) {
-    const result = [];
-    if (step > 0) {
-      for (let i = start;i < end; i += step) {
-        result.push(collection[i]);
-      }
-    } else {
-      for (let i = start;i > end; i += step) {
-        result.push(collection[i]);
+        return keyFunc;
       }
-    }
-    return result;
-  }
-}, TreeInterpreterInstance, TreeInterpreter_default, TYPE_ANY = 1, TYPE_ARRAY = 3, TYPE_ARRAY_ARRAY = 11, TYPE_ARRAY_NUMBER = 8, TYPE_ARRAY_OBJECT = 10, TYPE_ARRAY_STRING = 9, TYPE_BOOLEAN = 5, TYPE_EXPREF = 6, TYPE_NULL = 7, TYPE_NUMBER = 0, TYPE_OBJECT = 4, TYPE_STRING = 2, registerFunction = (functionName, customFunction, signature, options) => {
-  TreeInterpreter_default.runtime.registerFunction(functionName, customFunction, signature, options);
-}, register = (name, customFunction, signature, options) => {
-  return TreeInterpreter_default.runtime.register(name, customFunction, signature, options);
-}, unregisterFunction = (name) => {
-  return TreeInterpreter_default.runtime.unregister(name);
-}, isRegistered = (name) => {
-  return TreeInterpreter_default.runtime.isRegistered(name);
-}, getRegisteredFunctions = () => {
-  return TreeInterpreter_default.runtime.getRegistered();
-}, getCustomFunctions = () => {
-  return TreeInterpreter_default.runtime.getCustomFunctions();
-}, clearCustomFunctions = () => {
-  TreeInterpreter_default.runtime.clearCustomFunctions();
-}, TreeInterpreter2, jmespath;
-var init_dist = __esm(() => {
-  basicTokens = {
-    "(": "Lparen",
-    ")": "Rparen",
-    "*": "Star",
-    ",": "Comma",
-    ".": "Dot",
-    ":": "Colon",
-    "@": "Current",
-    "]": "Rbracket",
-    "{": "Lbrace",
-    "}": "Rbrace",
-    "+": "Plus",
-    "%": "Modulo",
-    "?": "Question",
-    "−": "Minus",
-    "×": "Multiply",
-    "÷": "Divide"
-  };
-  operatorStartToken = {
-    "!": true,
-    "<": true,
-    "=": true,
-    ">": true,
-    "&": true,
-    "|": true,
-    "/": true
-  };
-  skipChars = {
-    "\t": true,
-    "\n": true,
-    "\r": true,
-    " ": true
-  };
-  Lexer = new StreamLexer;
-  Lexer_default = Lexer;
-  bindingPower = {
-    ["EOF"]: 0,
-    ["Variable"]: 0,
-    ["UnquotedIdentifier"]: 0,
-    ["QuotedIdentifier"]: 0,
-    ["Rbracket"]: 0,
-    ["Rparen"]: 0,
-    ["Comma"]: 0,
-    ["Rbrace"]: 0,
-    ["Number"]: 0,
-    ["Current"]: 0,
-    ["Expref"]: 0,
-    ["Root"]: 0,
-    ["Assign"]: 1,
-    ["Pipe"]: 1,
-    ["Question"]: 2,
-    ["Or"]: 3,
-    ["And"]: 4,
-    ["EQ"]: 5,
-    ["GT"]: 5,
-    ["LT"]: 5,
-    ["GTE"]: 5,
-    ["LTE"]: 5,
-    ["NE"]: 5,
-    ["Minus"]: 6,
-    ["Plus"]: 6,
-    ["Div"]: 7,
-    ["Divide"]: 7,
-    ["Modulo"]: 7,
-    ["Multiply"]: 7,
-    ["Flatten"]: 9,
-    ["Star"]: 20,
-    ["Filter"]: 21,
-    ["Dot"]: 40,
-    ["Not"]: 45,
-    ["Lbrace"]: 50,
-    ["Lbracket"]: 55,
-    ["Lparen"]: 60
-  };
-  Parser = new TokenParser;
-  Parser_default = Parser;
-  emptyScopeChain = new ScopeChain;
-  TreeInterpreterInstance = new TreeInterpreter;
-  TreeInterpreter_default = TreeInterpreterInstance;
-  TreeInterpreter2 = TreeInterpreter_default;
-  jmespath = {
-    compile,
-    registerFunction,
-    register,
-    unregisterFunction,
-    isRegistered,
-    getRegisteredFunctions,
-    getCustomFunctions,
-    clearCustomFunctions,
-    search,
-    tokenize,
-    TreeInterpreter: TreeInterpreter2,
-    TYPE_ANY,
-    TYPE_ARRAY_NUMBER,
-    TYPE_ARRAY_STRING,
-    TYPE_ARRAY,
-    TYPE_BOOLEAN,
-    TYPE_EXPREF,
-    TYPE_NULL,
-    TYPE_NUMBER,
-    TYPE_OBJECT,
-    TYPE_STRING
-  };
+    };
+    function compile(stream) {
+      var parser = new Parser;
+      var ast = parser.parse(stream);
+      return ast;
+    }
+    function tokenize(stream) {
+      var lexer = new Lexer;
+      return lexer.tokenize(stream);
+    }
+    function search(data, expression) {
+      var parser = new Parser;
+      var runtime = new Runtime;
+      var interpreter = new TreeInterpreter(runtime);
+      runtime._interpreter = interpreter;
+      var node = parser.parse(expression);
+      return interpreter.search(node, data);
+    }
+    exports2.tokenize = tokenize;
+    exports2.compile = compile;
+    exports2.search = search;
+    exports2.strictDeepEqual = strictDeepEqual;
+  })(typeof exports === "undefined" ? exports.jmespath = {} : exports);
 });
 
 // ../../node_modules/commander/lib/error.js
@@ -6138,10 +5615,10 @@ var require_help = __commonJS(function(exports) {
         });
         output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
       }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub2) => sub2.helpGroup() || "Commands:");
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
       commandGroups.forEach((commands, group) => {
-        const commandList = commands.map((sub2) => {
-          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub2)), helper.styleSubcommandDescription(helper.subcommandDescription(sub2)));
+        const commandList = commands.map((sub) => {
+          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
         });
         output = output.concat(this.formatItemList(group, commandList, helper));
       });
@@ -9424,13 +8901,13 @@ var jmespathSlot = singleton("JmespathCodec");
 async function loadOutputCodecsAsync(needed) {
   const loads = [];
   if (needed.yaml && yamlSlot.get() === undefined) {
-    loads.push(Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml)).then((mod2) => {
-      yamlSlot.set(mod2);
+    loads.push(Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml)).then((mod) => {
+      yamlSlot.set(mod);
     }));
   }
   if (needed.filter && jmespathSlot.get() === undefined) {
-    loads.push(Promise.resolve().then(() => (init_dist(), exports_dist)).then((mod2) => {
-      jmespathSlot.set(mod2);
+    loads.push(Promise.resolve().then(() => __toESM(require_jmespath(), 1)).then((mod) => {
+      jmespathSlot.set(mod);
     }));
   }
   await Promise.all(loads);
@@ -10325,8 +9802,8 @@ class TelemetryService {
 var TIMINGS_ENV_VAR = "UIP_TIMINGS";
 var TIMINGS_LINE_PREFIX = "[timing]";
 function createStorage2() {
-  const [error, mod2] = catchError(() => __require("node:async_hooks"));
-  if (error || typeof mod2?.AsyncLocalStorage !== "function") {
+  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
         return;
@@ -10334,7 +9811,7 @@ function createStorage2() {
       run: (_store, fn) => fn()
     };
   }
-  return new mod2.AsyncLocalStorage;
+  return new mod.AsyncLocalStorage;
 }
 var storageSlot = singleton("TimingStorage");
 var stateSlot = singleton("Timings");
@@ -10678,7 +10155,7 @@ async function loadApplicationInsights() {
   const savedDebug = process.env.DEBUG;
   delete process.env.DEBUG;
   configureAppInsightsEnvironment();
-  const [error, mod2] = await catchError(import("applicationinsights"));
+  const [error, mod] = await catchError(import("applicationinsights"));
   if (savedDebug !== undefined) {
     process.env.DEBUG = savedDebug;
   }
@@ -10686,7 +10163,7 @@ async function loadApplicationInsights() {
     logger.warn(`[Telemetry] applicationinsights package not available: ${error.message}. Telemetry will use logger fallback.`);
     return;
   }
-  return mod2;
+  return mod;
 }
 function configureAppInsightsClient(client) {
   if (client.config) {
@@ -10720,12 +10197,12 @@ class NodeAppInsightsTelemetryProvider {
   async initialize() {
     if (this.initialized)
       return true;
-    const mod2 = await loadApplicationInsights();
-    if (!mod2)
+    const mod = await loadApplicationInsights();
+    if (!mod)
       return false;
-    this.appInsightsModule = mod2;
+    this.appInsightsModule = mod;
     logger.debug("[AppInsights] NodeAppInsightsTelemetryProvider initialized");
-    const client = new mod2.TelemetryClient(this.connectionString);
+    const client = new mod.TelemetryClient(this.connectionString);
     client.context.tags[client.context.keys.sessionId] = this._sessionId;
     this.client = client;
     configureAppInsightsClient(this.client);
@@ -11995,9 +11472,9 @@ function setPreviewBuild(isPreview) {
 function isPreviewBuild() {
   return previewSlot.get(false) ?? false;
 }
-function previewOnly(register2) {
+function previewOnly(register) {
   if (isPreviewBuild()) {
-    register2();
+    register();
   }
 }
 Command.prototype.previewCommand = function(nameAndArgs, opts) {
@@ -12500,9 +11977,9 @@ function collectCommands(command, parentName, result) {
   if (subcommands.length === 0 && !hasAction && parentName) {
     result.push({ command, fullName: parentName });
   }
-  for (const sub2 of subcommands) {
-    const name = parentName ? `${parentName} ${sub2.name()}` : sub2.name();
-    collectCommands(sub2, name, result);
+  for (const sub of subcommands) {
+    const name = parentName ? `${parentName} ${sub.name()}` : sub.name();
+    collectCommands(sub, name, result);
   }
 }
 // src/completer.ts
@@ -13178,16 +12655,16 @@ function mapPackageMetadataOptions(opts) {
 // src/packager-tool-import.ts
 var REGISTER_EXPORT = "registerPackagerFactories";
 async function importPackagerTool(specifier) {
-  const [importError, mod2] = await catchError(import(specifier));
+  const [importError, mod] = await catchError(import(specifier));
   if (importError)
     return importError;
-  const register2 = mod2?.[REGISTER_EXPORT];
-  if (typeof register2 !== "function") {
+  const register = mod?.[REGISTER_EXPORT];
+  if (typeof register !== "function") {
     logger.debug(`'${specifier}' has no '${REGISTER_EXPORT}' export — treating it as a ` + "legacy entry point that registered its factories at import.");
     return;
   }
   const [registerError] = catchError(() => {
-    register2();
+    register();
   });
   return registerError;
 }
@@ -14207,4 +13684,4 @@ export {
   writeTelemetrySpoolFile
 };
 
-//# debugId=39D73B2CDA6F6AF764756E2164756E21
+//# debugId=E388413E446272F364756E2164756E21