@jmespath-community/jmespath 1.3.0 → 1.4.0

package/dist/cli.mjs

@@ -1,11 +1,89 @@
 #!/usr/bin/env node
-import { parseArgs } from 'util';
 import * as fs from 'fs';
+import { parseArgs } from 'util';
 
 // package.json
 var package_default = {
   name: "@jmespath-community/jmespath",
-  version: "1.3.0"};
+  version: "1.4.0"};
+
+// src/utils/ast.ts
+var CHILD_PROPS = ["left", "right", "condition", "child", "operand", "trueExpr", "falseExpr", "expression"];
+function pushChildren(node, stack) {
+  const n = node;
+  for (const prop of CHILD_PROPS) {
+    const val = n[prop];
+    if (val && typeof val === "object" && "type" in val) {
+      stack.push(val);
+    }
+  }
+  if (Array.isArray(n.children)) {
+    for (const item of n.children) {
+      if (!item) {
+        continue;
+      }
+      stack.push(item);
+      if (item.type === "KeyValuePair" && item.value) {
+        stack.push(item.value);
+      }
+    }
+  }
+  if (Array.isArray(n.bindings)) {
+    for (const item of n.bindings) {
+      if (!item) {
+        continue;
+      }
+      stack.push(item);
+      if (item.reference) {
+        stack.push(item.reference);
+      }
+    }
+  }
+}
+function forEachNode(root, visitor) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      break;
+    }
+    if (visitor(current) === false) {
+      return;
+    }
+    pushChildren(current, stack);
+  }
+}
+function countNodes(root) {
+  let count = 0;
+  forEachNode(root, () => {
+    count += 1;
+    return true;
+  });
+  return count;
+}
+function findDisallowedFunction(root, options) {
+  const { allowedFunctions, disallowedFunctions } = options;
+  if (!allowedFunctions && !disallowedFunctions) {
+    return null;
+  }
+  let violation = null;
+  forEachNode(root, (node) => {
+    if (node.type !== "Function") {
+      return true;
+    }
+    const name = node.name;
+    if (allowedFunctions && !allowedFunctions.includes(name)) {
+      violation = `Function '${name}' is not allowed`;
+      return false;
+    }
+    if (disallowedFunctions && disallowedFunctions.includes(name)) {
+      violation = `Function '${name}' is disallowed`;
+      return false;
+    }
+    return true;
+  });
+  return violation;
+}
 
 // src/utils/index.ts
 var isObject = (obj) => {
@@ -56,9 +134,6 @@ var isFalse = (obj) => {
     if (Array.isArray(obj)) {
       return obj.length === 0;
     }
-    if (obj === null) {
-      return true;
-    }
     return Object.keys(obj).length === 0;
   }
   return false;
@@ -103,111 +178,28 @@ var notZero = (n) => {
 };
 var add = (left, right) => {
   ensureNumbers(left, right);
-  const result = left + right;
-  return result;
+  return left + right;
 };
 var sub = (left, right) => {
   ensureNumbers(left, right);
-  const result = left - right;
-  return result;
+  return left - right;
 };
 var mul = (left, right) => {
   ensureNumbers(left, right);
-  const result = left * right;
-  return result;
+  return left * right;
 };
 var divide = (left, right) => {
   ensureNumbers(left, right);
-  const result = left / notZero(right);
-  return result;
+  return left / notZero(right);
 };
 var div = (left, right) => {
   ensureNumbers(left, right);
-  const result = Math.floor(left / notZero(right));
-  return result;
+  return Math.floor(left / notZero(right));
 };
 var mod = (left, right) => {
   ensureNumbers(left, right);
-  const result = left % right;
-  return result;
-};
-
-// src/utils/strings.ts
-var findFirst = (subject, sub2, start, end) => {
-  if (!subject || !sub2) {
-    return null;
-  }
-  start = Math.max(ensureInteger(start = start || 0), 0);
-  end = Math.min(ensureInteger(end = end || subject.length), subject.length);
-  const offset = subject.slice(start, end).indexOf(sub2);
-  return offset === -1 ? null : offset + start;
-};
-var findLast = (subject, sub2, start, end) => {
-  if (!subject || !sub2) {
-    return null;
-  }
-  start = Math.max(ensureInteger(start = start || 0), 0);
-  end = Math.min(ensureInteger(end = end || subject.length), subject.length);
-  const offset = subject.slice(start, end).lastIndexOf(sub2);
-  const result = offset === -1 ? null : offset + start;
-  return result;
-};
-var lower = (subject) => subject.toLowerCase();
-var ensurePadFuncParams = (name, width, padding) => {
-  padding = padding || " ";
-  if (padding.length > 1) {
-    throw new Error(`invalid value, ${name} expects its 'pad' parameter to be a valid string with a single codepoint`);
-  }
-  ensurePositiveInteger(width);
-  return padding;
-};
-var padLeft = (subject, width, padding) => {
-  padding = ensurePadFuncParams("pad_left", width, padding);
-  return subject && subject.padStart(width, padding) || "";
-};
-var padRight = (subject, width, padding) => {
-  padding = ensurePadFuncParams("pad_right", width, padding);
-  return subject && subject.padEnd(width, padding) || "";
-};
-var replace = (subject, string, by, count) => {
-  if (count === 0) {
-    return subject;
-  }
-  if (!count) {
-    return subject.split(string).join(by);
-  }
-  ensurePositiveInteger(count);
-  [...Array(count).keys()].map(() => subject = subject.replace(string, by));
-  return subject;
-};
-var split = (subject, search2, count) => {
-  if (subject.length == 0 && search2.length === 0) {
-    return [];
-  }
-  if (count === null || count === void 0) {
-    return subject.split(search2);
-  }
-  ensurePositiveInteger(count);
-  if (count === 0) {
-    return [subject];
-  }
-  const split2 = subject.split(search2);
-  return [...split2.slice(0, count), split2.slice(count).join(search2)];
-};
-var trim = (subject, chars) => {
-  return trimLeft(trimRight(subject, chars), chars);
-};
-var trimLeft = (subject, chars) => {
-  return trimImpl(subject, (list) => new RegExp(`^[${list}]*(.*?)`), chars);
-};
-var trimRight = (subject, chars) => {
-  return trimImpl(subject, (list) => new RegExp(`(.*?)[${list}]*$`), chars);
-};
-var trimImpl = (subject, regExper, chars) => {
-  const pattern = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : "\\s\x85";
-  return subject.replace(regExper(pattern), "$1");
+  return left % right;
 };
-var upper = (subject) => subject.toUpperCase();
 
 // src/Lexer.ts
 var basicTokens = {
@@ -388,7 +380,7 @@ var StreamLexer = class {
     }
     this._current += 1;
     const literal = stream.slice(start + 1, this._current - 1);
-    return replace(replace(literal, `\\\\`, `\\`), `\\'`, `'`);
+    return literal.replace(/\\(['\\])/g, "$1");
   }
   consumeNumber(stream) {
     const start = this._current;
@@ -553,14 +545,25 @@ var bindingPower = {
 var TokenParser = class _TokenParser {
   index = 0;
   tokens = [];
+  depth = 0;
+  maxDepth;
+  nodeCount = 0;
+  maxNodes;
   parse(expression2, options) {
     this.loadTokens(expression2, options || { enable_legacy_literals: false });
     this.index = 0;
+    this.depth = 0;
+    this.nodeCount = 0;
+    this.maxDepth = options?.maxDepth;
+    this.maxNodes = options?.maxNodes;
     const ast = this.expression(0);
     if (this.lookahead(0) !== "EOF" /* TOK_EOF */) {
       const token = this.lookaheadToken(0);
       this.errorToken(token, `Syntax error: unexpected token type: ${token.type}, value: ${token.value}`);
     }
+    if (this.maxNodes !== void 0 && countNodes(ast) > this.maxNodes) {
+      throw new Error(`Expression exceeds maximum allowed node count of ${this.maxNodes}`);
+    }
     return ast;
   }
   loadTokens(expression2, options) {
@@ -568,16 +571,32 @@ var TokenParser = class _TokenParser {
     this.tokens.push({ type: "EOF" /* TOK_EOF */, value: "", start: expression2.length });
   }
   expression(rbp) {
-    const leftToken = this.lookaheadToken(0);
-    this.advance();
-    let left = this.nud(leftToken);
-    let currentTokenType = this.lookahead(0);
-    while (rbp < bindingPower[currentTokenType]) {
+    if (this.maxDepth !== void 0 && this.depth >= this.maxDepth) {
+      throw new Error(`Expression exceeds maximum allowed depth of ${this.maxDepth}`);
+    }
+    this.depth += 1;
+    this.trackNode();
+    try {
+      const leftToken = this.lookaheadToken(0);
       this.advance();
-      left = this.led(currentTokenType, left);
-      currentTokenType = this.lookahead(0);
+      let left = this.nud(leftToken);
+      let currentTokenType = this.lookahead(0);
+      while (rbp < bindingPower[currentTokenType]) {
+        this.trackNode();
+        this.advance();
+        left = this.led(currentTokenType, left);
+        currentTokenType = this.lookahead(0);
+      }
+      return left;
+    } finally {
+      this.depth -= 1;
+    }
+  }
+  trackNode() {
+    this.nodeCount += 1;
+    if (this.maxNodes !== void 0 && this.nodeCount > this.maxNodes) {
+      throw new Error(`Expression exceeds maximum allowed node count of ${this.maxNodes}`);
     }
-    return left;
   }
   lookahead(offset) {
     return this.tokens[this.index + offset].type;
@@ -804,9 +823,13 @@ var TokenParser = class _TokenParser {
       right
     };
     if (right.type === "Slice") {
+      const rhs = this.parseProjectionRHS(bindingPower.Star);
+      if (rhs.type === "Identity") {
+        return indexExpr;
+      }
       return {
         left: indexExpr,
-        right: this.parseProjectionRHS(bindingPower.Star),
+        right: rhs,
         type: "Projection"
       };
     }
@@ -966,6 +989,83 @@ var TokenParser = class _TokenParser {
 var Parser = new TokenParser();
 var Parser_default = Parser;
 
+// src/utils/strings.ts
+var findFirst = (subject, sub2, start, end) => {
+  if (!subject || !sub2) {
+    return null;
+  }
+  const s = Math.max(ensureInteger(start ?? 0), 0);
+  const e = Math.min(ensureInteger(end ?? subject.length), subject.length);
+  const offset = subject.slice(s, e).indexOf(sub2);
+  return offset === -1 ? null : offset + s;
+};
+var findLast = (subject, sub2, start, end) => {
+  if (!subject || !sub2) {
+    return null;
+  }
+  const s = Math.max(ensureInteger(start ?? 0), 0);
+  const e = Math.min(ensureInteger(end ?? subject.length), subject.length);
+  const offset = subject.slice(s, e).lastIndexOf(sub2);
+  return offset === -1 ? null : offset + s;
+};
+var lower = (subject) => subject.toLowerCase();
+var ensurePadFuncParams = (name, width, padding = " ") => {
+  if (padding.length > 1) {
+    throw new Error(`invalid value, ${name} expects its 'pad' parameter to be a valid string with a single codepoint`);
+  }
+  ensurePositiveInteger(width);
+  return padding;
+};
+var padLeft = (subject, width, padding) => {
+  padding = ensurePadFuncParams("pad_left", width, padding);
+  return subject && subject.padStart(width, padding) || "";
+};
+var padRight = (subject, width, padding) => {
+  padding = ensurePadFuncParams("pad_right", width, padding);
+  return subject && subject.padEnd(width, padding) || "";
+};
+var replace = (subject, string, by, count) => {
+  if (count === 0) {
+    return subject;
+  }
+  if (!count) {
+    return subject.split(string).join(by);
+  }
+  ensurePositiveInteger(count);
+  while (count-- > 0 && subject.includes(string)) {
+    subject = subject.replace(string, by);
+  }
+  return subject;
+};
+var split = (subject, search2, count) => {
+  if (subject.length == 0 && search2.length === 0) {
+    return [];
+  }
+  if (count === null || count === void 0) {
+    return subject.split(search2);
+  }
+  ensurePositiveInteger(count);
+  if (count === 0) {
+    return [subject];
+  }
+  const split2 = subject.split(search2);
+  return [...split2.slice(0, count), split2.slice(count).join(search2)];
+};
+var trim = (subject, chars) => {
+  return trimLeft(trimRight(subject, chars), chars);
+};
+var trimLeft = (subject, chars) => {
+  return trimImpl(subject, (list) => new RegExp(`^[${list}]*(.*?)`), chars);
+};
+var trimRight = (subject, chars) => {
+  return trimImpl(subject, (list) => new RegExp(`(.*?)[${list}]*$`), chars);
+};
+var trimImpl = (subject, regExper, chars) => {
+  const pattern = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : "\\s\x85";
+  return subject.replace(regExper(pattern), "$1");
+};
+var upper = (subject) => subject.toUpperCase();
+
 // src/utils/text.ts
 var Text = class _Text {
   _text;
@@ -976,7 +1076,11 @@ var Text = class _Text {
     return this._text;
   }
   get length() {
-    return this.codePoints.length;
+    let count = 0;
+    for (const _ of this._text) {
+      count += 1;
+    }
+    return count;
   }
   compareTo(other) {
     return _Text.compare(this, new _Text(other));
@@ -1011,6 +1115,12 @@ var Text = class _Text {
 var createMathFunction = (mathFn) => ([value]) => mathFn(value);
 var createStringFunction = (stringFn) => ([subject]) => stringFn(subject);
 var createObjectFunction = (objFn) => ([obj]) => objFn(obj);
+var ARRAY_SUBTYPES = {
+  [8 /* TYPE_ARRAY_NUMBER */]: 0 /* TYPE_NUMBER */,
+  [10 /* TYPE_ARRAY_OBJECT */]: 4 /* TYPE_OBJECT */,
+  [9 /* TYPE_ARRAY_STRING */]: 2 /* TYPE_STRING */,
+  [11 /* TYPE_ARRAY_ARRAY */]: 3 /* TYPE_ARRAY */
+};
 var Runtime = class {
   _interpreter;
   _functionTable;
@@ -1328,34 +1438,18 @@ var Runtime = class {
     if (expected === 1 /* TYPE_ANY */) {
       return true;
     }
-    if (expected === 9 /* TYPE_ARRAY_STRING */ || expected === 8 /* TYPE_ARRAY_NUMBER */ || expected === 10 /* TYPE_ARRAY_OBJECT */ || expected === 11 /* TYPE_ARRAY_ARRAY */ || expected === 3 /* TYPE_ARRAY */) {
-      if (expected === 3 /* TYPE_ARRAY */) {
-        return actual === 3 /* TYPE_ARRAY */;
-      }
-      if (actual === 3 /* TYPE_ARRAY */) {
-        let subtype;
-        if (expected === 8 /* TYPE_ARRAY_NUMBER */) {
-          subtype = 0 /* TYPE_NUMBER */;
-        } else if (expected === 10 /* TYPE_ARRAY_OBJECT */) {
-          subtype = 4 /* TYPE_OBJECT */;
-        } else if (expected === 9 /* TYPE_ARRAY_STRING */) {
-          subtype = 2 /* TYPE_STRING */;
-        } else if (expected === 11 /* TYPE_ARRAY_ARRAY */) {
-          subtype = 3 /* TYPE_ARRAY */;
-        }
-        const array = argValue;
-        for (let i = 0; i < array.length; i += 1) {
-          const typeName = this.getTypeName(array[i]);
-          if (typeName !== void 0 && subtype !== void 0 && !this.typeMatches(typeName, subtype, array[i])) {
-            return false;
-          }
-        }
-        return true;
+    const subtype = ARRAY_SUBTYPES[expected];
+    if (subtype !== void 0) {
+      if (actual !== 3 /* TYPE_ARRAY */) {
+        return false;
       }
-    } else {
-      return actual === expected;
+      const array = argValue;
+      return array.every((item) => {
+        const typeName = this.getTypeName(item);
+        return typeName === void 0 || this.typeMatches(typeName, subtype, item);
+      });
     }
-    return false;
+    return actual === expected;
   }
   getTypeName(obj) {
     if (obj === null) {
@@ -1419,9 +1513,8 @@ var Runtime = class {
     }
     return null;
   };
-  functionEndsWith = (resolvedArgs) => {
-    const [searchStr, suffix] = resolvedArgs;
-    return searchStr.includes(suffix, searchStr.length - suffix.length);
+  functionEndsWith = ([searchStr, suffix]) => {
+    return searchStr.endsWith(suffix);
   };
   functionFindFirst = this.createFindFunction(findFirst);
   functionFindLast = this.createFindFunction(findLast);
@@ -1435,21 +1528,24 @@ var Runtime = class {
     };
   }
   functionFromItems = ([array]) => {
-    array.map((pair) => {
-      if (pair.length != 2 || typeof pair[0] !== "string") {
+    for (const pair of array) {
+      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 /* TYPE_STRING */]);
-    return array.reduce((acc, cur) => {
-      const k = keyFunction(cur ?? {});
-      const target = acc[k] = acc[k] || [];
-      target.push(cur);
-      return acc;
-    }, {});
+    const groups = {};
+    for (const item of array) {
+      const key = keyFunction(item);
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+    }
+    return groups;
   };
   functionItems = ([inputValue]) => {
     return Object.entries(inputValue);
@@ -1512,12 +1608,7 @@ var Runtime = class {
     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;
+    return Object.assign({}, ...resolvedArgs);
   };
   functionMin = ([inputValue]) => {
     if (!inputValue.length) {
@@ -1553,12 +1644,7 @@ var Runtime = class {
     return minRecord || null;
   };
   functionNotNull = (resolvedArgs) => {
-    for (let i = 0; i < resolvedArgs.length; i += 1) {
-      if (this.getTypeName(resolvedArgs[i]) !== 7 /* TYPE_NULL */) {
-        return resolvedArgs[i];
-      }
-    }
-    return null;
+    return resolvedArgs.find((arg) => arg !== null) ?? null;
   };
   functionPadLeft = this.createPadFunction(padLeft);
   functionPadRight = this.createPadFunction(padRight);
@@ -1586,12 +1672,12 @@ var Runtime = class {
     if (typeName === 2 /* TYPE_STRING */) {
       return new Text(inputValue).reverse();
     }
-    const reversedArray = inputValue.slice(0);
+    const reversedArray = [...inputValue];
     reversedArray.reverse();
     return reversedArray;
   };
   functionSort = ([inputValue]) => {
-    if (inputValue.length == 0) {
+    if (inputValue.length <= 1) {
       return inputValue;
     }
     if (typeof inputValue[0] === "string") {
@@ -1600,8 +1686,8 @@ var Runtime = class {
     return [...inputValue].sort();
   };
   functionSortBy = (resolvedArgs) => {
-    const sortedArray = resolvedArgs[0].slice(0);
-    if (sortedArray.length === 0) {
+    const sortedArray = [...resolvedArgs[0]];
+    if (sortedArray.length <= 1) {
       return sortedArray;
     }
     const interpreter = this._interpreter;
@@ -1636,10 +1722,7 @@ var Runtime = class {
     return inputValue.reduce((x, y) => x + y, 0);
   };
   functionToArray = ([inputValue]) => {
-    if (this.getTypeName(inputValue) === 3 /* TYPE_ARRAY */) {
-      return inputValue;
-    }
-    return [inputValue];
+    return Array.isArray(inputValue) ? inputValue : [inputValue];
   };
   functionToNumber = ([inputValue]) => {
     const typeName = this.getTypeName(inputValue);
@@ -1656,10 +1739,7 @@ var Runtime = class {
     return null;
   };
   functionToString = ([inputValue]) => {
-    if (this.getTypeName(inputValue) === 2 /* TYPE_STRING */) {
-      return inputValue;
-    }
-    return JSON.stringify(inputValue);
+    return typeof inputValue === "string" ? inputValue : JSON.stringify(inputValue);
   };
   functionTrim = this.createTrimFunction(trim);
   functionTrimLeft = this.createTrimFunction(trimLeft);
@@ -1672,27 +1752,16 @@ var Runtime = class {
     };
   }
   functionType = ([inputValue]) => {
-    switch (this.getTypeName(inputValue)) {
-      case 0 /* TYPE_NUMBER */:
-        return "number";
-      case 2 /* TYPE_STRING */:
-        return "string";
-      case 3 /* TYPE_ARRAY */:
-        return "array";
-      case 4 /* TYPE_OBJECT */:
-        return "object";
-      case 5 /* TYPE_BOOLEAN */:
-        return "boolean";
-      case 7 /* TYPE_NULL */:
-        return "null";
-      default:
-        throw new Error("invalid-type");
+    const type = this.getTypeName(inputValue);
+    const name = type !== void 0 ? this.TYPE_NAME_TABLE[type] : void 0;
+    if (!name) {
+      throw new Error("invalid-type");
     }
+    return name;
   };
   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;
+    return Array.from({ length }, (_, index) => array.map((arr) => arr[index]));
   };
 };
 
@@ -1726,23 +1795,108 @@ var TreeInterpreter = class _TreeInterpreter {
   runtime;
   _rootValue = null;
   _scope;
-  constructor() {
+  _options;
+  _depth = 0;
+  _deadline = 0;
+  constructor(options) {
     this.runtime = new Runtime(this);
     this._scope = new ScopeChain();
+    if (options) {
+      this._options = options;
+      this._deadline = options.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : 0;
+    }
   }
   withScope(scope) {
-    const interpreter = new _TreeInterpreter();
+    const interpreter = new _TreeInterpreter(this._options);
     interpreter.runtime._functionTable = this.runtime._functionTable;
     interpreter._rootValue = this._rootValue;
     interpreter._scope = this._scope.withScope(scope);
+    interpreter._depth = this._depth;
+    interpreter._deadline = this._deadline;
     return interpreter;
   }
-  search(node, value) {
+  search(node, value, options) {
+    if (options?.maxNodes !== void 0 && countNodes(node) > options.maxNodes) {
+      throw new Error(`Expression exceeds maximum allowed node count of ${options.maxNodes}`);
+    }
     this._rootValue = value;
     this._scope = emptyScopeChain;
-    return this.visit(node, value);
+    this._options = options;
+    this._depth = 0;
+    this._deadline = options?.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : 0;
+    const result = this.visit(node, value);
+    this.checkOutputSize(result);
+    return result;
+  }
+  checkOutputSize(val) {
+    const max = this._options?.maxOutputSize;
+    if (max === void 0 || val == null) {
+      return;
+    }
+    const size = Array.isArray(val) || typeof val === "string" ? val.length : typeof val === "object" ? Object.keys(val).length : 0;
+    if (size > max) {
+      throw new Error(`Output size exceeds maximum allowed size of ${max}`);
+    }
+  }
+  collect(target, item) {
+    target.push(item);
+    if (this._options?.maxOutputSize !== void 0 && target.length > this._options.maxOutputSize) {
+      throw new Error(`Output size exceeds maximum allowed size of ${this._options.maxOutputSize}`);
+    }
+  }
+  evaluateProjectionItems(items, right) {
+    const collected = [];
+    if (right.type === "Field") {
+      const key = right.name;
+      for (let i = 0; i < items.length; i++) {
+        if (this._deadline > 0 && Date.now() >= this._deadline) {
+          throw new Error(`Query execution timed out after ${this._options?.timeoutMs}ms`);
+        }
+        const elem = items[i];
+        if (!elem || typeof elem !== "object" || Array.isArray(elem)) {
+          continue;
+        }
+        const val = elem[key];
+        if (val !== void 0 && val !== null) {
+          this.collect(collected, val);
+        }
+      }
+      return collected;
+    }
+    if (right.type === "Identity") {
+      for (let i = 0; i < items.length; i++) {
+        const elem = items[i];
+        if (elem !== null) {
+          this.collect(collected, elem);
+        }
+      }
+      return collected;
+    }
+    for (const elem of items) {
+      const current = this.visit(right, elem);
+      if (current !== null) {
+        this.collect(collected, current);
+      }
+    }
+    return collected;
   }
   visit(node, value) {
+    if (this._options) {
+      if (this._options.maxDepth !== void 0 && this._depth >= this._options.maxDepth) {
+        throw new Error(`Evaluation exceeds maximum allowed depth of ${this._options.maxDepth}`);
+      }
+      if (this._deadline > 0 && Date.now() >= this._deadline) {
+        throw new Error(`Query execution timed out after ${this._options.timeoutMs}ms`);
+      }
+    }
+    this._depth += 1;
+    try {
+      return this.evaluateNode(node, value);
+    } finally {
+      this._depth -= 1;
+    }
+  }
+  evaluateNode(node, value) {
     switch (node.type) {
       case "Ternary": {
         const condition = this.visit(node.condition, value);
@@ -1758,16 +1912,11 @@ var TreeInterpreter = class _TreeInterpreter {
         }
         return value[identifier] ?? null;
       case "LetExpression": {
-        const { bindings, expression: expression2 } = node;
-        let scope = {};
-        bindings.forEach((binding) => {
-          const reference = this.visit(binding, value);
-          scope = {
-            ...scope,
-            ...reference
-          };
-        });
-        return this.withScope(scope).visit(expression2, value);
+        const scope = {};
+        for (const binding of node.bindings) {
+          Object.assign(scope, this.visit(binding, value));
+        }
+        return this.withScope(scope).visit(node.expression, value);
       }
       case "Binding": {
         const { variable, reference } = node;
@@ -1799,51 +1948,27 @@ var TreeInterpreter = class _TreeInterpreter {
           return null;
         }
         const { start, stop, step } = this.computeSliceParams(value.length, node);
-        if (typeof value === "string") {
-          const chars = [...value];
-          const sliced = this.slice(chars, start, stop, step);
-          return sliced.join("");
-        } else {
-          return this.slice(value, start, stop, step);
-        }
+        const target = typeof value === "string" ? [...value] : value;
+        const sliced = this.slice(target, start, stop, step);
+        const res = typeof value === "string" ? sliced.join("") : sliced;
+        this.checkOutputSize(res);
+        return res;
       }
       case "Projection": {
         const { left, right } = node;
-        let allowString = false;
-        if (left.type === "IndexExpression" && left.right.type === "Slice") {
-          allowString = true;
-        }
+        const allowString = left.type === "IndexExpression" && left.right.type === "Slice";
         const base = this.visit(left, value);
         if (allowString && typeof base === "string") {
           return this.visit(right, base);
         }
-        if (!Array.isArray(base)) {
-          return null;
-        }
-        const collected = [];
-        for (const elem of base) {
-          const current = this.visit(right, elem);
-          if (current !== null) {
-            collected.push(current);
-          }
-        }
-        return collected;
+        return Array.isArray(base) ? this.evaluateProjectionItems(base, right) : null;
       }
       case "ValueProjection": {
-        const { left, right } = node;
-        const base = this.visit(left, value);
+        const base = this.visit(node.left, value);
         if (base === null || typeof base !== "object" || Array.isArray(base)) {
           return null;
         }
-        const collected = [];
-        const values = Object.values(base);
-        for (const elem of values) {
-          const current = this.visit(right, elem);
-          if (current !== null) {
-            collected.push(current);
-          }
-        }
-        return collected;
+        return this.evaluateProjectionItems(Object.values(base), node.right);
       }
       case "FilterProjection": {
         const { left, right, condition } = node;
@@ -1852,14 +1977,42 @@ var TreeInterpreter = class _TreeInterpreter {
           return null;
         }
         const results = [];
+        if (right.type === "Field") {
+          const key = right.name;
+          for (let i = 0; i < base.length; i++) {
+            const elem = base[i];
+            if (isFalse(this.visit(condition, elem))) {
+              continue;
+            }
+            if (!elem || typeof elem !== "object" || Array.isArray(elem)) {
+              continue;
+            }
+            const val = elem[key];
+            if (val !== void 0 && val !== null) {
+              this.collect(results, val);
+            }
+          }
+          return results;
+        }
+        if (right.type === "Identity") {
+          for (let i = 0; i < base.length; i++) {
+            const elem = base[i];
+            if (isFalse(this.visit(condition, elem))) {
+              continue;
+            }
+            if (elem !== null) {
+              this.collect(results, elem);
+            }
+          }
+          return results;
+        }
         for (const elem of base) {
-          const matched = this.visit(condition, elem);
-          if (isFalse(matched)) {
+          if (isFalse(this.visit(condition, elem))) {
             continue;
           }
           const result = this.visit(right, elem);
           if (result !== null) {
-            results.push(result);
+            this.collect(results, result);
           }
         }
         return results;
@@ -1923,7 +2076,9 @@ var TreeInterpreter = class _TreeInterpreter {
       }
       case "Flatten": {
         const original = this.visit(node.child, value);
-        return Array.isArray(original) ? original.flat() : null;
+        const res = Array.isArray(original) ? original.flat() : null;
+        this.checkOutputSize(res);
+        return res;
       }
       case "Root":
         return this._rootValue;
@@ -1932,6 +2087,7 @@ var TreeInterpreter = class _TreeInterpreter {
         for (const child of node.children) {
           collected.push(this.visit(child, value));
         }
+        this.checkOutputSize(collected);
         return collected;
       }
       case "MultiSelectHash": {
@@ -1939,6 +2095,7 @@ var TreeInterpreter = class _TreeInterpreter {
         for (const child of node.children) {
           collected[child.name] = this.visit(child.value, value);
         }
+        this.checkOutputSize(collected);
         return collected;
       }
       case "OrExpression": {
@@ -1962,11 +2119,19 @@ var TreeInterpreter = class _TreeInterpreter {
       case "Pipe":
         return this.visit(node.right, this.visit(node.left, value));
       case "Function": {
+        if (this._options?.allowedFunctions && !this._options.allowedFunctions.includes(node.name)) {
+          throw new Error(`Function '${node.name}' is not allowed`);
+        }
+        if (this._options?.disallowedFunctions && this._options.disallowedFunctions.includes(node.name)) {
+          throw new Error(`Function '${node.name}' is disallowed`);
+        }
         const args2 = [];
         for (const child of node.children) {
           args2.push(this.visit(child, value));
         }
-        return this.runtime.callFunction(node.name, args2);
+        const res = this.runtime.callFunction(node.name, args2);
+        this.checkOutputSize(res);
+        return res;
       }
       case "ExpressionReference":
         return {
@@ -2004,14 +2169,19 @@ var TreeInterpreter = class _TreeInterpreter {
     return nextActualValue;
   }
   slice(collection, start, end, step) {
-    const result = [];
+    if (step === 1) {
+      return collection.slice(start, end);
+    }
+    const len = Math.ceil(Math.abs(start - end) / Math.abs(step));
+    const result = new Array(len);
+    let idx = 0;
     if (step > 0) {
       for (let i = start; i < end; i += step) {
-        result.push(collection[i]);
+        result[idx++] = collection[i];
       }
     } else {
       for (let i = start; i > end; i += step) {
-        result.push(collection[i]);
+        result[idx++] = collection[i];
       }
     }
     return result;
@@ -2020,10 +2190,397 @@ var TreeInterpreter = class _TreeInterpreter {
 var TreeInterpreterInstance = new TreeInterpreter();
 var TreeInterpreter_default = TreeInterpreterInstance;
 
+// src/Stream.ts
+async function* toAsyncIterable(source) {
+  if (source == null) {
+    return;
+  }
+  if (typeof source !== "object" && typeof source !== "function") {
+    throw new TypeError("Invalid stream source: expected AsyncIterable, Iterable, or ReadableStream");
+  }
+  if (Symbol.asyncIterator in source) {
+    for await (const chunk of source) {
+      yield chunk;
+    }
+    return;
+  }
+  if (typeof source.getReader === "function") {
+    const reader = source.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return;
+  }
+  if (Symbol.iterator in source) {
+    for (const chunk of source) {
+      yield chunk;
+    }
+    return;
+  }
+  throw new TypeError("Invalid stream source: expected AsyncIterable, Iterable, or ReadableStream");
+}
+function parseItem(str, parseJson) {
+  if (parseJson === true) {
+    return JSON.parse(str);
+  }
+  if (parseJson === "auto") {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+  return str;
+}
+async function* normalizeSource(source, options) {
+  const parseJson = options?.parseJson ?? "auto";
+  const flatten = options?.flattenChunks ?? true;
+  let buffer = "";
+  const textDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder() : null;
+  for await (const chunk of toAsyncIterable(source)) {
+    if (chunk instanceof Uint8Array && textDecoder) {
+      buffer += textDecoder.decode(chunk, { stream: true });
+      if (buffer.includes("\n")) {
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed) {
+            yield parseItem(trimmed, parseJson);
+          }
+        }
+      }
+    } else if (typeof chunk === "string") {
+      if (parseJson === false) {
+        yield chunk;
+      } else {
+        buffer += chunk;
+        if (buffer.includes("\n")) {
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed) {
+              yield parseItem(trimmed, parseJson);
+            }
+          }
+        }
+      }
+    } else if (flatten && Array.isArray(chunk)) {
+      if (buffer.trim()) {
+        yield parseItem(buffer.trim(), parseJson);
+        buffer = "";
+      }
+      for (let i = 0; i < chunk.length; i++) {
+        yield chunk[i];
+      }
+    } else {
+      if (buffer.trim()) {
+        yield parseItem(buffer.trim(), parseJson);
+        buffer = "";
+      }
+      yield chunk;
+    }
+  }
+  if (textDecoder && buffer) {
+    buffer += textDecoder.decode();
+  }
+  if (buffer.trim()) {
+    yield parseItem(buffer.trim(), parseJson);
+  }
+}
+function isStreamableNode(node) {
+  switch (node.type) {
+    case "Projection":
+      if (node.left.type === "Identity" || node.left.type === "Current") {
+        return true;
+      }
+      if (node.left.type === "IndexExpression" && node.left.right.type === "Slice") {
+        const slice = node.left.right;
+        return (slice.start === null || slice.start >= 0) && (slice.stop === null || slice.stop >= 0) && (slice.step === null || slice.step > 0);
+      }
+      return false;
+    case "FilterProjection":
+      return node.left.type === "Identity" || node.left.type === "Current";
+    case "IndexExpression":
+      if (node.right.type === "Slice" && (node.left.type === "Identity" || node.left.type === "Current")) {
+        const slice = node.right;
+        return (slice.start === null || slice.start >= 0) && (slice.stop === null || slice.stop >= 0) && (slice.step === null || slice.step > 0);
+      }
+      return true;
+    case "Field":
+    case "Identity":
+    case "Current":
+    case "Subexpression":
+    case "MultiSelectHash":
+    case "MultiSelectList":
+    case "Ternary":
+    case "Comparator":
+    case "Arithmetic":
+    case "NotExpression":
+      return true;
+    case "Pipe":
+      return isStreamableNode(node.left) && isStreamableNode(node.right);
+    default:
+      return false;
+  }
+}
+async function* evaluateStreamNode(source, node, interpreter, options) {
+  const deadline = options?.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : 0;
+  function checkDeadline() {
+    if (deadline > 0 && Date.now() >= deadline) {
+      throw new Error(`Query execution timed out after ${options?.timeoutMs}ms`);
+    }
+  }
+  switch (node.type) {
+    case "Projection": {
+      const { left, right } = node;
+      let streamSource = source;
+      if (left.type === "IndexExpression" && left.right.type === "Slice") {
+        streamSource = evaluateStreamNode(source, left, interpreter, options);
+      }
+      if (right.type === "Identity" || right.type === "Current") {
+        for await (const item of streamSource) {
+          checkDeadline();
+          if (item !== null && item !== void 0) {
+            yield item;
+          }
+        }
+        return;
+      }
+      if (right.type === "Field") {
+        const key = right.name;
+        for await (const item of streamSource) {
+          checkDeadline();
+          if (item && typeof item === "object" && !Array.isArray(item)) {
+            const val = item[key];
+            if (val !== void 0 && val !== null) {
+              yield val;
+            }
+          }
+        }
+        return;
+      }
+      for await (const item of streamSource) {
+        checkDeadline();
+        const res = interpreter.visit(right, item);
+        if (res !== null && res !== void 0) {
+          yield res;
+        }
+      }
+      return;
+    }
+    case "IndexExpression": {
+      if (node.right.type === "Slice" && (node.left.type === "Identity" || node.left.type === "Current")) {
+        const slice = node.right;
+        const start = slice.start ?? 0;
+        const stop = slice.stop ?? Infinity;
+        const step = slice.step ?? 1;
+        if (start >= 0 && stop >= 0 && step > 0) {
+          let index = 0;
+          for await (const item of source) {
+            checkDeadline();
+            if (index >= stop) {
+              break;
+            }
+            if (index >= start && (index - start) % step === 0) {
+              yield item;
+            }
+            index++;
+            if (index >= stop) {
+              break;
+            }
+          }
+          return;
+        }
+        const collected = [];
+        for await (const item of source) {
+          checkDeadline();
+          collected.push(item);
+          if (options?.maxOutputSize !== void 0 && collected.length > options.maxOutputSize) {
+            throw new Error(`Output size exceeds maximum allowed size of ${options.maxOutputSize}`);
+          }
+        }
+        const result = interpreter.search(node, collected, options);
+        if (Array.isArray(result)) {
+          for (const item of result) {
+            yield item;
+          }
+        }
+        return;
+      }
+      for await (const item of source) {
+        checkDeadline();
+        const res = interpreter.visit(node, item);
+        if (res !== null && res !== void 0) {
+          yield res;
+        }
+      }
+      return;
+    }
+    case "FilterProjection": {
+      const { condition, right } = node;
+      if (right.type === "Identity" || right.type === "Current") {
+        for await (const item of source) {
+          checkDeadline();
+          if (!isFalse(interpreter.visit(condition, item))) {
+            yield item;
+          }
+        }
+        return;
+      }
+      if (right.type === "Field") {
+        const key = right.name;
+        for await (const item of source) {
+          checkDeadline();
+          if (!isFalse(interpreter.visit(condition, item))) {
+            if (item && typeof item === "object" && !Array.isArray(item)) {
+              const val = item[key];
+              if (val !== void 0 && val !== null) {
+                yield val;
+              }
+            }
+          }
+        }
+        return;
+      }
+      for await (const item of source) {
+        checkDeadline();
+        if (!isFalse(interpreter.visit(condition, item))) {
+          const res = interpreter.visit(right, item);
+          if (res !== null && res !== void 0) {
+            yield res;
+          }
+        }
+      }
+      return;
+    }
+    case "Pipe": {
+      const leftStream = evaluateStreamNode(source, node.left, interpreter, options);
+      if (isStreamableNode(node.right)) {
+        for await (const res of evaluateStreamNode(leftStream, node.right, interpreter, options)) {
+          yield res;
+        }
+      } else {
+        const collected = [];
+        for await (const item of leftStream) {
+          checkDeadline();
+          collected.push(item);
+          if (options?.maxOutputSize !== void 0 && collected.length > options.maxOutputSize) {
+            throw new Error(`Output size exceeds maximum allowed size of ${options.maxOutputSize}`);
+          }
+        }
+        const result = interpreter.search(node.right, collected, options);
+        if (result !== null && result !== void 0) {
+          yield result;
+        }
+      }
+      return;
+    }
+    case "Identity":
+    case "Current": {
+      for await (const item of source) {
+        checkDeadline();
+        yield item;
+      }
+      return;
+    }
+    case "Field": {
+      const key = node.name;
+      for await (const item of source) {
+        checkDeadline();
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          const val = item[key];
+          if (val !== void 0 && val !== null) {
+            yield val;
+          }
+        }
+      }
+      return;
+    }
+    default: {
+      if (isStreamableNode(node)) {
+        for await (const item of source) {
+          checkDeadline();
+          const res = interpreter.visit(node, item);
+          if (res !== null && res !== void 0) {
+            yield res;
+          }
+        }
+        return;
+      }
+      const collected = [];
+      for await (const item of source) {
+        checkDeadline();
+        collected.push(item);
+        if (options?.maxOutputSize !== void 0 && collected.length > options.maxOutputSize) {
+          throw new Error(`Output size exceeds maximum allowed size of ${options.maxOutputSize}`);
+        }
+      }
+      const result = interpreter.search(node, collected, options);
+      if (result !== null && result !== void 0) {
+        yield result;
+      }
+      return;
+    }
+  }
+}
+function isExpressionNode(val) {
+  return typeof val === "object" && val !== null && "type" in val && typeof val.type === "string" && !(Symbol.iterator in val) && !(Symbol.asyncIterator in val);
+}
+async function* searchStream(sourceOrExpression, expressionOrSource, options) {
+  let expression2;
+  let source;
+  if (typeof sourceOrExpression === "string" || isExpressionNode(sourceOrExpression)) {
+    expression2 = sourceOrExpression;
+    source = expressionOrSource;
+  } else {
+    source = sourceOrExpression;
+    expression2 = expressionOrSource;
+  }
+  if (typeof expression2 !== "string" && !isExpressionNode(expression2)) {
+    throw new TypeError("Expression must be a string or AST ExpressionNode");
+  }
+  const ast = typeof expression2 === "string" ? Parser_default.parse(expression2, options) : expression2;
+  if (options) {
+    const fnError = findDisallowedFunction(ast, options);
+    if (fnError) {
+      throw new Error(fnError);
+    }
+  }
+  const interpreter = new TreeInterpreter(options);
+  interpreter.runtime._functionTable = TreeInterpreterInstance.runtime._functionTable;
+  const items = normalizeSource(source, options);
+  const results = evaluateStreamNode(items, ast, interpreter, options);
+  const limit = options?.limit;
+  const maxOutputSize = options?.maxOutputSize;
+  let count = 0;
+  for await (const result of results) {
+    yield result;
+    count++;
+    if (limit !== void 0 && count >= limit) {
+      break;
+    }
+    if (maxOutputSize !== void 0 && count > maxOutputSize) {
+      throw new Error(`Output size exceeds maximum allowed size of ${maxOutputSize}`);
+    }
+  }
+}
+
 // src/index.ts
 var TYPE_ANY = 1 /* TYPE_ANY */;
 var TYPE_ARRAY = 3 /* TYPE_ARRAY */;
+var TYPE_ARRAY_ARRAY = 11 /* TYPE_ARRAY_ARRAY */;
 var TYPE_ARRAY_NUMBER = 8 /* TYPE_ARRAY_NUMBER */;
+var TYPE_ARRAY_OBJECT = 10 /* TYPE_ARRAY_OBJECT */;
 var TYPE_ARRAY_STRING = 9 /* TYPE_ARRAY_STRING */;
 var TYPE_BOOLEAN = 5 /* TYPE_BOOLEAN */;
 var TYPE_EXPREF = 6 /* TYPE_EXPREF */;
@@ -2032,8 +2589,37 @@ var TYPE_NUMBER = 0 /* TYPE_NUMBER */;
 var TYPE_OBJECT = 4 /* TYPE_OBJECT */;
 var TYPE_STRING = 2 /* TYPE_STRING */;
 function compile(expression2, options) {
+  return Parser_default.parse(expression2, options);
+}
+function compileQuery(expression2, options) {
   const nodeTree = Parser_default.parse(expression2, options);
-  return nodeTree;
+  const fn = function(data) {
+    return TreeInterpreter_default.search(nodeTree, data, options);
+  };
+  fn.search = (data) => TreeInterpreter_default.search(nodeTree, data, options);
+  fn.searchStream = (source, streamOptions) => searchStream(source, nodeTree, { ...options, ...streamOptions });
+  fn.ast = nodeTree;
+  return fn;
+}
+function validate(expression2, options) {
+  if (typeof expression2 !== "string") {
+    return { valid: false, error: "Expression must be a string" };
+  }
+  try {
+    const ast = Parser_default.parse(expression2, options);
+    if (options) {
+      const fnError = findDisallowedFunction(ast, options);
+      if (fnError) {
+        return { valid: false, error: fnError };
+      }
+    }
+    return { valid: true, ast };
+  } catch (err) {
+    return {
+      valid: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 function tokenize(expression2, options) {
   return Lexer_default.tokenize(expression2, options);
@@ -2059,13 +2645,36 @@ var getCustomFunctions = () => {
 var clearCustomFunctions = () => {
   TreeInterpreter_default.runtime.clearCustomFunctions();
 };
+var MAX_CACHE_SIZE = 1e3;
+var astCache = /* @__PURE__ */ new Map();
 function search(data, expression2, options) {
-  const nodeTree = Parser_default.parse(expression2, options);
-  return TreeInterpreter_default.search(nodeTree, data);
+  let nodeTree;
+  if (!options) {
+    nodeTree = astCache.get(expression2);
+    if (!nodeTree) {
+      nodeTree = Parser_default.parse(expression2);
+      if (astCache.size >= MAX_CACHE_SIZE) {
+        const firstKey = astCache.keys().next().value;
+        if (firstKey !== void 0) {
+          astCache.delete(firstKey);
+        }
+      }
+      astCache.set(expression2, nodeTree);
+    }
+  } else {
+    nodeTree = Parser_default.parse(expression2, options);
+  }
+  return TreeInterpreter_default.search(nodeTree, data, options);
+}
+function Scope() {
+  return new ScopeChain();
 }
 var TreeInterpreter2 = TreeInterpreter_default;
 var jmespath = {
   compile,
+  compileQuery,
+  searchStream,
+  validate,
   registerFunction,
   register,
   unregisterFunction,
@@ -2085,8 +2694,12 @@ var jmespath = {
   TYPE_NULL,
   TYPE_NUMBER,
   TYPE_OBJECT,
-  TYPE_STRING
+  TYPE_STRING,
+  TYPE_ARRAY_ARRAY,
+  TYPE_ARRAY_OBJECT,
+  Scope
 };
+var index_default = jmespath;
 
 // src/cli.ts
 var args = getArgs();
@@ -2172,7 +2785,7 @@ function printResult(inputJSON2, expression2, compact = false) {
     throw e;
   }
   try {
-    console.log(JSON.stringify(jmespath.search(parsedInput, expression2, void 0), null, compact ? 0 : 2));
+    console.log(JSON.stringify(index_default.search(parsedInput, expression2, void 0), null, compact ? 0 : 2));
   } catch (e) {
     throw e;
   }