@uipath/maestro-sdk 1.202.0-preview.142 → 1.202.0

package/dist/index.js

@@ -5201,2019 +5201,1496 @@ 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;
-}, findFirst2 = (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
-    };
-  }
-  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");
+    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>"
+    };
+    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
+    };
+    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;
+          }
         }
-      }
-    }
-    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);
-    };
-    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] }
-        ]
+        return tokens;
       },
-      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 }
-        ]
+      _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);
+      },
+      _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));
       },
-      find_last: {
-        _func: this.functionFindLast,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true },
-          { 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("\\'", "'");
+      },
+      _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 };
+      },
+      _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 };
+        }
       },
-      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 }
-        ]
+      _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 };
+          }
+        }
       },
-      pad_right: {
-        _func: this.functionPadRight,
-        _signature: [
-          { types: [2] },
-          { types: [0] },
-          { 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;
       },
-      replace: {
-        _func: this.functionReplace,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true }
-        ]
+      _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;
+          }
+        } else {
+          return false;
+        }
+      }
+    };
+    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;
       },
-      reverse: {
-        _func: this.functionReverse,
-        _signature: [{ types: [2, 3] }]
+      _loadTokens: function(expression) {
+        var lexer = new Lexer;
+        var tokens = lexer.tokenize(expression);
+        tokens.push({ type: TOK_EOF, value: "", start: expression.length });
+        this.tokens = tokens;
       },
-      sort: {
-        _func: this.functionSort,
-        _signature: [{ types: [9, 8] }]
+      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;
       },
-      sort_by: {
-        _func: this.functionSortBy,
-        _signature: [{ types: [3] }, { types: [6] }]
+      _lookahead: function(number) {
+        return this.tokens[this.index + number].type;
       },
-      split: {
-        _func: this.functionSplit,
-        _signature: [
-          { types: [2] },
-          { types: [2] },
-          { types: [0], optional: true }
-        ]
+      _lookaheadToken: function(number) {
+        return this.tokens[this.index + number];
       },
-      starts_with: {
-        _func: this.functionStartsWith,
-        _signature: [{ types: [2] }, { types: [2] }]
+      _advance: function() {
+        this.index++;
       },
-      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 }]
+      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));
+        }
       },
-      trim_left: {
-        _func: this.functionTrimLeft,
-        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      _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;
+        }
       },
-      trim_right: {
-        _func: this.functionTrimRight,
-        _signature: [{ types: [2] }, { types: [2], optional: true }]
+      _errorToken: function(token) {
+        var error = new Error("Invalid token (" + token.type + '): "' + token.value + '"');
+        error.name = "ParserError";
+        throw error;
       },
-      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;
+      _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
+          };
+          this._advance();
+          this._match(TOK_RBRACKET);
+          return node;
+        }
+      },
+      _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;
+        }
+      },
+      _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);
         }
-        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(findFirst2);
-  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;
-  };
-}, 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;
+        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();
+        }
+      },
+      _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 {
+          var t = this._lookaheadToken(0);
+          var error = new Error("Sytanx error, unexpected token: " + t.value + "(" + 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
-          };
-        });
-        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 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 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;
+        return { type: "MultiSelectHash", children: pairs2 };
       }
-      case "Index": {
-        if (!Array.isArray(value)) {
-          return null;
+    };
+    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 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;
+        var stepValueNegative = step < 0 ? true : false;
+        if (start === null) {
+          start = stepValueNegative ? arrayLength - 1 : 0;
+        } else {
+          start = this.capSliceRange(arrayLength, start, step);
         }
-        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("");
+        if (stop === null) {
+          stop = stepValueNegative ? -1 : arrayLength;
         } else {
-          return this.slice(value, start, stop, step);
+          stop = this.capSliceRange(arrayLength, stop, step);
+        }
+        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 actualValue;
+      }
+    };
+    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 }]
         }
-      }
-      case "Projection": {
-        const { left, right } = node;
-        let allowString = false;
-        if (left.type === "IndexExpression" && left.right.type === "Slice") {
-          allowString = true;
+      };
+    }
+    Runtime.prototype = {
+      callFunction: function(name, resolvedArgs) {
+        var 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);
+      },
+      _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.");
+          }
         }
-        const base = this.visit(left, value);
-        if (allowString && typeof base === "string") {
-          return this.visit(right, base);
+      },
+      _typeMatches: function(actual, expected, argValue) {
+        if (expected === TYPE_ANY) {
+          return true;
         }
-        if (!Array.isArray(base)) {
-          return null;
+        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;
+          }
+        } 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;
+            }
         }
-        const collected = [];
-        for (const elem of base) {
-          const current = this.visit(right, elem);
-          if (current !== null) {
-            collected.push(current);
+      },
+      _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 collected;
-      }
-      case "ValueProjection": {
-        const { left, right } = node;
-        const base = this.visit(left, value);
-        if (base === null || typeof base !== "object" || Array.isArray(base)) {
-          return null;
+      },
+      _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];
         }
-        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 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;
         }
-        return collected;
-      }
-      case "FilterProjection": {
-        const { left, right, condition } = node;
-        const base = this.visit(left, value);
-        if (!Array.isArray(base)) {
-          return null;
+      },
+      _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]));
         }
-        const results = [];
-        for (const elem of base) {
-          const matched = this.visit(condition, elem);
-          if (isFalse(matched)) {
-            continue;
+        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];
           }
-          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 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;
         }
-        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));
+      },
+      _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;
         }
-        return collected;
-      }
-      case "MultiSelectHash": {
-        const collected = {};
-        for (const child of node.children) {
-          collected[child.name] = this.visit(child.value, value);
+      },
+      _functionSum: function(resolvedArgs) {
+        var sum = 0;
+        var listToSum = resolvedArgs[0];
+        for (var i = 0;i < listToSum.length; i++) {
+          sum += listToSum[i];
+        }
+        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";
+        }
+      },
+      _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;
+        return keyFunc;
       }
-    } else if (nextActualValue >= arrayLength) {
-      nextActualValue = step < 0 ? arrayLength - 1 : arrayLength;
+    };
+    function compile(stream) {
+      var parser = new Parser;
+      var ast = parser.parse(stream);
+      return ast;
     }
-    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]);
-      }
+    function tokenize(stream) {
+      var lexer = new Lexer;
+      return lexer.tokenize(stream);
     }
-    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 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);
 });
 
 // ../common/src/output-codecs.ts
 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);
@@ -8026,8 +7503,8 @@ var init_telemetry_service = __esm(() => {
 
 // ../common/src/timings.ts
 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;
@@ -8035,7 +7512,7 @@ function createStorage2() {
       run: (_store, fn) => fn()
     };
   }
-  return new mod2.AsyncLocalStorage;
+  return new mod.AsyncLocalStorage;
 }
 function newState(baseline) {
   return { baseline, httpMs: 0, httpCalls: 0 };
@@ -9169,10 +8646,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));
       });
