@uipath/solution-tool 1.200.0-preview.109 → 1.201.0-preview.115

package/dist/index-2fj08e7n.js

@@ -0,0 +1,2058 @@
+import"./packager-tool-0v6na3yp.js";
+
+// ../../node_modules/@jmespath-community/jmespath/dist/index.mjs
+var isObject = (obj) => {
+  return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
+};
+var 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])) {
+        return false;
+      }
+      secondKeys.delete(key);
+    }
+    return secondKeys.size === 0;
+  }
+  return false;
+};
+var 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;
+};
+var isAlpha = (ch) => {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+};
+var isNum = (ch) => {
+  return ch >= "0" && ch <= "9" || ch === "-";
+};
+var isAlphaNum = (ch) => {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+};
+var ensureInteger = (value) => {
+  if (!(typeof value === "number") || Math.floor(value) !== value) {
+    throw new Error("invalid-value: expecting an integer.");
+  }
+  return value;
+};
+var ensurePositiveInteger = (value) => {
+  if (!(typeof value === "number") || value < 0 || Math.floor(value) !== value) {
+    throw new Error("invalid-value: expecting a non-negative integer.");
+  }
+  return value;
+};
+var 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");
+    }
+  }
+};
+var notZero = (n) => {
+  n = +n;
+  if (!n) {
+    throw new Error("not-a-number: divide by zero");
+  }
+  return n;
+};
+var add = (left, right) => {
+  ensureNumbers(left, right);
+  const result = left + right;
+  return result;
+};
+var sub = (left, right) => {
+  ensureNumbers(left, right);
+  const result = left - right;
+  return result;
+};
+var mul = (left, right) => {
+  ensureNumbers(left, right);
+  const result = left * right;
+  return result;
+};
+var divide = (left, right) => {
+  ensureNumbers(left, right);
+  const result = left / notZero(right);
+  return result;
+};
+var div = (left, right) => {
+  ensureNumbers(left, right);
+  const result = Math.floor(left / notZero(right));
+  return result;
+};
+var mod = (left, right) => {
+  ensureNumbers(left, right);
+  const result = left % right;
+  return result;
+};
+var 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;
+};
+var 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;
+};
+var lower = (subject) => subject.toLowerCase();
+var 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;
+};
+var padLeft = (subject, width, padding) => {
+  padding = ensurePadFuncParams("pad_left", width, padding);
+  return subject && subject.padStart(width, padding) || "";
+};
+var padRight = (subject, width, padding) => {
+  padding = ensurePadFuncParams("pad_right", width, padding);
+  return subject && subject.padEnd(width, padding) || "";
+};
+var 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;
+};
+var 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)];
+};
+var trim = (subject, chars) => {
+  return trimLeft(trimRight(subject, chars), chars);
+};
+var trimLeft = (subject, chars) => {
+  return trimImpl(subject, (list) => new RegExp(`^[${list}]*(.*?)`), chars);
+};
+var trimRight = (subject, chars) => {
+  return trimImpl(subject, (list) => new RegExp(`(.*?)[${list}]*$`), chars);
+};
+var trimImpl = (subject, regExper, chars) => {
+  const pattern = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : "\\s…";
+  return subject.replace(regExper(pattern), "$1");
+};
+var upper = (subject) => subject.toUpperCase();
+var basicTokens = {
+  "(": "Lparen",
+  ")": "Rparen",
+  "*": "Star",
+  ",": "Comma",
+  ".": "Dot",
+  ":": "Colon",
+  "@": "Current",
+  "]": "Rbracket",
+  "{": "Lbrace",
+  "}": "Rbrace",
+  "+": "Plus",
+  "%": "Modulo",
+  "?": "Question",
+  "−": "Minus",
+  "×": "Multiply",
+  "÷": "Divide"
+};
+var operatorStartToken = {
+  "!": true,
+  "<": true,
+  "=": true,
+  ">": true,
+  "&": true,
+  "|": true,
+  "/": true
+};
+var skipChars = {
+  "\t": true,
+  "\n": true,
+  "\r": true,
+  " ": true
+};
+var 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;
+      } else {
+        const error = new Error(`Syntax error: unknown character: ${stream[this._current]}`);
+        error.name = "LexerError";
+        throw error;
+      }
+    }
+    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;
+      }
+      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;
+      }
+      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 json = JSON.parse(text);
+      return [json, true];
+    } catch {
+      return [null, false];
+    }
+  }
+};
+var Lexer = new StreamLexer;
+var Lexer_default = Lexer;
+var 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
+};
+var 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 };
+        }
+      }
+      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 };
+        }
+      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
+        };
+      }
+      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"
+          };
+        }
+        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 };
+      }
+      case "Lparen": {
+        const expression = this.expression(0);
+        this.match("Rparen");
+        return expression;
+      }
+      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
+        };
+      }
+      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
+        };
+      }
+      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 };
+      }
+      default:
+        return this.errorToken(this.lookaheadToken(0));
+    }
+  }
+  static isKeyword(token, keyword) {
+    return token.type === "UnquotedIdentifier" && token.value === keyword;
+  }
+  match(tokenType) {
+    if (this.lookahead(0) === tokenType) {
+      this.advance();
+      return;
+    } 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"
+      };
+    }
+    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
+    };
+  }
+  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 pairs = [];
+    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);
+      pairs.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: pairs };
+  }
+};
+var Parser = new TokenParser;
+var Parser_default = Parser;
+var 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);
+    };
+    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;
+  }
+};
+var createMathFunction = (mathFn) => ([value]) => mathFn(value);
+var createStringFunction = (stringFn) => ([subject]) => stringFn(subject);
+var createObjectFunction = (objFn) => ([obj]) => objFn(obj);
+var 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] }]
+      },
+      sort: {
+        _func: this.functionSort,
+        _signature: [{ types: [9, 8] }]
+      },
+      sort_by: {
+        _func: this.functionSortBy,
+        _signature: [{ types: [3] }, { types: [6] }]
+      },
+      split: {
+        _func: this.functionSplit,
+        _signature: [
+          { types: [2] },
+          { types: [2] },
+          { types: [0], optional: true }
+        ]
+      },
+      starts_with: {
+        _func: this.functionStartsWith,
+        _signature: [{ types: [2] }, { types: [2] }]
+      },
+      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 }]
+      },
+      trim_left: {
+        _func: this.functionTrimLeft,
+        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      },
+      trim_right: {
+        _func: this.functionTrimRight,
+        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      },
+      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])) {
+            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;
+      }
+    }
+    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;
+  };
+};
+var 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;
+  }
+};
+var emptyScopeChain = new ScopeChain;
+var 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;
+        }
+        return value[identifier] ?? null;
+      case "LetExpression": {
+        const { bindings, expression } = node;
+        let scope = {};
+        bindings.forEach((binding) => {
+          const reference = this.visit(binding, value);
+          scope = {
+            ...scope,
+            ...reference
+          };
+        });
+        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}`);
+        }
+        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;
+        }
+        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;
+        }
+        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("");
+        } else {
+          return this.slice(value, start, stop, step);
+        }
+      }
+      case "Projection": {
+        const { left, right } = node;
+        let allowString = false;
+        if (left.type === "IndexExpression" && left.right.type === "Slice") {
+          allowString = true;
+        }
+        const base = this.visit(left, value);
+        if (allowString && typeof base === "string") {
+          return this.visit(right, base);
+        }
+        if (!Array.isArray(base)) {
+          return null;
+        }
+        const collected = [];
+        for (const elem of base) {
+          const current = this.visit(right, elem);
+          if (current !== null) {
+            collected.push(current);
+          }
+        }
+        return collected;
+      }
+      case "ValueProjection": {
+        const { left, right } = node;
+        const base = this.visit(left, value);
+        if (base === null || typeof base !== "object" || Array.isArray(base)) {
+          return null;
+        }
+        const collected = [];
+        const values = Object.values(base);
+        for (const elem of values) {
+          const current = this.visit(right, elem);
+          if (current !== null) {
+            collected.push(current);
+          }
+        }
+        return collected;
+      }
+      case "FilterProjection": {
+        const { left, right, condition } = node;
+        const base = this.visit(left, value);
+        if (!Array.isArray(base)) {
+          return null;
+        }
+        const results = [];
+        for (const elem of base) {
+          const matched = this.visit(condition, elem);
+          if (isFalse(matched)) {
+            continue;
+          }
+          const result = this.visit(right, elem);
+          if (result !== null) {
+            results.push(result);
+          }
+        }
+        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}`);
+        }
+      }
+      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);
+        }
+        if (typeof first !== "number" || typeof second !== "number") {
+          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;
+        }
+      }
+      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 collected;
+      }
+      case "MultiSelectHash": {
+        const collected = {};
+        for (const child of node.children) {
+          collected[child.name] = this.visit(child.value, value);
+        }
+        return collected;
+      }
+      case "OrExpression": {
+        const result = this.visit(node.left, value);
+        if (isFalse(result)) {
+          return this.visit(node.right, value);
+        }
+        return result;
+      }
+      case "AndExpression": {
+        const result = this.visit(node.left, value);
+        if (isFalse(result)) {
+          return result;
+        }
+        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 this.runtime.callFunction(node.name, args);
+      }
+      case "ExpressionReference":
+        return {
+          expref: true,
+          ...node.child
+        };
+      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 result;
+  }
+};
+var TreeInterpreterInstance = new TreeInterpreter;
+var TreeInterpreter_default = TreeInterpreterInstance;
+var TYPE_ANY = 1;
+var TYPE_ARRAY = 3;
+var TYPE_ARRAY_ARRAY = 11;
+var TYPE_ARRAY_NUMBER = 8;
+var TYPE_ARRAY_OBJECT = 10;
+var TYPE_ARRAY_STRING = 9;
+var TYPE_BOOLEAN = 5;
+var TYPE_EXPREF = 6;
+var TYPE_NULL = 7;
+var TYPE_NUMBER = 0;
+var TYPE_OBJECT = 4;
+var TYPE_STRING = 2;
+function compile(expression, options) {
+  const nodeTree = Parser_default.parse(expression, options);
+  return nodeTree;
+}
+function tokenize(expression, options) {
+  return Lexer_default.tokenize(expression, options);
+}
+var registerFunction = (functionName, customFunction, signature, options) => {
+  TreeInterpreter_default.runtime.registerFunction(functionName, customFunction, signature, options);
+};
+var register = (name, customFunction, signature, options) => {
+  return TreeInterpreter_default.runtime.register(name, customFunction, signature, options);
+};
+var unregisterFunction = (name) => {
+  return TreeInterpreter_default.runtime.unregister(name);
+};
+var isRegistered = (name) => {
+  return TreeInterpreter_default.runtime.isRegistered(name);
+};
+var getRegisteredFunctions = () => {
+  return TreeInterpreter_default.runtime.getRegistered();
+};
+var getCustomFunctions = () => {
+  return TreeInterpreter_default.runtime.getCustomFunctions();
+};
+var clearCustomFunctions = () => {
+  TreeInterpreter_default.runtime.clearCustomFunctions();
+};
+function search(data, expression, options) {
+  const nodeTree = Parser_default.parse(expression, options);
+  return TreeInterpreter_default.search(nodeTree, data);
+}
+function Scope() {
+  return new ScopeChain;
+}
+var TreeInterpreter2 = TreeInterpreter_default;
+var 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
+};
+export {
+  unregisterFunction,
+  tokenize,
+  search,
+  registerFunction,
+  register,
+  jmespath,
+  isRegistered,
+  getRegisteredFunctions,
+  getCustomFunctions,
+  jmespath as default,
+  compile,
+  clearCustomFunctions,
+  TreeInterpreter2 as TreeInterpreter,
+  TYPE_STRING,
+  TYPE_OBJECT,
+  TYPE_NUMBER,
+  TYPE_NULL,
+  TYPE_EXPREF,
+  TYPE_BOOLEAN,
+  TYPE_ARRAY_STRING,
+  TYPE_ARRAY_OBJECT,
+  TYPE_ARRAY_NUMBER,
+  TYPE_ARRAY_ARRAY,
+  TYPE_ARRAY,
+  TYPE_ANY,
+  Scope
+};
+
+//# debugId=FA9FB28BF9A093C864756E2164756E21