json-p3 1.1.1 → 1.2.1

package/dist/json-p3.esm.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.1.1
+ * json-p3 version 1.2.1
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -1180,6 +1180,8 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
   TokenKind["GE"] = "TOKEN_GE";
   TokenKind["GT"] = "TOKEN_GT";
   TokenKind["INDEX"] = "TOKEN_INDEX";
+  TokenKind["KEY"] = "TOKEN_KEY";
+  TokenKind["KEYS"] = "TOKEN_KEYS";
   TokenKind["LBRACKET"] = "TOKEN_LBRACKET";
   TokenKind["LE"] = "TOKEN_LE";
   TokenKind["LG"] = "TOKEN_LG";
@@ -1249,6 +1251,9 @@ class TokenStream {
   }
 }
 
+/** A lexer that accepts additional, non-standard tokens. */
+
+
 // These regular expressions are to be used with Lexer.acceptMatchRun(),
 // which expects the sticky flag to be set.
 const exponentPattern = /e[+-]?\d+/y;
@@ -1288,7 +1293,8 @@ class Lexer {
   /**
    * @param path - A JSONPath query.
    */
-  constructor(path) {
+  constructor(environment, path) {
+    this.environment = environment;
     this.path = path;
   }
   get pos() {
@@ -1388,8 +1394,8 @@ class Lexer {
  * @returns A two-tuple containing a lexer for _path_ and an array to populate
  * with tokens.
  */
-function lex(path) {
-  const lexer = new Lexer(path);
+function lex(environment, path) {
+  const lexer = new Lexer(environment, path);
   return [lexer, lexer.tokens];
 }
 
@@ -1398,8 +1404,8 @@ function lex(path) {
  * @param path - A JSONPath query.
  * @returns Tokens to be parsed by the parser.
  */
-function tokenize(path) {
-  const [lexer, tokens] = lex(path);
+function tokenize(environment, path) {
+  const [lexer, tokens] = lex(environment, path);
   lexer.run();
   if (tokens.length && tokens[tokens.length - 1].kind === TokenKind.ERROR) {
     throw new JSONPathSyntaxError(tokens[tokens.length - 1].value, tokens[tokens.length - 1]);
@@ -1452,6 +1458,16 @@ function lexSegment(l) {
  * @returns -
  */
 function lexDescendantSelection(l) {
+  if (l.acceptMatchRun(namePattern)) {
+    // Shorthand name
+    l.emit(TokenKind.NAME);
+    return lexSegment;
+  }
+  if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
+    // Non-standard keys selector
+    l.emit(TokenKind.KEYS);
+    return lexSegment;
+  }
   const ch = l.next();
   switch (ch) {
     case "":
@@ -1465,13 +1481,8 @@ function lexDescendantSelection(l) {
       return lexInsideBracketedSelection;
     default:
       l.backup();
-      if (l.acceptMatchRun(namePattern)) {
-        l.emit(TokenKind.NAME);
-        return lexSegment;
-      } else {
-        l.error(`unexpected descendent selection token '${ch}'`);
-        return null;
-      }
+      l.error(`unexpected descendent selection token '${ch}'`);
+      return null;
   }
 }
 function lexDotSelector(l) {
@@ -1480,23 +1491,34 @@ function lexDotSelector(l) {
     l.error("unexpected whitespace after dot");
     return null;
   }
-  const ch = l.next();
-  if (ch === "*") {
-    l.emit(TokenKind.WILD);
+  if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
+    l.emit(TokenKind.KEYS);
     return lexSegment;
   }
-  l.backup();
   if (l.acceptMatchRun(namePattern)) {
     l.emit(TokenKind.NAME);
     return lexSegment;
-  } else {
-    l.error(`unexpected shorthand selector '${ch}'`);
-    return null;
   }
+  const ch = l.next();
+  if (ch === "*") {
+    l.emit(TokenKind.WILD);
+    return lexSegment;
+  }
+  l.backup();
+  l.error(`unexpected shorthand selector '${ch}'`);
+  return null;
 }
 function lexInsideBracketedSelection(l) {
   for (;;) {
     l.ignoreWhitespace();
+    if (l.acceptMatchRun(indexPattern)) {
+      l.emit(TokenKind.INDEX);
+      continue;
+    }
+    if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
+      l.emit(TokenKind.KEYS);
+      continue;
+    }
     const ch = l.next();
     switch (ch) {
       case "]":
@@ -1525,10 +1547,6 @@ function lexInsideBracketedSelection(l) {
         return lexDoubleQuoteStringInsideBracketSelection;
       default:
         l.backup();
-        if (l.acceptMatchRun(indexPattern)) {
-          l.emit(TokenKind.INDEX);
-          continue;
-        }
         l.error(`unexpected token '${ch}' in bracketed selection`);
         return null;
     }
@@ -1542,6 +1560,8 @@ function lexInsideFilter(l) {
     const ch = l.next();
     switch (ch) {
       case "":
+        l.error("unclosed bracketed selection");
+        return null;
       case "]":
         l.filterLevel -= 1;
         if (l.parenStack.length === 1) {
@@ -1583,6 +1603,9 @@ function lexInsideFilter(l) {
       case "@":
         l.emit(TokenKind.CURRENT);
         return lexSegment;
+      case "#":
+        l.emit(TokenKind.KEY);
+        return lexSegment;
       case ".":
         l.backup();
         return lexSegment;
@@ -1761,7 +1784,7 @@ class NameSelector extends JSONPathSelector {
   resolve(nodes) {
     const rv = [];
     for (const node of nodes) {
-      if (hasStringKey(node.value, this.name)) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
         rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
       }
     }
@@ -1769,7 +1792,7 @@ class NameSelector extends JSONPathSelector {
   }
   *lazyResolve(nodes) {
     for (const node of nodes) {
-      if (hasStringKey(node.value, this.name)) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
         yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
       }
     }
@@ -1845,7 +1868,7 @@ class SliceSelector extends JSONPathSelector {
   *lazyResolve(nodes) {
     for (const node of nodes) {
       if (!isArray(node.value)) continue;
-      for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
+      for (const [i, value] of this.lazySlice(node.value, this.start, this.stop, this.step)) {
         yield new JSONPathNode(value, node.location.concat(i), node.root);
       }
     }
@@ -1908,6 +1931,45 @@ class SliceSelector extends JSONPathSelector {
     }
     return slicedArray;
   }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  *lazySlice(arr, start, stop, step) {
+    if (!arr.length) return;
+
+    // Handle negative and undefined start values
+    if (start === undefined || start === null) {
+      start = step && step < 0 ? arr.length - 1 : 0;
+    } else if (start < 0) {
+      start = Math.max(arr.length + start, 0);
+    } else {
+      start = Math.min(start, arr.length - 1);
+    }
+
+    // Handle negative and undefined stop values
+    if (stop === undefined || stop === null) {
+      stop = step && step < 0 ? -1 : arr.length;
+    } else if (stop < 0) {
+      stop = Math.max(arr.length + stop, -1);
+    } else {
+      stop = Math.min(stop, arr.length);
+    }
+
+    // Perform the slice
+    if (step === undefined) {
+      // Default to a step of 1
+      for (let i = start; i < stop; i += 1) {
+        yield [i, arr[i]];
+      }
+    } else if (step > 0) {
+      for (let i = start; i < stop; i += step) {
+        yield [i, arr[i]];
+      }
+    } else if (step < 0) {
+      for (let i = start; i > stop; i += step) {
+        yield [i, arr[i]];
+      }
+    }
+  }
 }
 class WildcardSelector extends JSONPathSelector {
   constructor(environment, token) {
@@ -1960,10 +2022,18 @@ class RecursiveDescentSegment extends JSONPathSelector {
   }
   resolve(nodes) {
     const rv = [];
-    for (const node of nodes) {
-      rv.push(node);
-      for (const _node of this.visit(node)) {
-        rv.push(_node);
+    if (this.environment.nondeterministic) {
+      for (const root of nodes) {
+        for (const node of this.nondeterministicVisitor(root)) {
+          rv.push(node);
+        }
+      }
+    } else {
+      for (const node of nodes) {
+        rv.push(node);
+        for (const _node of this.visitor(node)) {
+          rv.push(_node);
+        }
       }
     }
     return this.selector.resolve(rv);
@@ -2018,7 +2088,7 @@ class RecursiveDescentSegment extends JSONPathSelector {
   toString() {
     return `..${this.selector.toString()}`;
   }
-  visit(node) {
+  visitor(node) {
     let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     if (depth >= this.environment.maxRecursionDepth) {
       throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
@@ -2029,7 +2099,7 @@ class RecursiveDescentSegment extends JSONPathSelector {
       for (let i = 0; i < node.value.length; i++) {
         const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
         rv.push(_node);
-        for (const __node of this.visit(_node, depth + 1)) {
+        for (const __node of this.visitor(_node, depth + 1)) {
           rv.push(__node);
         }
       }
@@ -2037,13 +2107,52 @@ class RecursiveDescentSegment extends JSONPathSelector {
       for (const [key, value] of this.environment.entries(node.value)) {
         const _node = new JSONPathNode(value, node.location.concat(key), node.root);
         rv.push(_node);
-        for (const __node of this.visit(_node, depth + 1)) {
+        for (const __node of this.visitor(_node, depth + 1)) {
           rv.push(__node);
         }
       }
     }
     return rv;
   }
+  nondeterministicVisitor(root) {
+    let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    const rv = [root];
+    let queue = this.nondeterministicChildren(root).map(node => [node, depth]);
+    while (queue.length) {
+      const [node, _depth] = queue.shift();
+      rv.push(node);
+      if (_depth >= this.environment.maxRecursionDepth) {
+        throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
+      }
+
+      // Visit child nodes now or queue them for later?
+      const visitChildren = Math.random() < 0.5;
+      for (const child of this.nondeterministicChildren(node)) {
+        if (visitChildren) {
+          rv.push(child);
+          const grandchildren = this.nondeterministicChildren(child).map(n => [n, _depth + 2]);
+          queue = interleave(queue, grandchildren);
+        } else {
+          queue.push([child, _depth + 1]);
+        }
+      }
+    }
+    return rv;
+  }
+  nondeterministicChildren(node) {
+    const _rv = [];
+    if (node.value instanceof String) return _rv;
+    if (isArray(node.value)) {
+      for (let i = 0; i < node.value.length; i++) {
+        _rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
+      }
+    } else if (isObject(node.value)) {
+      for (const [key, value] of this.environment.entries(node.value)) {
+        _rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
+      }
+    }
+    return _rv;
+  }
 }
 class FilterSelector extends JSONPathSelector {
   constructor(environment, token, expression) {
@@ -2064,7 +2173,8 @@ class FilterSelector extends JSONPathSelector {
           const filterContext = {
             environment: this.environment,
             currentValue: value,
-            rootValue: node.root
+            rootValue: node.root,
+            currentKey: i
           };
           if (this.expression.evaluate(filterContext)) {
             rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
@@ -2075,7 +2185,8 @@ class FilterSelector extends JSONPathSelector {
           const filterContext = {
             environment: this.environment,
             currentValue: value,
-            rootValue: node.root
+            rootValue: node.root,
+            currentKey: key
           };
           if (this.expression.evaluate(filterContext)) {
             rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
@@ -2097,7 +2208,8 @@ class FilterSelector extends JSONPathSelector {
             environment: this.environment,
             currentValue: value,
             rootValue: node.root,
-            lazy: true
+            lazy: true,
+            currentKey: i
           };
           if (this.expression.evaluate(filterContext)) {
             yield new JSONPathNode(value, node.location.concat(i), node.root);
@@ -2109,7 +2221,8 @@ class FilterSelector extends JSONPathSelector {
             environment: this.environment,
             currentValue: value,
             rootValue: node.root,
-            lazy: true
+            lazy: true,
+            currentKey: key
           };
           if (this.expression.evaluate(filterContext)) {
             yield new JSONPathNode(value, node.location.concat(key), node.root);
@@ -2152,6 +2265,41 @@ class BracketedSelection extends JSONPathSelector {
   }
 }
 
+/**
+ * Randomly interleave elements from two arrays while maintaining relative
+ * order of each input array.
+ *
+ * If _arrayA_ is empty, _arrayB_ is returned, and vice versa.
+ */
+function interleave(arrayA, arrayB) {
+  if (arrayA.length === 0) {
+    return arrayB;
+  }
+  if (arrayB.length === 0) {
+    return arrayA;
+  }
+
+  // An array of iterators
+  const iterators = [];
+  const itA = arrayA[Symbol.iterator]();
+  const itB = arrayB[Symbol.iterator]();
+  for (let i = 0; i < arrayA.length; i++) {
+    iterators.push(itA);
+  }
+  for (let i = 0; i < arrayB.length; i++) {
+    iterators.push(itB);
+  }
+  shuffle(iterators);
+  return iterators.map(it => it.next().value);
+}
+function shuffle(entries) {
+  for (let i = entries.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [entries[i], entries[j]] = [entries[j], entries[i]];
+  }
+  return entries;
+}
+
 var selectors = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BracketedSelection: BracketedSelection,
@@ -2235,6 +2383,57 @@ class JSONPath {
   }
 }
 
+class CurrentKey extends FilterExpression {
+  evaluate(context) {
+    return context.currentKey ?? Nothing;
+  }
+  toString() {
+    return "#";
+  }
+}
+
+/**
+ * Object property name selector or array index selector.
+ */
+class KeysSelector extends JSONPathSelector {
+  constructor(environment, token) {
+    let shorthand = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    super(environment, token);
+    this.environment = environment;
+    this.token = token;
+    this.shorthand = shorthand;
+  }
+  resolve(nodes) {
+    const rv = [];
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value)) {
+        let i = 0;
+        for (const [key, _] of this.environment.entries(node.value)) {
+          rv.push(new JSONPathNode(key, node.location.concat("[~]", `[${i}]`), node.root));
+          i++;
+        }
+      }
+    }
+    return rv;
+  }
+  *lazyResolve(nodes) {
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value)) {
+        let i = 0;
+        for (const [key, _] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(key, node.location.concat("[~]", `[${i}]`), node.root);
+          i++;
+        }
+      }
+    }
+  }
+  toString() {
+    return this.shorthand ? "[~]" : "~";
+  }
+}
+
 const PRECEDENCE_LOWEST = 1;
 const PRECEDENCE_LOGICAL_OR = 4;
 const PRECEDENCE_LOGICAL_AND = 5;
@@ -2250,7 +2449,7 @@ const COMPARISON_OPERATORS = new Set(["==", ">=", ">", "<=", "<", "!="]);
 class Parser {
   constructor(environment) {
     this.environment = environment;
-    this.tokenMap = new Map([[TokenKind.FALSE, this.parseBoolean], [TokenKind.NUMBER, this.parseNumber], [TokenKind.LPAREN, this.parseGroupedExpression], [TokenKind.NOT, this.parsePrefixExpression], [TokenKind.NULL, this.parseNull], [TokenKind.ROOT, this.parseRootQuery], [TokenKind.CURRENT, this.parseRelativeQuery], [TokenKind.SINGLE_QUOTE_STRING, this.parseString], [TokenKind.DOUBLE_QUOTE_STRING, this.parseString], [TokenKind.TRUE, this.parseBoolean], [TokenKind.FUNCTION, this.parseFunction]]);
+    this.tokenMap = new Map([[TokenKind.FALSE, this.parseBoolean], [TokenKind.NUMBER, this.parseNumber], [TokenKind.LPAREN, this.parseGroupedExpression], [TokenKind.NOT, this.parsePrefixExpression], [TokenKind.NULL, this.parseNull], [TokenKind.ROOT, this.parseRootQuery], [TokenKind.CURRENT, this.parseRelativeQuery], [TokenKind.SINGLE_QUOTE_STRING, this.parseString], [TokenKind.DOUBLE_QUOTE_STRING, this.parseString], [TokenKind.TRUE, this.parseBoolean], [TokenKind.FUNCTION, this.parseFunction], [TokenKind.KEY, this.parseCurrentKey], [TokenKind.KEY, this.parseCurrentKey]]);
   }
   parse(stream) {
     if (stream.current.kind === TokenKind.ROOT) stream.next();
@@ -2282,6 +2481,8 @@ class Parser {
         return new NameSelector(this.environment, stream.current, stream.current.value, true);
       case TokenKind.WILD:
         return new WildcardSelector(this.environment, stream.current, true);
+      case TokenKind.KEYS:
+        return new KeysSelector(this.environment, stream.current, true);
       case TokenKind.DDOT:
         {
           const segmentToken = stream.current;
@@ -2375,6 +2576,9 @@ class Parser {
         case TokenKind.WILD:
           items.push(new WildcardSelector(this.environment, stream.current));
           break;
+        case TokenKind.KEYS:
+          items.push(new KeysSelector(this.environment, stream.current));
+          break;
         case TokenKind.EOF:
           throw new JSONPathSyntaxError("unexpected end of query", stream.current);
         default:
@@ -2435,13 +2639,20 @@ class Parser {
     return new InfixExpression(tok, left, operator, right);
   }
   parseGroupedExpression(stream) {
-    stream.next();
+    if (stream.peek.kind === TokenKind.RPAREN) {
+      throw new JSONPathSyntaxError(`empty paren expression`, stream.current);
+    }
+    stream.next(); // eat open paren
+
     let expr = this.parseFilterExpression(stream);
     stream.next();
     while (stream.current.kind !== TokenKind.RPAREN) {
       if (stream.current.kind === TokenKind.EOF) {
         throw new JSONPathSyntaxError("unbalanced parentheses", stream.current);
       }
+      if (!BINARY_OPERATORS.has(stream.current.kind)) {
+        throw new JSONPathSyntaxError(`expected an expression, found '${stream.current.value}'`, stream.current);
+      }
       expr = this.parseInfixExpression(stream, expr);
     }
     stream.expect(TokenKind.RPAREN);
@@ -2455,6 +2666,9 @@ class Parser {
     const tok = stream.next();
     return new RelativeQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
   }
+  parseCurrentKey(stream) {
+    return new CurrentKey(stream.current);
+  }
   parseFunction(stream) {
     const args = [];
     const tok = stream.next();
@@ -2494,7 +2708,7 @@ class Parser {
           msg = "end of expression";
           break;
         default:
-          msg = `'${stream.current.value}`;
+          msg = `'${stream.current.value}'`;
       }
       throw new JSONPathSyntaxError(`unexpected ${msg}`, stream.current);
     }
@@ -2571,6 +2785,10 @@ class JSONPathEnvironment {
    * If `true`, enable nondeterministic ordering when iterating JSON object data.
    */
 
+  /**
+   * The pattern to use for the non-standard _keys selector_.
+   */
+
   /**
    * A map of function names to objects implementing the {@link FilterFunction}
    * interface. You are free to set or delete custom filter functions directly.
@@ -2586,6 +2804,7 @@ class JSONPathEnvironment {
     this.minIntIndex = options.maxIntIndex ?? -Math.pow(2, 53) - 1;
     this.maxRecursionDepth = options.maxRecursionDepth ?? 50;
     this.nondeterministic = options.nondeterministic ?? false;
+    this.keysPattern = options.keysPattern ?? /~/y;
     this.parser = new Parser(this);
     this.setupFilterFunctions();
   }
@@ -2595,7 +2814,7 @@ class JSONPathEnvironment {
    * @returns A new {@link JSONPath} object, bound to this environment.
    */
   compile(path) {
-    return new JSONPath(this, this.parser.parse(new TokenStream(tokenize(path))));
+    return new JSONPath(this, this.parser.parse(new TokenStream(tokenize(this, path))));
   }
 
   /**
@@ -2677,7 +2896,7 @@ class JSONPathEnvironment {
     for (const [typ, arg, idx] of func.argTypes.map((t, i) => [t, args[i], i])) {
       switch (typ) {
         case FunctionExpressionType.ValueType:
-          if (!(arg instanceof FilterExpressionLiteral || arg instanceof JSONPathQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
+          if (!(arg instanceof FilterExpressionLiteral || arg instanceof CurrentKey || arg instanceof JSONPathQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
             throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of ValueType`, arg.token);
           }
           break;
@@ -3305,6 +3524,6 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.1.1";
+const version = "1.2.1";
 
 export { DEFAULT_ENVIRONMENT, FunctionExpressionType, JSONPatch, JSONPatchError, JSONPatchTestFailure, JSONPath, JSONPathEnvironment, JSONPathError, JSONPathIndexError, JSONPathLexerError, JSONPathNode, JSONPathNodeList, JSONPathRecursionLimitError, JSONPathSyntaxError, JSONPathTypeError, JSONPointer, Nothing, RelativeJSONPointer, Token, TokenKind, UNDEFINED, apply, compile, index as jsonpatch, index$1 as jsonpath, index$3 as jsonpointer, lazyQuery, query, resolve, version };