@@ -13542,8 +13019,8 @@ function createI18nRegistrar(options) {
       if (!target || loaded[target])
         return;
       try {
-        const mod2 = await loadCatalog(target);
-        instance.addResourceBundle(target, namespace, mod2.default, true, true);
+        const mod = await loadCatalog(target);
+        instance.addResourceBundle(target, namespace, mod.default, true, true);
         loaded[target] = true;
       } catch (err) {
         console.warn(`[i18n] Failed to load '${target}' catalog for namespace '${namespace}':`, err);
@@ -13701,7 +13178,7 @@ __export(exports_util, {
   getParsedType: () => getParsedType,
   getSizableOrigin: () => getSizableOrigin,
   hexToUint8Array: () => hexToUint8Array,
-  isObject: () => isObject2,
+  isObject: () => isObject,
   isPlainObject: () => isPlainObject,
   issue: () => issue,
   joinValues: () => joinValues,
@@ -13858,11 +13335,11 @@ function esc(str2) {
 function slugify(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function isObject2(data) {
+function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 function isPlainObject(o) {
-  if (isObject2(o) === false)
+  if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
   if (ctor === undefined)
@@ -13870,7 +13347,7 @@ function isPlainObject(o) {
   if (typeof ctor !== "function")
     return true;
   const prot = ctor.prototype;
-  if (isObject2(prot) === false)
+  if (isObject(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -14364,12 +13841,12 @@ var init_util = __esm(() => {
 function flattenError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = {};
   const formErrors = [];
-  for (const sub2 of error.issues) {
-    if (sub2.path.length > 0) {
-      fieldErrors[sub2.path[0]] = fieldErrors[sub2.path[0]] || [];
-      fieldErrors[sub2.path[0]].push(mapper(sub2));
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
     } else {
-      formErrors.push(mapper(sub2));
+      formErrors.push(mapper(sub));
     }
   }
   return { formErrors, fieldErrors };
@@ -16388,13 +15865,13 @@ var init_schemas = __esm(() => {
       }
       return propValues;
     });
-    const isObject3 = isObject2;
+    const isObject2 = isObject;
     const catchall = def.catchall;
     let value;
     inst._zod.parse = (payload, ctx) => {
       value ?? (value = _normalized.value);
       const input = payload.value;
-      if (!isObject3(input)) {
+      if (!isObject2(input)) {
         payload.issues.push({
           expected: "object",
           code: "invalid_type",
@@ -16521,7 +15998,7 @@ var init_schemas = __esm(() => {
       return (payload, ctx) => fn(shape, payload, ctx);
     };
     let fastpass;
-    const isObject3 = isObject2;
+    const isObject2 = isObject;
     const jit = !globalConfig.jitless;
     const allowsEval2 = allowsEval;
     const fastEnabled = jit && allowsEval2.value;
@@ -16530,7 +16007,7 @@ var init_schemas = __esm(() => {
     inst._zod.parse = (payload, ctx) => {
       value ?? (value = _normalized.value);
       const input = payload.value;
-      if (!isObject3(input)) {
+      if (!isObject2(input)) {
         payload.issues.push({
           expected: "object",
           code: "invalid_type",
@@ -16662,7 +16139,7 @@ var init_schemas = __esm(() => {
     });
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isObject2(input)) {
+      if (!isObject(input)) {
         payload.issues.push({
           code: "invalid_type",
           expected: "object",
@@ -28388,7 +27865,7 @@ var require_scope = __commonJS(function(exports) {
     var: new code_1.Name("var")
   };
 
-  class Scope2 {
+  class Scope {
     constructor({ prefixes, parent } = {}) {
       this._names = {};
       this._prefixes = prefixes;
@@ -28412,7 +27889,7 @@ var require_scope = __commonJS(function(exports) {
       return this._names[prefix] = { prefix, index: 0 };
     }
   }
-  exports.Scope = Scope2;
+  exports.Scope = Scope;
 
   class ValueScopeName extends code_1.Name {
     constructor(prefix, nameStr) {
@@ -28427,7 +27904,7 @@ var require_scope = __commonJS(function(exports) {
   exports.ValueScopeName = ValueScopeName;
   var line = (0, code_1._)`\n`;
 
-  class ValueScope extends Scope2 {
+  class ValueScope extends Scope {
     constructor(opts) {
       super(opts);
       this._values = {};
@@ -37696,7 +37173,7 @@ __export(exports_util2, {
   getLengthableOrigin: () => getLengthableOrigin2,
   getParsedType: () => getParsedType2,
   getSizableOrigin: () => getSizableOrigin2,
-  isObject: () => isObject3,
+  isObject: () => isObject2,
   isPlainObject: () => isPlainObject2,
   issue: () => issue2,
   joinValues: () => joinValues2,
@@ -37825,17 +37302,17 @@ function randomString2(length = 10) {
 function esc2(str2) {
   return JSON.stringify(str2);
 }
-function isObject3(data) {
+function isObject2(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 function isPlainObject2(o) {
-  if (isObject3(o) === false)
+  if (isObject2(o) === false)
     return false;
   const ctor = o.constructor;
   if (ctor === undefined)
     return true;
   const prot = ctor.prototype;
-  if (isObject3(prot) === false)
+  if (isObject2(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -38185,12 +37662,12 @@ var init_util2 = __esm(() => {
 function flattenError2(error51, mapper = (issue3) => issue3.message) {
   const fieldErrors = {};
   const formErrors = [];
-  for (const sub2 of error51.issues) {
-    if (sub2.path.length > 0) {
-      fieldErrors[sub2.path[0]] = fieldErrors[sub2.path[0]] || [];
-      fieldErrors[sub2.path[0]].push(mapper(sub2));
+  for (const sub of error51.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
     } else {
-      formErrors.push(mapper(sub2));
+      formErrors.push(mapper(sub));
     }
   }
   return { formErrors, fieldErrors };
@@ -39982,7 +39459,7 @@ var init_schemas3 = __esm(() => {
       return (payload, ctx) => fn(shape, payload, ctx);
     };
     let fastpass;
-    const isObject4 = isObject3;
+    const isObject3 = isObject2;
     const jit = !globalConfig2.jitless;
     const allowsEval3 = allowsEval2;
     const fastEnabled = jit && allowsEval3.value;
@@ -39991,7 +39468,7 @@ var init_schemas3 = __esm(() => {
     inst._zod.parse = (payload, ctx) => {
       value ?? (value = _normalized.value);
       const input = payload.value;
-      if (!isObject4(input)) {
+      if (!isObject3(input)) {
         payload.issues.push({
           expected: "object",
           code: "invalid_type",
@@ -40135,7 +39612,7 @@ var init_schemas3 = __esm(() => {
     });
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isObject3(input)) {
+      if (!isObject2(input)) {
         payload.issues.push({
           code: "invalid_type",
           expected: "object",
@@ -50545,15 +50022,15 @@ var require_subset = __commonJS(function(exports, module) {
   var { ANY } = Comparator;
   var satisfies = require_satisfies();
   var compare = require_compare();
-  var subset = (sub2, dom, options = {}) => {
-    if (sub2 === dom) {
+  var subset = (sub, dom, options = {}) => {
+    if (sub === dom) {
       return true;
     }
-    sub2 = new Range(sub2, options);
+    sub = new Range(sub, options);
     dom = new Range(dom, options);
     let sawNonNull = false;
     OUTER:
-      for (const simpleSub of sub2.set) {
+      for (const simpleSub of sub.set) {
         for (const simpleDom of dom.set) {
           const isSub = simpleSubset(simpleSub, simpleDom, options);
           sawNonNull = sawNonNull || isSub !== null;
@@ -50569,17 +50046,17 @@ var require_subset = __commonJS(function(exports, module) {
   };
   var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
   var minimumVersion = [new Comparator(">=0.0.0")];
-  var simpleSubset = (sub2, dom, options) => {
-    if (sub2 === dom) {
+  var simpleSubset = (sub, dom, options) => {
+    if (sub === dom) {
       return true;
     }
-    if (sub2.length === 1 && sub2[0].semver === ANY) {
+    if (sub.length === 1 && sub[0].semver === ANY) {
       if (dom.length === 1 && dom[0].semver === ANY) {
         return true;
       } else if (options.includePrerelease) {
-        sub2 = minimumVersionWithPreRelease;
+        sub = minimumVersionWithPreRelease;
       } else {
-        sub2 = minimumVersion;
+        sub = minimumVersion;
       }
     }
     if (dom.length === 1 && dom[0].semver === ANY) {
@@ -50591,7 +50068,7 @@ var require_subset = __commonJS(function(exports, module) {
     }
     const eqSet = new Set;
     let gt, lt;
-    for (const c of sub2) {
+    for (const c of sub) {
       if (c.operator === ">" || c.operator === ">=") {
         gt = higherGT(gt, c, options);
       } else if (c.operator === "<" || c.operator === "<=") {
@@ -50626,7 +50103,7 @@ var require_subset = __commonJS(function(exports, module) {
       }
       return true;
     }
-    let higher, lower2;
+    let higher, lower;
     let hasDomLT, hasDomGT;
     let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
     let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
@@ -50658,8 +50135,8 @@ var require_subset = __commonJS(function(exports, module) {
           }
         }
         if (c.operator === "<" || c.operator === "<=") {
-          lower2 = lowerLT(lt, c, options);
-          if (lower2 === c && lower2 !== lt) {
+          lower = lowerLT(lt, c, options);
+          if (lower === c && lower !== lt) {
             return false;
           }
         } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
@@ -50999,7 +50476,7 @@ var import_semver, createStorageSchema = (factory) => {
   ...context,
   contextType: context.contextType ?? (context.attachments ? "attachments" : "index")
 }), v48, migrationV48, version24 = "49.0.0", lowCodeAgentSchemaV49, codedAgentSchemaV49, agentStorageSchemaV49, storageSchemaV49, v49, migrationV49, version25 = "50.0.0", LATEST_AGENT_VERSION = "1.2.0", AGENT365_GOVERNANCE_PROVIDER_NAMESPACE = "agent.governance_providers.agents365", Agent365Attributes, RECIPIENT_TYPE3, escalationRecipientsV50, hitlSchemaFieldRuleV50, hitlSchemaFieldV50, hitlSchemaOutcomeV50, hitlSchemaV50, actionableMessageMetaDataV50, channelQuickFormPropertiesV50, escalationChannelActionCenterSchemaV50, escalationChannelActionCenterQuickFormSchemaV50, escalationStorageSchemaV50, baseLowCodeSettingsSchema, _v49ProcessToolSchema, flowToolStorageSchemaV50, functionToolStorageSchemaV50, TURN_DETECTION_MAX_MS = 5000, turnDetectionSchemaV50, voiceSettingsExtension, standardLowCodeAgentSettingsV50, advancedLowCodeAgentSettingsV50, lowCodeAgentSettingsV50, agent365ValuesSchemaV50, lowCodeAgentSchemaV50, codedAgentSchemaV50, agentStorageSchemaV50, clientSideToolStorageSchemaV50, toolStorageSchemaV50, discoveryModeSchemaV50, mcpToolStorageSchemaV50, dataFabricOntologyContextSchemaV50, contextStorageSchemaV50, resourceStorageSchemaV50, resourcesFolderSchemaV50, storageSchemaV50, v50, migrationV50, currentStorageSchemaMigration, currentStorageSchema, currentAgentStorageSchema, currentResourceStorageSchema, currentFeatureStorageSchema, currentEvaluationSetStorageSchema, currentCodedAgentStorageSchema, currentFlowLayoutStorageSchema;
-var init_dist2 = __esm(() => {
+var init_dist = __esm(() => {
   init_v4();
   import_semver = __toESM(require_semver2(), 1);
   jsonSchemaTypeSchema = exports_external2.enum([
@@ -61785,7 +61262,7 @@ var init_chunk_E6I5CCCH = __esm(() => {
   init_i18next();
   init_i18next();
   init_i18next();
-  init_dist2();
+  init_dist();
   init_i18next();
   init_i18next();
   init_jsep();
@@ -62787,7 +62264,7 @@ var import_object, workflowRuntimeSchema, argumentBindingSchema, workflowVariabl
   },
   required: ["name", "value"]
 }), HTTP_REQUEST_SCHEMA;
-var init_dist3 = __esm(() => {
+var init_dist2 = __esm(() => {
   init_chunk_E6I5CCCH();
   init_zod();
   init_zod();
@@ -86090,11 +85567,11 @@ var require__Symbol = __commonJS(function(exports, module) {
 var require__getRawTag = __commonJS(function(exports, module) {
   var Symbol2 = require__Symbol();
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   var nativeObjectToString = objectProto.toString;
   var symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined;
   function getRawTag(value) {
-    var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+    var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
     try {
       value[symToStringTag] = undefined;
       var unmasked = true;
@@ -86141,23 +85618,23 @@ var require__baseGetTag = __commonJS(function(exports, module) {
 
 // ../../node_modules/lodash/isObject.js
 var require_isObject = __commonJS(function(exports, module) {
-  function isObject4(value) {
+  function isObject3(value) {
     var type2 = typeof value;
     return value != null && (type2 == "object" || type2 == "function");
   }
-  module.exports = isObject4;
+  module.exports = isObject3;
 });
 
 // ../../node_modules/lodash/isFunction.js
 var require_isFunction = __commonJS(function(exports, module) {
   var baseGetTag = require__baseGetTag();
-  var isObject4 = require_isObject();
+  var isObject3 = require_isObject();
   var asyncTag = "[object AsyncFunction]";
   var funcTag = "[object Function]";
   var genTag = "[object GeneratorFunction]";
   var proxyTag = "[object Proxy]";
   function isFunction(value) {
-    if (!isObject4(value)) {
+    if (!isObject3(value)) {
       return false;
     }
     var tag = baseGetTag(value);
@@ -86208,17 +85685,17 @@ var require__toSource = __commonJS(function(exports, module) {
 var require__baseIsNative = __commonJS(function(exports, module) {
   var isFunction = require_isFunction();
   var isMasked = require__isMasked();
-  var isObject4 = require_isObject();
+  var isObject3 = require_isObject();
   var toSource = require__toSource();
   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
   var reIsHostCtor = /^\[object .+?Constructor\]$/;
   var funcProto = Function.prototype;
   var objectProto = Object.prototype;
   var funcToString = funcProto.toString;
-  var hasOwnProperty = objectProto.hasOwnProperty;
-  var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
+  var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
   function baseIsNative(value) {
-    if (!isObject4(value) || isMasked(value)) {
+    if (!isObject3(value) || isMasked(value)) {
       return false;
     }
     var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
@@ -86286,14 +85763,14 @@ var require__hashGet = __commonJS(function(exports, module) {
   var nativeCreate = require__nativeCreate();
   var HASH_UNDEFINED = "__lodash_hash_undefined__";
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function hashGet(key) {
     var data = this.__data__;
     if (nativeCreate) {
       var result = data[key];
       return result === HASH_UNDEFINED ? undefined : result;
     }
-    return hasOwnProperty.call(data, key) ? data[key] : undefined;
+    return hasOwnProperty2.call(data, key) ? data[key] : undefined;
   }
   module.exports = hashGet;
 });
@@ -86302,10 +85779,10 @@ var require__hashGet = __commonJS(function(exports, module) {
 var require__hashHas = __commonJS(function(exports, module) {
   var nativeCreate = require__nativeCreate();
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function hashHas(key) {
     var data = this.__data__;
-    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+    return nativeCreate ? data[key] !== undefined : hasOwnProperty2.call(data, key);
   }
   module.exports = hashHas;
 });
@@ -86809,12 +86286,12 @@ var require_isArguments = __commonJS(function(exports, module) {
   var baseIsArguments = require__baseIsArguments();
   var isObjectLike = require_isObjectLike();
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   var propertyIsEnumerable = objectProto.propertyIsEnumerable;
   var isArguments = baseIsArguments(function() {
     return arguments;
   }()) ? baseIsArguments : function(value) {
-    return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
   };
   module.exports = isArguments;
 });
@@ -86947,11 +86424,11 @@ var require__arrayLikeKeys = __commonJS(function(exports, module) {
   var isIndex = require__isIndex();
   var isTypedArray = require_isTypedArray();
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function arrayLikeKeys(value, inherited) {
     var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
     for (var key in value) {
-      if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
+      if ((inherited || hasOwnProperty2.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
         result.push(key);
       }
     }
@@ -86992,14 +86469,14 @@ var require__baseKeys = __commonJS(function(exports, module) {
   var isPrototype = require__isPrototype();
   var nativeKeys = require__nativeKeys();
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function baseKeys(object3) {
     if (!isPrototype(object3)) {
       return nativeKeys(object3);
     }
     var result = [];
     for (var key in Object(object3)) {
-      if (hasOwnProperty.call(object3, key) && key != "constructor") {
+      if (hasOwnProperty2.call(object3, key) && key != "constructor") {
         result.push(key);
       }
     }
@@ -87045,7 +86522,7 @@ var require__equalObjects = __commonJS(function(exports, module) {
   var getAllKeys = require__getAllKeys();
   var COMPARE_PARTIAL_FLAG = 1;
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function equalObjects(object3, other, bitmask, customizer, equalFunc, stack) {
     var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object3), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
     if (objLength != othLength && !isPartial) {
@@ -87054,7 +86531,7 @@ var require__equalObjects = __commonJS(function(exports, module) {
     var index = objLength;
     while (index--) {
       var key = objProps[index];
-      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+      if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
         return false;
       }
     }
@@ -87183,7 +86660,7 @@ var require__baseIsEqualDeep = __commonJS(function(exports, module) {
   var arrayTag = "[object Array]";
   var objectTag = "[object Object]";
   var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
   function baseIsEqualDeep(object3, other, bitmask, customizer, equalFunc, stack) {
     var objIsArr = isArray(object3), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object3), othTag = othIsArr ? arrayTag : getTag(other);
     objTag = objTag == argsTag ? objectTag : objTag;
@@ -87201,7 +86678,7 @@ var require__baseIsEqualDeep = __commonJS(function(exports, module) {
       return objIsArr || isTypedArray(object3) ? equalArrays(object3, other, bitmask, customizer, equalFunc, stack) : equalByTag(object3, other, objTag, bitmask, customizer, equalFunc, stack);
     }
     if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
-      var objIsWrapped = objIsObj && hasOwnProperty.call(object3, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+      var objIsWrapped = objIsObj && hasOwnProperty2.call(object3, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
       if (objIsWrapped || othIsWrapped) {
         var objUnwrapped = objIsWrapped ? object3.value() : object3, othUnwrapped = othIsWrapped ? other.value() : other;
         stack || (stack = new Stack);
@@ -89824,247 +89301,247 @@ var init_manifest = __esm(() => {
   init_i18next();
   init_i18next();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
-  init_dist3();
+  init_dist2();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_i18next();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_i18next();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
-  init_dist3();
+  init_dist2();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_zod();
-  init_dist3();
+  init_dist2();
   init_i18next();
-  init_dist3();
+  init_dist2();
   init_i18next();
   init_i18next();
   init_i18next();
-  init_dist3();
-  init_dist3();
+  init_dist2();
+  init_dist2();
   import_isEqual = __toESM(require_isEqual(), 1);
   fixedT = instance.getFixedT(null, MANIFEST_NAMESPACE);
   ERROR_OUTPUT_DEFINITION = {
@@ -123944,8 +123421,8 @@ function isAuthProfileStorage(value) {
   return value !== null && typeof value === "object" && "getStore" in value && "run" in value;
 }
 function createProfileStorage() {
-  const [error90, mod2] = catchError2(() => __require("node:async_hooks"));
-  if (error90 || typeof mod2?.AsyncLocalStorage !== "function") {
+  const [error90, mod] = catchError2(() => __require("node:async_hooks"));
+  if (error90 || typeof mod?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
         return;
@@ -123953,7 +123430,7 @@ function createProfileStorage() {
       run: (_store, fn) => fn()
     };
   }
-  return new mod2.AsyncLocalStorage;
+  return new mod.AsyncLocalStorage;
 }
 function getProfileStorage() {
   const existing = globalSlot2[AUTH_PROFILE_STORAGE_KEY];
@@ -124332,11 +123809,11 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, ROBOT_USER_SERVICES_PIPE
   if (!hostLoader) {
     return;
   }
-  const [error90, mod2] = await catchError2(() => hostLoader());
-  if (error90 || !mod2) {
+  const [error90, mod] = await catchError2(() => hostLoader());
+  if (error90 || !mod) {
     return;
   }
-  return mod2;
+  return mod;
 }, tryRobotClientFallback = async (options = {}) => {
   if (isBrowser())
     return;
@@ -124354,10 +123831,10 @@ var DEFAULT_TIMEOUT_MS = 1000, CLOSE_TIMEOUT_MS = 500, ROBOT_USER_SERVICES_PIPE
   if (!await isRobotIpcAvailable()) {
     return;
   }
-  const mod2 = await loadModule();
-  if (!mod2)
+  const mod = await loadModule();
+  if (!mod)
     return;
-  const [ctorError, proxy] = catchError2(() => new mod2.RobotProxyConstructor);
+  const [ctorError, proxy] = catchError2(() => new mod.RobotProxyConstructor);
   if (ctorError || !proxy) {
     return;
   }
@@ -125857,8 +125334,8 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@uipath/integrationservice-sdk",
-    license: "MIT",
-    version: "1.202.0-preview.142",
+    license: "SEE LICENSE IN LICENSE.txt",
+    version: "1.202.0",
     repository: {
       type: "git",
       url: "https://github.com/UiPath/cli.git",
@@ -137661,15 +137138,15 @@ var require_fromEvent = __commonJS(function(exports) {
       return function(handler) {
         return target[methodName](eventName, handler, options);
       };
-    }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add2 = _a3[0], remove = _a3[1];
-    if (!add2) {
+    }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add = _a3[0], remove = _a3[1];
+    if (!add) {
       if (isArrayLike_1.isArrayLike(target)) {
         return mergeMap_1.mergeMap(function(subTarget) {
           return fromEvent(subTarget, eventName, options);
         })(innerFrom_1.innerFrom(target));
       }
     }
-    if (!add2) {
+    if (!add) {
       throw new TypeError("Invalid event target");
     }
     return new Observable_1.Observable(function(subscriber) {
@@ -137680,7 +137157,7 @@ var require_fromEvent = __commonJS(function(exports) {
         }
         return subscriber.next(1 < args.length ? args : args[0]);
       };
-      add2(handler);
+      add(handler);
       return function() {
         return remove(handler);
       };
@@ -142921,7 +142398,7 @@ var init__Symbol = __esm(() => {
 
 // ../../node_modules/lodash-es/_getRawTag.js
 function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
   try {
     value[symToStringTag] = undefined;
     var unmasked = true;
@@ -142936,11 +142413,11 @@ function getRawTag(value) {
   }
   return result;
 }
-var objectProto, hasOwnProperty, nativeObjectToString, symToStringTag, _getRawTag_default;
+var objectProto, hasOwnProperty2, nativeObjectToString, symToStringTag, _getRawTag_default;
 var init__getRawTag = __esm(() => {
   init__Symbol();
   objectProto = Object.prototype;
-  hasOwnProperty = objectProto.hasOwnProperty;
+  hasOwnProperty2 = objectProto.hasOwnProperty;
   nativeObjectToString = objectProto.toString;
   symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
   _getRawTag_default = getRawTag;
@@ -142974,13 +142451,13 @@ var init__baseGetTag = __esm(() => {
 });
 
 // ../../node_modules/lodash-es/isObject.js
-function isObject4(value) {
+function isObject3(value) {
   var type2 = typeof value;
   return value != null && (type2 == "object" || type2 == "function");
 }
 var isObject_default;
 var init_isObject = __esm(() => {
-  isObject_default = isObject4;
+  isObject_default = isObject3;
 });
 
 // ../../node_modules/lodash-es/isFunction.js
@@ -143047,7 +142524,7 @@ function baseIsNative(value) {
   var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
   return pattern.test(_toSource_default(value));
 }
-var reRegExpChar, reIsHostCtor, funcProto2, objectProto3, funcToString2, hasOwnProperty2, reIsNative, _baseIsNative_default;
+var reRegExpChar, reIsHostCtor, funcProto2, objectProto3, funcToString2, hasOwnProperty3, reIsNative, _baseIsNative_default;
 var init__baseIsNative = __esm(() => {
   init_isFunction();
   init__isMasked();
@@ -143058,8 +142535,8 @@ var init__baseIsNative = __esm(() => {
   funcProto2 = Function.prototype;
   objectProto3 = Object.prototype;
   funcToString2 = funcProto2.toString;
-  hasOwnProperty2 = objectProto3.hasOwnProperty;
-  reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+  hasOwnProperty3 = objectProto3.hasOwnProperty;
+  reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty3).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
   _baseIsNative_default = baseIsNative;
 });
 
@@ -143121,26 +142598,26 @@ function hashGet(key) {
     var result = data[key];
     return result === HASH_UNDEFINED ? undefined : result;
   }
-  return hasOwnProperty3.call(data, key) ? data[key] : undefined;
+  return hasOwnProperty4.call(data, key) ? data[key] : undefined;
 }
-var HASH_UNDEFINED = "__lodash_hash_undefined__", objectProto4, hasOwnProperty3, _hashGet_default;
+var HASH_UNDEFINED = "__lodash_hash_undefined__", objectProto4, hasOwnProperty4, _hashGet_default;
 var init__hashGet = __esm(() => {
   init__nativeCreate();
   objectProto4 = Object.prototype;
-  hasOwnProperty3 = objectProto4.hasOwnProperty;
+  hasOwnProperty4 = objectProto4.hasOwnProperty;
   _hashGet_default = hashGet;
 });
 
 // ../../node_modules/lodash-es/_hashHas.js
 function hashHas(key) {
   var data = this.__data__;
-  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
+  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty5.call(data, key);
 }
-var objectProto5, hasOwnProperty4, _hashHas_default;
+var objectProto5, hasOwnProperty5, _hashHas_default;
 var init__hashHas = __esm(() => {
   init__nativeCreate();
   objectProto5 = Object.prototype;
-  hasOwnProperty4 = objectProto5.hasOwnProperty;
+  hasOwnProperty5 = objectProto5.hasOwnProperty;
   _hashHas_default = hashHas;
 });
 
@@ -143644,17 +143121,17 @@ var init__baseIsArguments = __esm(() => {
 });
 
 // ../../node_modules/lodash-es/isArguments.js
-var objectProto6, hasOwnProperty5, propertyIsEnumerable, isArguments, isArguments_default;
+var objectProto6, hasOwnProperty6, propertyIsEnumerable, isArguments, isArguments_default;
 var init_isArguments = __esm(() => {
   init__baseIsArguments();
   init_isObjectLike();
   objectProto6 = Object.prototype;
-  hasOwnProperty5 = objectProto6.hasOwnProperty;
+  hasOwnProperty6 = objectProto6.hasOwnProperty;
   propertyIsEnumerable = objectProto6.propertyIsEnumerable;
   isArguments = _baseIsArguments_default(function() {
     return arguments;
   }()) ? _baseIsArguments_default : function(value) {
-    return isObjectLike_default(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    return isObjectLike_default(value) && hasOwnProperty6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
   };
   isArguments_default = isArguments;
 });
@@ -144290,13 +143767,13 @@ var init_isTypedArray = __esm(() => {
 function arrayLikeKeys(value, inherited) {
   var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes_default(value.length, String) : [], length = result.length;
   for (var key in value) {
-    if ((inherited || hasOwnProperty6.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) {
+    if ((inherited || hasOwnProperty7.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) {
       result.push(key);
     }
   }
   return result;
 }
-var objectProto7, hasOwnProperty6, _arrayLikeKeys_default;
+var objectProto7, hasOwnProperty7, _arrayLikeKeys_default;
 var init__arrayLikeKeys = __esm(() => {
   init__baseTimes();
   init_isArguments();
@@ -144305,7 +143782,7 @@ var init__arrayLikeKeys = __esm(() => {
   init__isIndex();
   init_isTypedArray();
   objectProto7 = Object.prototype;
-  hasOwnProperty6 = objectProto7.hasOwnProperty;
+  hasOwnProperty7 = objectProto7.hasOwnProperty;
   _arrayLikeKeys_default = arrayLikeKeys;
 });
 
@@ -144346,18 +143823,18 @@ function baseKeys(object3) {
   }
   var result = [];
   for (var key in Object(object3)) {
-    if (hasOwnProperty7.call(object3, key) && key != "constructor") {
+    if (hasOwnProperty8.call(object3, key) && key != "constructor") {
       result.push(key);
     }
   }
   return result;
 }
-var objectProto9, hasOwnProperty7, _baseKeys_default;
+var objectProto9, hasOwnProperty8, _baseKeys_default;
 var init__baseKeys = __esm(() => {
   init__isPrototype();
   init__nativeKeys();
   objectProto9 = Object.prototype;
-  hasOwnProperty7 = objectProto9.hasOwnProperty;
+  hasOwnProperty8 = objectProto9.hasOwnProperty;
   _baseKeys_default = baseKeys;
 });
 
@@ -144754,7 +144231,7 @@ function equalObjects(object3, other, bitmask, customizer, equalFunc, stack) {
   var index = objLength;
   while (index--) {
     var key = objProps[index];
-    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
+    if (!(isPartial ? key in other : hasOwnProperty9.call(other, key))) {
       return false;
     }
   }
@@ -144789,11 +144266,11 @@ function equalObjects(object3, other, bitmask, customizer, equalFunc, stack) {
   stack["delete"](other);
   return result;
 }
-var COMPARE_PARTIAL_FLAG3 = 1, objectProto11, hasOwnProperty8, _equalObjects_default;
+var COMPARE_PARTIAL_FLAG3 = 1, objectProto11, hasOwnProperty9, _equalObjects_default;
 var init__equalObjects = __esm(() => {
   init__getAllKeys();
   objectProto11 = Object.prototype;
-  hasOwnProperty8 = objectProto11.hasOwnProperty;
+  hasOwnProperty9 = objectProto11.hasOwnProperty;
   _equalObjects_default = equalObjects;
 });
 
@@ -144890,7 +144367,7 @@ function baseIsEqualDeep(object3, other, bitmask, customizer, equalFunc, stack)
     return objIsArr || isTypedArray_default(object3) ? _equalArrays_default(object3, other, bitmask, customizer, equalFunc, stack) : _equalByTag_default(object3, other, objTag, bitmask, customizer, equalFunc, stack);
   }
   if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
-    var objIsWrapped = objIsObj && hasOwnProperty9.call(object3, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    var objIsWrapped = objIsObj && hasOwnProperty10.call(object3, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty10.call(other, "__wrapped__");
     if (objIsWrapped || othIsWrapped) {
       var objUnwrapped = objIsWrapped ? object3.value() : object3, othUnwrapped = othIsWrapped ? other.value() : other;
       stack || (stack = new _Stack_default);
@@ -144903,7 +144380,7 @@ function baseIsEqualDeep(object3, other, bitmask, customizer, equalFunc, stack)
   stack || (stack = new _Stack_default);
   return _equalObjects_default(object3, other, bitmask, customizer, equalFunc, stack);
 }
-var COMPARE_PARTIAL_FLAG4 = 1, argsTag3 = "[object Arguments]", arrayTag2 = "[object Array]", objectTag3 = "[object Object]", objectProto12, hasOwnProperty9, _baseIsEqualDeep_default;
+var COMPARE_PARTIAL_FLAG4 = 1, argsTag3 = "[object Arguments]", arrayTag2 = "[object Array]", objectTag3 = "[object Object]", objectProto12, hasOwnProperty10, _baseIsEqualDeep_default;
 var init__baseIsEqualDeep = __esm(() => {
   init__Stack();
   init__equalArrays();
@@ -144914,7 +144391,7 @@ var init__baseIsEqualDeep = __esm(() => {
   init_isBuffer();
   init_isTypedArray();
   objectProto12 = Object.prototype;
-  hasOwnProperty9 = objectProto12.hasOwnProperty;
+  hasOwnProperty10 = objectProto12.hasOwnProperty;
   _baseIsEqualDeep_default = baseIsEqualDeep;
 });
 
@@ -145178,14 +144655,14 @@ var init__createAggregator = __esm(() => {
 });
 
 // ../../node_modules/lodash-es/groupBy.js
-var objectProto13, hasOwnProperty10, groupBy, groupBy_default;
+var objectProto13, hasOwnProperty11, groupBy, groupBy_default;
 var init_groupBy = __esm(() => {
   init__baseAssignValue();
   init__createAggregator();
   objectProto13 = Object.prototype;
-  hasOwnProperty10 = objectProto13.hasOwnProperty;
+  hasOwnProperty11 = objectProto13.hasOwnProperty;
   groupBy = _createAggregator_default(function(result, value, key) {
-    if (hasOwnProperty10.call(result, key)) {
+    if (hasOwnProperty11.call(result, key)) {
       result[key].push(value);
     } else {
       _baseAssignValue_default(result, key, [value]);
@@ -145326,13 +144803,13 @@ var init_orderBy = __esm(() => {
 });
 
 // ../../node_modules/lodash-es/_baseClamp.js
-function baseClamp(number7, lower2, upper2) {
+function baseClamp(number7, lower, upper) {
   if (number7 === number7) {
-    if (upper2 !== undefined) {
-      number7 = number7 <= upper2 ? number7 : upper2;
+    if (upper !== undefined) {
+      number7 = number7 <= upper ? number7 : upper;
     }
-    if (lower2 !== undefined) {
-      number7 = number7 >= lower2 ? number7 : lower2;
+    if (lower !== undefined) {
+      number7 = number7 >= lower ? number7 : lower;
     }
   }
   return number7;
@@ -145555,7 +145032,7 @@ var init__stringToArray = __esm(() => {
 });
 
 // ../../node_modules/lodash-es/trim.js
-function trim2(string7, chars2, guard) {
+function trim(string7, chars2, guard) {
   string7 = toString_default(string7);
   if (string7 && (guard || chars2 === undefined)) {
     return _baseTrim_default(string7);
@@ -145575,7 +145052,7 @@ var init_trim = __esm(() => {
   init__charsStartIndex();
   init__stringToArray();
   init_toString();
-  trim_default = trim2;
+  trim_default = trim;
 });
 
 // ../../node_modules/lodash-es/trimEnd.js
@@ -146557,7 +146034,7 @@ function pick3(obj, keys2) {
     return a;
   }, {});
 }
-function hasOwnProperty11(obj, prop) {
+function hasOwnProperty12(obj, prop) {
   return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 function validateWeekSettings(settings) {
@@ -146701,7 +146178,7 @@ function asNumber(value) {
 function normalizeObject(obj, normalizer) {
   const normalized = {};
   for (const u in obj) {
-    if (hasOwnProperty11(obj, u)) {
+    if (hasOwnProperty12(obj, u)) {
       const v = obj[u];
       if (v === undefined || v === null)
         continue;
@@ -147592,7 +147069,7 @@ function match(input, regex, handlers) {
     const all = {};
     let matchIndex = 1;
     for (const i in handlers) {
-      if (hasOwnProperty11(handlers, i)) {
+      if (hasOwnProperty12(handlers, i)) {
         const h = handlers[i], groups = h.groups ? h.groups + 1 : 1;
         if (!h.literal && h.token) {
           all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups));
@@ -147696,7 +147173,7 @@ function expandMacroTokens(tokens, locale) {
   return Array.prototype.concat(...tokens.map((t14) => maybeExpandMacroToken(t14, locale)));
 }
 
-class TokenParser2 {
+class TokenParser {
   constructor(locale, format) {
     this.locale = locale;
     this.format = format;
@@ -147714,7 +147191,7 @@ class TokenParser2 {
       return { input, tokens: this.tokens, invalidReason: this.invalidReason };
     } else {
       const [rawMatches, matches] = match(input, this.regex, this.handlers), [result, zone, specificOffset] = matches ? dateTimeFromMatches(matches) : [null, null, undefined];
-      if (hasOwnProperty11(matches, "a") && hasOwnProperty11(matches, "H")) {
+      if (hasOwnProperty12(matches, "a") && hasOwnProperty12(matches, "H")) {
         throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
       }
       return {
@@ -147737,7 +147214,7 @@ class TokenParser2 {
   }
 }
 function explainFromTokens(locale, input, format) {
-  const parser = new TokenParser2(locale, format);
+  const parser = new TokenParser(locale, format);
   return parser.explainFromTokens(input);
 }
 function parseFromTokens(locale, input, format) {
@@ -148900,7 +148377,7 @@ var init_luxon = __esm(() => {
         return this;
       const dur = Duration.fromDurationLike(duration5), result = {};
       for (const k of orderedUnits$1) {
-        if (hasOwnProperty11(dur.values, k) || hasOwnProperty11(this.values, k)) {
+        if (hasOwnProperty12(dur.values, k) || hasOwnProperty12(this.values, k)) {
           result[k] = dur.get(k) + this.get(k);
         }
       }
@@ -150108,7 +149585,7 @@ var init_luxon = __esm(() => {
         numberingSystem,
         defaultToEN: true
       });
-      return new TokenParser2(localeToUse, fmt);
+      return new TokenParser(localeToUse, fmt);
     }
     static fromFormatParser(text, formatParser, opts = {}) {
       if (isUndefined(text) || isUndefined(formatParser)) {
@@ -151774,15 +151251,15 @@ var require_subset2 = __commonJS(function(exports, module) {
   var { ANY } = Comparator;
   var satisfies = require_satisfies2();
   var compare = require_compare2();
-  var subset = (sub2, dom, options = {}) => {
-    if (sub2 === dom) {
+  var subset = (sub, dom, options = {}) => {
+    if (sub === dom) {
       return true;
     }
-    sub2 = new Range(sub2, options);
+    sub = new Range(sub, options);
     dom = new Range(dom, options);
     let sawNonNull = false;
     OUTER:
-      for (const simpleSub of sub2.set) {
+      for (const simpleSub of sub.set) {
         for (const simpleDom of dom.set) {
           const isSub = simpleSubset(simpleSub, simpleDom, options);
           sawNonNull = sawNonNull || isSub !== null;
@@ -151798,17 +151275,17 @@ var require_subset2 = __commonJS(function(exports, module) {
   };
   var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
   var minimumVersion = [new Comparator(">=0.0.0")];
-  var simpleSubset = (sub2, dom, options) => {
-    if (sub2 === dom) {
+  var simpleSubset = (sub, dom, options) => {
+    if (sub === dom) {
       return true;
     }
-    if (sub2.length === 1 && sub2[0].semver === ANY) {
+    if (sub.length === 1 && sub[0].semver === ANY) {
       if (dom.length === 1 && dom[0].semver === ANY) {
         return true;
       } else if (options.includePrerelease) {
-        sub2 = minimumVersionWithPreRelease;
+        sub = minimumVersionWithPreRelease;
       } else {
-        sub2 = minimumVersion;
+        sub = minimumVersion;
       }
     }
     if (dom.length === 1 && dom[0].semver === ANY) {
@@ -151820,7 +151297,7 @@ var require_subset2 = __commonJS(function(exports, module) {
     }
     const eqSet = new Set;
     let gt, lt2;
-    for (const c of sub2) {
+    for (const c of sub) {
       if (c.operator === ">" || c.operator === ">=") {
         gt = higherGT(gt, c, options);
       } else if (c.operator === "<" || c.operator === "<=") {
@@ -151855,7 +151332,7 @@ var require_subset2 = __commonJS(function(exports, module) {
       }
       return true;
     }
-    let higher, lower2;
+    let higher, lower;
     let hasDomLT, hasDomGT;
     let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
     let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
@@ -151887,8 +151364,8 @@ var require_subset2 = __commonJS(function(exports, module) {
           }
         }
         if (c.operator === "<" || c.operator === "<=") {
-          lower2 = lowerLT(lt2, c, options);
-          if (lower2 === c && lower2 !== lt2) {
+          lower = lowerLT(lt2, c, options);
+          if (lower === c && lower !== lt2) {
             return false;
           }
         } else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c), options)) {
@@ -159874,8 +159351,8 @@ classDef hidden display: none;`;
 });
 
 // ../../node_modules/@uipath/integration-service-design-time/dist/index.mjs
-var exports_dist2 = {};
-__export(exports_dist2, {
+var exports_dist = {};
+__export(exports_dist, {
   DesignTimeActivityClient: () => DesignTimeActivityClient2
 });
 function widgetOperandKeyString(parentPropertyName, rowId, operandPosition) {
@@ -160239,11 +159716,11 @@ function esc3(str2) {
 function slugify2(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function isObject5(data) {
+function isObject4(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 function isPlainObject3(o) {
-  if (isObject5(o) === false)
+  if (isObject4(o) === false)
     return false;
   const ctor = o.constructor;
   if (ctor === undefined)
@@ -160251,7 +159728,7 @@ function isPlainObject3(o) {
   if (typeof ctor !== "function")
     return true;
   const prot = ctor.prototype;
-  if (isObject5(prot) === false)
+  if (isObject4(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -160603,12 +160080,12 @@ function uint8ArrayToHex2(bytes) {
 function flattenError3(error462, mapper = (issue22) => issue22.message) {
   const fieldErrors = {};
   const formErrors = [];
-  for (const sub2 of error462.issues) {
-    if (sub2.path.length > 0) {
-      fieldErrors[sub2.path[0]] = fieldErrors[sub2.path[0]] || [];
-      fieldErrors[sub2.path[0]].push(mapper(sub2));
+  for (const sub of error462.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
     } else {
-      formErrors.push(mapper(sub2));
+      formErrors.push(mapper(sub));
     }
   }
   return { formErrors, fieldErrors };
@@ -177798,7 +177275,7 @@ ${this._errorMessage}`;
     };
   }
 }, DesignTimeActivityClient2;
-var init_dist4 = __esm(() => {
+var init_dist3 = __esm(() => {
   init_lodash();
   init_luxon();
   init_lodash();
@@ -178961,7 +178438,7 @@ var init_dist4 = __esm(() => {
     getParsedType: () => getParsedType3,
     getSizableOrigin: () => getSizableOrigin3,
     hexToUint8Array: () => hexToUint8Array2,
-    isObject: () => isObject5,
+    isObject: () => isObject4,
     isPlainObject: () => isPlainObject3,
     issue: () => issue3,
     joinValues: () => joinValues3,
@@ -180304,7 +179781,7 @@ var init_dist4 = __esm(() => {
       }
       return propValues;
     });
-    const isObject22 = isObject5;
+    const isObject22 = isObject4;
     const catchall = def.catchall;
     let value;
     inst._zod.parse = (payload, ctx) => {
@@ -180384,7 +179861,7 @@ var init_dist4 = __esm(() => {
       return (payload, ctx) => fn(shape, payload, ctx);
     };
     let fastpass;
-    const isObject22 = isObject5;
+    const isObject22 = isObject4;
     const jit = !globalConfig3.jitless;
     const allowsEval22 = allowsEval3;
     const fastEnabled = jit && allowsEval22.value;
@@ -180496,7 +179973,7 @@ var init_dist4 = __esm(() => {
     });
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isObject5(input)) {
+      if (!isObject4(input)) {
         payload.issues.push({
           code: "invalid_type",
           expected: "object",
@@ -190491,7 +189968,7 @@ async function createConfiguredActivityClient({
       assertFilterTreeSupported(tree);
     }
   }
-  const { DesignTimeActivityClient: DesignTimeActivityClient3 } = await Promise.resolve().then(() => (init_dist4(), exports_dist2));
+  const { DesignTimeActivityClient: DesignTimeActivityClient3 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
   const client = await DesignTimeActivityClient3.initiate({ instanceParameters, uiPathActivityTypeId: "" }, { connectionsProvider: createLiveConnectionsProvider() });
   await client.updateConnection({ connectionId });
   if (customFieldsRequestDetails) {
@@ -198193,7 +197670,7 @@ class VoidApiResponse3 {
 // ../orchestrator-sdk/package.json
 var package_default2 = {
   name: "@uipath/orchestrator-sdk",
-  license: "MIT",
+  license: "SEE LICENSE IN LICENSE.txt",
   version: "1.202.0",
   repository: {
     type: "git",
@@ -200618,16 +200095,16 @@ async function getRegistry() {
 }
 async function searchRegistry(keyword) {
   const registry5 = await getRegistry();
-  const lower2 = keyword.toLowerCase();
-  const extensionTypes = Object.values(registry5.static.extensionTypes).filter((et) => et.extensionType.toLowerCase().includes(lower2) || et.label.toLowerCase().includes(lower2) || et.bpmnElement.toLowerCase().includes(lower2) || et.extensionTag.toLowerCase().includes(lower2) || (et.discoveryNotes ?? "").toLowerCase().includes(lower2));
-  const connectors = registry5.discovered.connectors.filter((c) => c.key.toLowerCase().includes(lower2) || c.name.toLowerCase().includes(lower2) || c.activities.some((a) => a.displayName.toLowerCase().includes(lower2) || a.name.toLowerCase().includes(lower2)) || c.triggers.some((t14) => t14.displayName.toLowerCase().includes(lower2) || t14.name.toLowerCase().includes(lower2)));
-  const processes = registry5.discovered.processes.filter((p) => p.name.toLowerCase().includes(lower2) || p.processKey.toLowerCase().includes(lower2) || (p.processVersion ?? "").toLowerCase().includes(lower2) || p.key.toLowerCase().includes(lower2) || p.type.toLowerCase().includes(lower2) || p.folderKey.toLowerCase().includes(lower2) || (p.feedId ?? "").toLowerCase().includes(lower2));
+  const lower = keyword.toLowerCase();
+  const extensionTypes = Object.values(registry5.static.extensionTypes).filter((et) => et.extensionType.toLowerCase().includes(lower) || et.label.toLowerCase().includes(lower) || et.bpmnElement.toLowerCase().includes(lower) || et.extensionTag.toLowerCase().includes(lower) || (et.discoveryNotes ?? "").toLowerCase().includes(lower));
+  const connectors = registry5.discovered.connectors.filter((c) => c.key.toLowerCase().includes(lower) || c.name.toLowerCase().includes(lower) || c.activities.some((a) => a.displayName.toLowerCase().includes(lower) || a.name.toLowerCase().includes(lower)) || c.triggers.some((t14) => t14.displayName.toLowerCase().includes(lower) || t14.name.toLowerCase().includes(lower)));
+  const processes = registry5.discovered.processes.filter((p) => p.name.toLowerCase().includes(lower) || p.processKey.toLowerCase().includes(lower) || (p.processVersion ?? "").toLowerCase().includes(lower) || p.key.toLowerCase().includes(lower) || p.type.toLowerCase().includes(lower) || p.folderKey.toLowerCase().includes(lower) || (p.feedId ?? "").toLowerCase().includes(lower));
   return { extensionTypes, connectors, processes };
 }
 async function getExtensionType(extensionType) {
   const registry5 = await getRegistry();
-  const lower2 = extensionType.toLowerCase();
-  const match2 = Object.entries(registry5.static.extensionTypes).find(([key]) => key.toLowerCase() === lower2);
+  const lower = extensionType.toLowerCase();
+  const match2 = Object.entries(registry5.static.extensionTypes).find(([key]) => key.toLowerCase() === lower);
   return match2 ? match2[1] : null;
 }
 async function resolveConnectorKey(connectionId) {
@@ -202115,4 +201592,4 @@ export {
   withPimsCall
 };
 
-//# debugId=C8895705CB92198464756E2164756E21
+//# debugId=FE5E55D83A77DFFF64756E2164756E21