json-p3 2.2.1 → 2.3.0

package/dist/json-p3.cjs.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 2.2.1
+ * json-p3 version 2.3.0
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -337,10 +337,7 @@ class JSONPointer {
   }
   static encode(tokens) {
     if (!tokens.length) return "";
-    return (
-      // eslint-disable-next-line prefer-template
-      "/" + tokens.map(token => token.replaceAll("~", "~0").replaceAll("/", "~1")).join("/")
-    );
+    return "/" + tokens.map(token => token.replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
   }
 
   /**
@@ -357,8 +354,7 @@ class JSONPointer {
    * If the value pointed to by _pointer_ does not exist in _value_, and
    * no fallback value is given.
    */
-  resolve(value) {
-    let fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : UNDEFINED;
+  resolve(value, fallback = UNDEFINED) {
     try {
       return this.tokens.reduce(this.getItem.bind(this), value);
     } catch (error) {
@@ -463,10 +459,7 @@ class JSONPointer {
    * @returns A new JSON Pointer that is the concatenation of all tokens or
    * "parts".
    */
-  join() {
-    for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
-      tokens[_key] = arguments[_key];
-    }
+  join(...tokens) {
     if (!tokens.length) {
       return this;
     }
@@ -515,7 +508,7 @@ class JSONPointer {
   }
 }
 const RE_RELATIVE_POINTER = /(?<ORIGIN>\d+)(?<INDEX_G>(?<SIGN>[+-])(?<INDEX>\d))?(?<POINTER>.*)/s;
-const RE_INT = /(0|[1-9][0-9]*)/;
+const RE_INT = /(0|[1-9]\d*)/;
 
 /**
  * A relative JSON Pointer.
@@ -634,8 +627,7 @@ class RelativeJSONPointer {
  * @throws {@link JSONPointerSyntaxError}
  * If _pointer_ is malformed according to RFC 6901.
  */
-function resolve(pointer, value) {
-  let fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : UNDEFINED;
+function resolve(pointer, value, fallback = UNDEFINED) {
   return new JSONPointer(pointer).resolve(value, fallback);
 }
 
@@ -739,10 +731,7 @@ class JSONPathNode {
       ...defaultSerializationOptions,
       ...options
     };
-    return (
-      // eslint-disable-next-line prefer-template
-      "$" + this.location.map(s => isString(s) ? this.decodeNameLocation(s, opts) : `[${s}]`).join("")
-    );
+    return "$" + this.location.map(s => isString(s) ? this.decodeNameLocation(s, opts) : `[${s}]`).join("");
   }
 
   /**
@@ -1137,16 +1126,16 @@ var expression = /*#__PURE__*/Object.freeze({
 });
 
 class Count {
-  argTypes = (() => [FunctionExpressionType.NodesType])();
-  returnType = (() => FunctionExpressionType.ValueType)();
+  argTypes = [FunctionExpressionType.NodesType];
+  returnType = FunctionExpressionType.ValueType;
   call(nodes) {
     return nodes.length;
   }
 }
 
 class Length {
-  argTypes = (() => [FunctionExpressionType.ValueType])();
-  returnType = (() => FunctionExpressionType.ValueType)();
+  argTypes = [FunctionExpressionType.ValueType];
+  returnType = FunctionExpressionType.ValueType;
   call(value) {
     if (isArray(value) || isString(value)) return value.length;
     if (isObject(value)) return Object.keys(value).length;
@@ -1158,9 +1147,7 @@ class Length {
  * A Least Recently Used cache, implemented as an extended Map.
  */
 class LRUCache extends Map {
-  constructor() {
-    let maxSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 128;
-    let entries = arguments.length > 1 ? arguments[1] : undefined;
+  constructor(maxSize = 128, entries) {
     if (entries !== undefined) {
       super(entries);
     } else {
@@ -2478,11 +2465,10 @@ var check_1 = {
 var check$1 = check_1.check;
 
 class Match {
-  argTypes = (() => [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType])();
-  returnType = (() => FunctionExpressionType.LogicalType)();
+  argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
+  returnType = FunctionExpressionType.LogicalType;
   #cache;
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     this.options = options;
     this.cacheSize = options.cacheSize ?? 10;
     this.throwErrors = options.throwErrors ?? false;
@@ -2527,11 +2513,10 @@ class Match {
 }
 
 class Search {
-  argTypes = (() => [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType])();
-  returnType = (() => FunctionExpressionType.LogicalType)();
+  argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
+  returnType = FunctionExpressionType.LogicalType;
   #cache;
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     this.options = options;
     this.cacheSize = options.cacheSize ?? 10;
     this.throwErrors = options.throwErrors ?? false;
@@ -2576,8 +2561,8 @@ class Search {
 }
 
 class Value {
-  argTypes = (() => [FunctionExpressionType.NodesType])();
-  returnType = (() => FunctionExpressionType.ValueType)();
+  argTypes = [FunctionExpressionType.NodesType];
+  returnType = FunctionExpressionType.ValueType;
   call(nodes) {
     if (nodes.length === 1) return nodes.nodes[0].value;
     return Nothing;
@@ -2593,6 +2578,7 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
   TokenKind["COMMA"] = "TOKEN_COMMA";
   TokenKind["CURRENT"] = "TOKEN_CURRENT_VALUE";
   TokenKind["CURRENT_KEY"] = "TOKEN_CURRENT_KEY";
+  // non-standard, default `#`
   TokenKind["DDOT"] = "TOKEN_DDOT";
   TokenKind["DOT"] = "TOKEN_DOT";
   TokenKind["DOUBLE_QUOTE_STRING"] = "TOKEN_DOUBLE_QUOTE_STRING";
@@ -2606,10 +2592,15 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
   TokenKind["GT"] = "TOKEN_GT";
   TokenKind["INDEX"] = "TOKEN_INDEX";
   TokenKind["KEY"] = "TOKEN_KEY";
+  // non-standard, default `~<name>`
   TokenKind["KEY_DOUBLE_QUOTE_STRING"] = "TOKEN_KEY_DOUBLE_QUOTE_STRING";
+  // non-standard, `~"<name>"`
   TokenKind["KEY_SINGLE_QUOTE_STRING"] = "TOKEN_KEY_SINGLE_QUOTE_STRING";
+  // non-standard, `~'<name>'`
   TokenKind["KEYS"] = "TOKEN_KEYS";
+  // non-standard, default `~`
   TokenKind["KEYS_FILTER"] = "TOKEN_KEYS_FILTER";
+  // non-standard, `~?<expression>`
   TokenKind["LBRACKET"] = "TOKEN_LBRACKET";
   TokenKind["LE"] = "TOKEN_LE";
   TokenKind["LG"] = "TOKEN_LG";
@@ -2693,7 +2684,7 @@ class TokenStream {
 const exponentPattern = /[eE][+-]?\d+/y;
 const functionNamePattern = /[a-z][a-z_0-9]*/y;
 const indexPattern = /-?\d+/y;
-const intPattern = /-?[0-9]+/y;
+const intPattern = /-?\d+/y;
 const namePattern = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/y;
 const whitespace = new Set([" ", "\n", "\t", "\r"]);
 const nameFirstPattern = /[\u0080-\uFFFFa-zA-Z_]/; // don't set sticky bit
@@ -2718,7 +2709,13 @@ class Lexer {
    * If the stack is empty, we are not in a function call. Remember that
    * function arguments can use arbitrarily nested in parentheses.
    */
-  parenStack = [];
+  funcCallStack = [];
+
+  /**
+   * A stack of parentheses and square brackets used to check for balanced
+   * brackets.
+   */
+  bracketStack = [];
 
   /** Tokens resulting from tokenizing a JSONPath query. */
   tokens = [];
@@ -2847,9 +2844,19 @@ function lex(environment, path) {
 function tokenize(environment, path) {
   const [lexer, tokens] = lex(environment, path);
   lexer.run();
+
+  // If there's an error, it will be the last token with kind set to ERROR.
   if (tokens.length && tokens[tokens.length - 1].kind === TokenKind.ERROR) {
     throw new JSONPathSyntaxError(tokens[tokens.length - 1].value, tokens[tokens.length - 1]);
   }
+
+  // If the bracket stack is not empty, we hav unbalanced brackets.
+  // This might not be reachable.
+  if (lexer.bracketStack.length !== 0) {
+    const [ch, index] = lexer.bracketStack[lexer.bracketStack.length - 1];
+    const msg = "unbalanced brackets";
+    throw new JSONPathSyntaxError(msg, new Token(TokenKind.ERROR, ch, index, path));
+  }
   return tokens;
 }
 function lexRoot(l) {
@@ -2879,6 +2886,7 @@ function lexSegment(l) {
       }
       return lexDotSelector;
     case "[":
+      l.bracketStack.push(["[", l.start]);
       l.emit(TokenKind.LBRACKET);
       return lexInsideBracketedSelection;
     default:
@@ -2935,6 +2943,7 @@ function lexDescendantSelection(l) {
       l.emit(TokenKind.WILD);
       return lexSegment;
     case "[":
+      l.bracketStack.push(["[", l.start]);
       l.emit(TokenKind.LBRACKET);
       return lexInsideBracketedSelection;
     default:
@@ -2993,7 +3002,6 @@ function lexInsideBracketedSelection(l) {
       continue;
     }
     if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
-      // FIXME: fall back to legacy behavior if keysPattern is not the default
       switch (l.peek()) {
         case "'":
           l.ignore(); // ~
@@ -3016,6 +3024,12 @@ function lexInsideBracketedSelection(l) {
     const ch = l.next();
     switch (ch) {
       case "]":
+        if (l.bracketStack.length === 0 || l.bracketStack[l.bracketStack.length - 1][0] !== "[") {
+          l.backup();
+          l.error("unbalanced brackets");
+          return null;
+        }
+        l.bracketStack.pop();
         l.emit(TokenKind.RBRACKET);
         return lexSegment;
       case "":
@@ -3057,17 +3071,13 @@ function lexInsideFilter(l) {
         return null;
       case "]":
         l.filterLevel -= 1;
-        if (l.parenStack.length === 1) {
-          l.error("unbalanced parentheses");
-          return null;
-        }
         l.backup();
         return lexInsideBracketedSelection;
       case ",":
         l.emit(TokenKind.COMMA);
         // If we have unbalanced parens, we are inside a function call and a
         // comma separates arguments. Otherwise a comma separates selectors.
-        if (l.parenStack.length) continue;
+        if (l.funcCallStack.length) continue;
         l.filterLevel -= 1;
         return lexInsideBracketedSelection;
       case "'":
@@ -3075,18 +3085,25 @@ function lexInsideFilter(l) {
       case '"':
         return lexDoubleQuoteStringInsideFilterExpression;
       case "(":
+        l.bracketStack.push(["(", l.start]);
         l.emit(TokenKind.LPAREN);
         // Are we in a function call? If so, a function argument contains parens.
-        if (l.parenStack.length) l.parenStack[l.parenStack.length - 1] += 1;
+        if (l.funcCallStack.length) l.funcCallStack[l.funcCallStack.length - 1] += 1;
         continue;
       case ")":
+        if (l.bracketStack.length === 0 || l.bracketStack[l.bracketStack.length - 1][0] !== "(") {
+          l.backup();
+          l.error("unbalanced brackets");
+          return null;
+        }
+        l.bracketStack.pop();
         l.emit(TokenKind.RPAREN);
         // Are we closing a function call or a parenthesized expression?
-        if (l.parenStack.length) {
-          if (l.parenStack[l.parenStack.length - 1] === 1) {
-            l.parenStack.pop();
+        if (l.funcCallStack.length) {
+          if (l.funcCallStack[l.funcCallStack.length - 1] === 1) {
+            l.funcCallStack.pop();
           } else {
-            l.parenStack[l.parenStack.length - 1] -= 1;
+            l.funcCallStack[l.funcCallStack.length - 1] -= 1;
           }
         }
         continue;
@@ -3183,8 +3200,9 @@ function lexInsideFilter(l) {
         // functions
         if (l.acceptMatchRun(functionNamePattern) && l.peek() === "(") {
           // Keep track of parentheses for this function call.
-          l.parenStack.push(1);
+          l.funcCallStack.push(1);
           l.emit(TokenKind.FUNCTION);
+          l.bracketStack.push(["(", l.start]);
           l.next();
           l.ignore();
           continue;
@@ -3375,10 +3393,7 @@ class SliceSelector extends JSONPathSelector {
     const step = this.step ? this.step : "1";
     return `${start}:${stop}:${step}`;
   }
-  checkRange() {
-    for (var _len = arguments.length, indices = new Array(_len), _key = 0; _key < _len; _key++) {
-      indices[_key] = arguments[_key];
-    }
+  checkRange(...indices) {
     for (const index of indices) {
       if (index !== undefined && (index < this.environment.minIntIndex || index > this.environment.maxIntIndex)) {
         throw new JSONPathIndexError("index out of range", this.token);
@@ -3665,53 +3680,45 @@ class DescendantSegment extends JSONPathSegment {
   toString(options) {
     return `..[${this.selectors.map(s => s.toString(options)).join(", ")}]`;
   }
-  visit(node) {
-    var _this = this;
-    let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-    return function* () {
-      if (depth >= _this.environment.maxRecursionDepth) {
-        throw new JSONPathRecursionLimitError("recursion limit reached", _this.token);
+  *visit(node, depth = 1) {
+    if (depth >= this.environment.maxRecursionDepth) {
+      throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
+    }
+    yield node;
+    if (isArray(node.value)) {
+      for (let i = 0; i < node.value.length; i++) {
+        const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
+        yield* this.visit(_node, depth + 1);
+      }
+    } else if (isObject(node.value)) {
+      for (const [key, value] of this.environment.entries(node.value)) {
+        const _node = new JSONPathNode(value, node.location.concat(key), node.root);
+        yield* this.visit(_node, depth + 1);
       }
+    }
+  }
+  *nondeterministicVisit(root, depth = 1) {
+    let queue = Array.from(this.nondeterministicChildren(root)).map(node => [node, depth]);
+    yield root;
+    while (queue.length) {
+      const [node, _depth] = queue.shift();
       yield node;
-      if (isArray(node.value)) {
-        for (let i = 0; i < node.value.length; i++) {
-          const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
-          yield* _this.visit(_node, depth + 1);
-        }
-      } else if (isObject(node.value)) {
-        for (const [key, value] of _this.environment.entries(node.value)) {
-          const _node = new JSONPathNode(value, node.location.concat(key), node.root);
-          yield* _this.visit(_node, depth + 1);
-        }
+      if (_depth >= this.environment.maxRecursionDepth) {
+        throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
       }
-    }();
-  }
-  nondeterministicVisit(root) {
-    var _this2 = this;
-    let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-    return function* () {
-      let queue = Array.from(_this2.nondeterministicChildren(root)).map(node => [node, depth]);
-      yield root;
-      while (queue.length) {
-        const [node, _depth] = queue.shift();
-        yield node;
-        if (_depth >= _this2.environment.maxRecursionDepth) {
-          throw new JSONPathRecursionLimitError("recursion limit reached", _this2.token);
-        }
 
-        // Visit child nodes now or queue them for later?
-        const visitChildren = Math.random() < 0.5;
-        for (const child of _this2.nondeterministicChildren(node)) {
-          if (visitChildren) {
-            yield child;
-            const grandchildren = Array.from(_this2.nondeterministicChildren(child)).map(n => [n, _depth + 2]);
-            queue = interleave(queue, grandchildren);
-          } else {
-            queue.push([child, _depth + 1]);
-          }
+      // Visit child nodes now or queue them for later?
+      const visitChildren = Math.random() < 0.5;
+      for (const child of this.nondeterministicChildren(node)) {
+        if (visitChildren) {
+          yield child;
+          const grandchildren = Array.from(this.nondeterministicChildren(child)).map(n => [n, _depth + 2]);
+          queue = interleave(queue, grandchildren);
+        } else {
+          queue.push([child, _depth + 1]);
         }
       }
-    }();
+    }
   }
   *nondeterministicChildren(node) {
     if (isString(node.value)) return;
@@ -3977,8 +3984,7 @@ class Parser {
     }
     return segments;
   }
-  parseQuery(stream) {
-    let inFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  parseQuery(stream, inFilter = false) {
     const segments = [];
     loop: for (;;) {
       switch (stream.current.kind) {
@@ -4130,8 +4136,7 @@ class Parser {
     }
     return selectors;
   }
-  parseFilter(stream) {
-    let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  parseFilter(stream, keys = false) {
     const tok = stream.next();
     const expr = this.parseFilterExpression(stream);
     if (expr instanceof FunctionExtension) {
@@ -4245,8 +4250,7 @@ class Parser {
     stream.expect(TokenKind.RPAREN);
     return new FunctionExtension(tok, tok.value, this.environment.checkWellTypedness(tok, args));
   }
-  parseFilterExpression(stream) {
-    let precedence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : PRECEDENCE_LOWEST;
+  parseFilterExpression(stream, precedence = PRECEDENCE_LOWEST) {
     const func = this.tokenMap.get(stream.current.kind);
     if (!func) {
       let msg;
@@ -4316,7 +4320,6 @@ class Parser {
             rv.push(this.stringFromCodePoint(codepoint, token));
             break;
           default:
-            // TODO: This is unreachable. The lexer will catch unknown escape sequences.
             throw new JSONPathSyntaxError(`unknown escape sequence at index ${token.index + index - 1}`, token);
         }
       } else {
@@ -4496,12 +4499,11 @@ class JSONPathEnvironment {
    * A map of function names to objects implementing the {@link FilterFunction}
    * interface. You are free to set or delete custom filter functions directly.
    */
-  functionRegister = (() => new Map())();
+  functionRegister = new Map();
   /**
    * @param options - Environment configuration options.
    */
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     this.strict = options.strict ?? true;
     this.maxIntIndex = options.maxIntIndex ?? Math.pow(2, 53) - 1;
     this.minIntIndex = options.maxIntIndex ?? -Math.pow(2, 53) + 1;
@@ -4646,11 +4648,10 @@ class JSONPathEnvironment {
  * value and it contains a property matching the second argument.
  */
 class Has {
-  argTypes = (() => [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType])();
-  returnType = (() => FunctionExpressionType.LogicalType)();
+  argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
+  returnType = FunctionExpressionType.LogicalType;
   #cache;
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     this.options = options;
     this.cacheSize = options.cacheSize ?? 10;
     this.throwErrors = options.throwErrors ?? false;
@@ -5299,7 +5300,7 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "2.2.1";
+const version = "2.3.0";
 
 exports.DEFAULT_ENVIRONMENT = DEFAULT_ENVIRONMENT;
 exports.FunctionExpressionType = FunctionExpressionType;