@jmespath-community/jmespath 1.3.0 → 1.4.0

package/dist/index.umd.js

@@ -1,10 +1,88 @@
-var jmespath = (function (exports) {
+var jmespath = (function () {
   'use strict';
 
   var __defProp = Object.defineProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+  // 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) => {
     return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
@@ -54,9 +132,6 @@ var jmespath = (function (exports) {
       if (Array.isArray(obj)) {
         return obj.length === 0;
       }
-      if (obj === null) {
-        return true;
-      }
       return Object.keys(obj).length === 0;
     }
     return false;
@@ -101,112 +176,29 @@ var jmespath = (function (exports) {
   };
   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;
+    return left % right;
   };
 
-  // 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");
-  };
-  var upper = (subject) => subject.toUpperCase();
-
   // src/Lexer.ts
   var basicTokens = {
     "(": "Lparen" /* TOK_LPAREN */,
@@ -388,7 +380,7 @@ var jmespath = (function (exports) {
       }
       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;
@@ -554,15 +546,26 @@ var jmespath = (function (exports) {
     constructor() {
       __publicField(this, "index", 0);
       __publicField(this, "tokens", []);
+      __publicField(this, "depth", 0);
+      __publicField(this, "maxDepth");
+      __publicField(this, "nodeCount", 0);
+      __publicField(this, "maxNodes");
     }
     parse(expression, options) {
       this.loadTokens(expression, 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(expression, options) {
@@ -570,16 +573,32 @@ var jmespath = (function (exports) {
       this.tokens.push({ type: "EOF" /* TOK_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]) {
+      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;
@@ -806,9 +825,13 @@ var jmespath = (function (exports) {
         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"
         };
       }
@@ -968,6 +991,83 @@ var jmespath = (function (exports) {
   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 {
     constructor(text) {
@@ -978,7 +1078,11 @@ var jmespath = (function (exports) {
       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));
@@ -1013,6 +1117,12 @@ var jmespath = (function (exports) {
   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 {
     constructor(interpreter) {
       __publicField(this, "_interpreter");
@@ -1058,28 +1168,30 @@ var jmespath = (function (exports) {
         }
         return null;
       });
-      __publicField(this, "functionEndsWith", (resolvedArgs) => {
-        const [searchStr, suffix] = resolvedArgs;
-        return searchStr.includes(suffix, searchStr.length - suffix.length);
+      __publicField(this, "functionEndsWith", ([searchStr, suffix]) => {
+        return searchStr.endsWith(suffix);
       });
       __publicField(this, "functionFindFirst", this.createFindFunction(findFirst));
       __publicField(this, "functionFindLast", this.createFindFunction(findLast));
       __publicField(this, "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);
       });
       __publicField(this, "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;
       });
       __publicField(this, "functionItems", ([inputValue]) => {
         return Object.entries(inputValue);
@@ -1142,12 +1254,7 @@ var jmespath = (function (exports) {
         return maxRecord || null;
       });
       __publicField(this, "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);
       });
       __publicField(this, "functionMin", ([inputValue]) => {
         if (!inputValue.length) {
@@ -1183,12 +1290,7 @@ var jmespath = (function (exports) {
         return minRecord || null;
       });
       __publicField(this, "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;
       });
       __publicField(this, "functionPadLeft", this.createPadFunction(padLeft));
       __publicField(this, "functionPadRight", this.createPadFunction(padRight));
@@ -1208,12 +1310,12 @@ var jmespath = (function (exports) {
         if (typeName === 2 /* TYPE_STRING */) {
           return new Text(inputValue).reverse();
         }
-        const reversedArray = inputValue.slice(0);
+        const reversedArray = [...inputValue];
         reversedArray.reverse();
         return reversedArray;
       });
       __publicField(this, "functionSort", ([inputValue]) => {
-        if (inputValue.length == 0) {
+        if (inputValue.length <= 1) {
           return inputValue;
         }
         if (typeof inputValue[0] === "string") {
@@ -1222,8 +1324,8 @@ var jmespath = (function (exports) {
         return [...inputValue].sort();
       });
       __publicField(this, "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;
@@ -1258,10 +1360,7 @@ var jmespath = (function (exports) {
         return inputValue.reduce((x, y) => x + y, 0);
       });
       __publicField(this, "functionToArray", ([inputValue]) => {
-        if (this.getTypeName(inputValue) === 3 /* TYPE_ARRAY */) {
-          return inputValue;
-        }
-        return [inputValue];
+        return Array.isArray(inputValue) ? inputValue : [inputValue];
       });
       __publicField(this, "functionToNumber", ([inputValue]) => {
         const typeName = this.getTypeName(inputValue);
@@ -1278,36 +1377,22 @@ var jmespath = (function (exports) {
         return null;
       });
       __publicField(this, "functionToString", ([inputValue]) => {
-        if (this.getTypeName(inputValue) === 2 /* TYPE_STRING */) {
-          return inputValue;
-        }
-        return JSON.stringify(inputValue);
+        return typeof inputValue === "string" ? inputValue : JSON.stringify(inputValue);
       });
       __publicField(this, "functionTrim", this.createTrimFunction(trim));
       __publicField(this, "functionTrimLeft", this.createTrimFunction(trimLeft));
       __publicField(this, "functionTrimRight", this.createTrimFunction(trimRight));
       __publicField(this, "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;
       });
       __publicField(this, "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]));
       });
       this._interpreter = interpreter;
       this._functionTable = this.buildFunctionTable();
@@ -1607,34 +1692,18 @@ var jmespath = (function (exports) {
       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) {
@@ -1727,26 +1796,111 @@ var jmespath = (function (exports) {
   // src/TreeInterpreter.ts
   var emptyScopeChain = new ScopeChain();
   var TreeInterpreter = class _TreeInterpreter {
-    constructor() {
+    constructor(options) {
       __publicField(this, "runtime");
       __publicField(this, "_rootValue", null);
       __publicField(this, "_scope");
+      __publicField(this, "_options");
+      __publicField(this, "_depth", 0);
+      __publicField(this, "_deadline", 0);
       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);
@@ -1762,16 +1916,11 @@ var jmespath = (function (exports) {
           }
           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);
+          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;
@@ -1803,51 +1952,27 @@ var jmespath = (function (exports) {
             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;
@@ -1856,14 +1981,42 @@ var jmespath = (function (exports) {
             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;
@@ -1927,7 +2080,9 @@ var jmespath = (function (exports) {
         }
         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;
@@ -1936,6 +2091,7 @@ var jmespath = (function (exports) {
           for (const child of node.children) {
             collected.push(this.visit(child, value));
           }
+          this.checkOutputSize(collected);
           return collected;
         }
         case "MultiSelectHash": {
@@ -1943,6 +2099,7 @@ var jmespath = (function (exports) {
           for (const child of node.children) {
             collected[child.name] = this.visit(child.value, value);
           }
+          this.checkOutputSize(collected);
           return collected;
         }
         case "OrExpression": {
@@ -1966,11 +2123,19 @@ var jmespath = (function (exports) {
         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 args = [];
           for (const child of node.children) {
             args.push(this.visit(child, value));
           }
-          return this.runtime.callFunction(node.name, args);
+          const res = this.runtime.callFunction(node.name, args);
+          this.checkOutputSize(res);
+          return res;
         }
         case "ExpressionReference":
           return {
@@ -2008,14 +2173,19 @@ var jmespath = (function (exports) {
       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;
@@ -2024,6 +2194,391 @@ var jmespath = (function (exports) {
   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 expression;
+    let source;
+    if (typeof sourceOrExpression === "string" || isExpressionNode(sourceOrExpression)) {
+      expression = sourceOrExpression;
+      source = expressionOrSource;
+    } else {
+      source = sourceOrExpression;
+      expression = expressionOrSource;
+    }
+    if (typeof expression !== "string" && !isExpressionNode(expression)) {
+      throw new TypeError("Expression must be a string or AST ExpressionNode");
+    }
+    const ast = typeof expression === "string" ? Parser_default.parse(expression, options) : expression;
+    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 */;
@@ -2038,8 +2593,37 @@ var jmespath = (function (exports) {
   var TYPE_OBJECT = 4 /* TYPE_OBJECT */;
   var TYPE_STRING = 2 /* TYPE_STRING */;
   function compile(expression, options) {
+    return Parser_default.parse(expression, options);
+  }
+  function compileQuery(expression, options) {
     const nodeTree = Parser_default.parse(expression, 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(expression, options) {
+    if (typeof expression !== "string") {
+      return { valid: false, error: "Expression must be a string" };
+    }
+    try {
+      const ast = Parser_default.parse(expression, 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(expression, options) {
     return Lexer_default.tokenize(expression, options);
@@ -2065,9 +2649,26 @@ var jmespath = (function (exports) {
   var clearCustomFunctions = () => {
     TreeInterpreter_default.runtime.clearCustomFunctions();
   };
+  var MAX_CACHE_SIZE = 1e3;
+  var astCache = /* @__PURE__ */ new Map();
   function search(data, expression, options) {
-    const nodeTree = Parser_default.parse(expression, options);
-    return TreeInterpreter_default.search(nodeTree, data);
+    let nodeTree;
+    if (!options) {
+      nodeTree = astCache.get(expression);
+      if (!nodeTree) {
+        nodeTree = Parser_default.parse(expression);
+        if (astCache.size >= MAX_CACHE_SIZE) {
+          const firstKey = astCache.keys().next().value;
+          if (firstKey !== void 0) {
+            astCache.delete(firstKey);
+          }
+        }
+        astCache.set(expression, nodeTree);
+      }
+    } else {
+      nodeTree = Parser_default.parse(expression, options);
+    }
+    return TreeInterpreter_default.search(nodeTree, data, options);
   }
   function Scope() {
     return new ScopeChain();
@@ -2075,6 +2676,9 @@ var jmespath = (function (exports) {
   var TreeInterpreter2 = TreeInterpreter_default;
   var jmespath = {
     compile,
+    compileQuery,
+    searchStream,
+    validate,
     registerFunction,
     register,
     unregisterFunction,
@@ -2094,40 +2698,15 @@ var jmespath = (function (exports) {
     TYPE_NULL,
     TYPE_NUMBER,
     TYPE_OBJECT,
-    TYPE_STRING
+    TYPE_STRING,
+    TYPE_ARRAY_ARRAY,
+    TYPE_ARRAY_OBJECT,
+    Scope
   };
+  var index_default = jmespath;
 
-  exports.Scope = Scope;
-  exports.TYPE_ANY = TYPE_ANY;
-  exports.TYPE_ARRAY = TYPE_ARRAY;
-  exports.TYPE_ARRAY_ARRAY = TYPE_ARRAY_ARRAY;
-  exports.TYPE_ARRAY_NUMBER = TYPE_ARRAY_NUMBER;
-  exports.TYPE_ARRAY_OBJECT = TYPE_ARRAY_OBJECT;
-  exports.TYPE_ARRAY_STRING = TYPE_ARRAY_STRING;
-  exports.TYPE_BOOLEAN = TYPE_BOOLEAN;
-  exports.TYPE_EXPREF = TYPE_EXPREF;
-  exports.TYPE_NULL = TYPE_NULL;
-  exports.TYPE_NUMBER = TYPE_NUMBER;
-  exports.TYPE_OBJECT = TYPE_OBJECT;
-  exports.TYPE_STRING = TYPE_STRING;
-  exports.TreeInterpreter = TreeInterpreter2;
-  exports.clearCustomFunctions = clearCustomFunctions;
-  exports.compile = compile;
-  exports.default = jmespath;
-  exports.getCustomFunctions = getCustomFunctions;
-  exports.getRegisteredFunctions = getRegisteredFunctions;
-  exports.isRegistered = isRegistered;
-  exports.jmespath = jmespath;
-  exports.register = register;
-  exports.registerFunction = registerFunction;
-  exports.search = search;
-  exports.tokenize = tokenize;
-  exports.unregisterFunction = unregisterFunction;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-  return exports;
+  return index_default;
 
-})({});
+})();
 //# sourceMappingURL=index.umd.js.map
 //# sourceMappingURL=index.umd.js.map