json-p3 1.3.3 → 1.3.5

package/dist/json-p3.esm.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.3.3
+ * json-p3 version 1.3.5
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -1040,16 +1040,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;
@@ -1083,7 +1083,10 @@ class LRUCache extends Map {
     if (this.has(key)) {
       this.delete(key);
     } else if (this.size >= this.maxSize) {
-      this.delete(this.first());
+      const first = this.first();
+      if (first !== undefined) {
+        this.delete(first);
+      }
     }
     return super.set(key, value);
   }
@@ -2342,8 +2345,8 @@ 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] : {};
@@ -2400,8 +2403,8 @@ 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] : {};
@@ -2449,8 +2452,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;
@@ -2550,6 +2553,12 @@ class TokenStream {
       throw new JSONPathSyntaxError(`expected token '${kind}', found '${peeked.kind}'`, peeked);
     }
   }
+  expectPeekNot(kind, message) {
+    const peeked = this.peek;
+    if (peeked.kind === kind) {
+      throw new JSONPathSyntaxError(message, peeked);
+    }
+  }
 }
 
 /** A lexer that accepts additional, non-standard tokens. */
@@ -2557,7 +2566,7 @@ class TokenStream {
 
 // These regular expressions are to be used with Lexer.acceptMatchRun(),
 // which expects the sticky flag to be set.
-const exponentPattern = /e[+-]?\d+/y;
+const exponentPattern = /[eE][+-]?\d+/y;
 const functionNamePattern = /[a-z][a-z_0-9]*/y;
 const indexPattern = /-?\d+/y;
 const intPattern = /-?[0-9]+/y;
@@ -4000,7 +4009,7 @@ class Parser {
       switch (stream.current.kind) {
         case TokenKind.SINGLE_QUOTE_STRING:
         case TokenKind.DOUBLE_QUOTE_STRING:
-          items.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current, true), false));
+          items.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current), false));
           break;
         case TokenKind.FILTER:
           items.push(this.parseFilter(stream));
@@ -4020,7 +4029,7 @@ class Parser {
           break;
         case TokenKind.KEY_SINGLE_QUOTE_STRING:
         case TokenKind.KEY_DOUBLE_QUOTE_STRING:
-          items.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current, true), false));
+          items.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current), false));
           break;
         case TokenKind.KEYS_FILTER:
           items.push(this.parseFilter(stream, true));
@@ -4036,6 +4045,7 @@ class Parser {
       if (stream.peek.kind !== TokenKind.RBRACKET) {
         stream.expectPeek(TokenKind.COMMA);
         stream.next();
+        stream.expectPeekNot(TokenKind.RBRACKET, "unexpected trailing comma");
       }
       stream.next();
     }
@@ -4068,7 +4078,15 @@ class Parser {
     return new StringLiteral(stream.current, this.decodeString(stream.current));
   }
   parseNumber(stream) {
-    return new NumberLiteral(stream.current, Number(stream.current.value));
+    const value = stream.current.value;
+    if (value.startsWith("0") && value.length > 1) {
+      throw new JSONPathSyntaxError(`invalid number literal '${value}'`, stream.current);
+    }
+    const num = Number(stream.current.value);
+    if (isNaN(num)) {
+      throw new JSONPathSyntaxError(`invalid number literal '${value}'`, stream.current);
+    }
+    return new NumberLiteral(stream.current, num);
   }
   parsePrefixExpression(stream) {
     stream.expect(TokenKind.NOT);
@@ -4179,11 +4197,155 @@ class Parser {
     return left;
   }
   decodeString(token) {
-    let isName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return this.unescapeString(token.kind === TokenKind.SINGLE_QUOTE_STRING ? token.value.replaceAll('"', '\\"').replaceAll("\\'", "'") : token.value, token);
+  }
+  unescapeString(value, token) {
+    const rv = [];
+    const length = value.length;
+    let index = 0;
+    let codepoint;
+    while (index < length) {
+      const ch = value[index];
+      if (ch === "\\") {
+        // Handle escape sequences
+        index += 1; // Move past '\'
+
+        switch (value[index]) {
+          case '"':
+            rv.push('"');
+            break;
+          case "\\":
+            rv.push("\\");
+            break;
+          case "/":
+            rv.push("/");
+            break;
+          case "b":
+            rv.push("\x08");
+            break;
+          case "f":
+            rv.push("\x0C");
+            break;
+          case "n":
+            rv.push("\n");
+            break;
+          case "r":
+            rv.push("\r");
+            break;
+          case "t":
+            rv.push("\t");
+            break;
+          case "u":
+            [codepoint, index] = this.decodeHexChar(value, index, token);
+            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 {
+        this.stringFromCodePoint(ch.codePointAt(0), token);
+        rv.push(ch);
+      }
+      index += 1;
+    }
+    return rv.join("");
+  }
+
+  /**
+   * Decode a `\uXXXX` or `\uXXXX\uXXXX` escape sequence from _value_ at _index_.
+   *
+   * @param value - A string value containing the sequence to decode.
+   * @param index - The start index of an escape sequence in _value_.
+   * @param token - The token for the string value.
+   * @returns - A codepoint, new index tuple.
+   */
+  decodeHexChar(value, index, token) {
+    const length = value.length;
+    if (index + 4 >= length) {
+      throw new JSONPathSyntaxError(`incomplete escape sequence at index ${token.index + index - 1}`, token);
+    }
+    index += 1; // Move past 'u'
+    let codepoint = this.parseHexDigits(value.slice(index, index + 4), token);
+    if (isLowSurrogate(codepoint)) {
+      throw new JSONPathSyntaxError(`unexpected low surrogate codepoint at index ${token.index + index - 2}`, token);
+    }
+    if (isHighSurrogate(codepoint)) {
+      // Expect a surrogate pair.
+      if (!(index + 9 < length && value[index + 4] === "\\" && value[index + 5] === "u")) {
+        throw new JSONPathSyntaxError(`incomplete escape sequence at index ${token.index + index - 2}`, token);
+      }
+      const lowSurrogate = this.parseHexDigits(value.slice(index + 6, index + 10), token);
+      if (!isLowSurrogate(lowSurrogate)) {
+        throw new JSONPathSyntaxError(`unexpected codepoint at index ${token.index + index + 4}`, token);
+      }
+      codepoint = 0x10000 + ((codepoint & 0x03ff) << 10 | lowSurrogate & 0x03ff);
+      return [codepoint, index + 9];
+    }
+    return [codepoint, index + 3];
+  }
+
+  /**
+   * Parse a hexadecimal string as an integer.
+   *
+   * @param digits - Hexadecimal digit string.
+   * @param token - The token for the string value.
+   * @returns - The number representation of _digits_.
+   *
+   * Note that we're not using `parseInt(digits, 16)` because it accepts `+`
+   * and `-` and things we don't allow.
+   */
+  parseHexDigits(digits, token) {
+    const encoder = new TextEncoder();
+    let codepoint = 0;
+    for (const digit of encoder.encode(digits)) {
+      codepoint <<= 4;
+      switch (digit) {
+        case 48:
+        case 49:
+        case 50:
+        case 51:
+        case 52:
+        case 53:
+        case 54:
+        case 55:
+        case 56:
+        case 57:
+          codepoint |= digit - 48; // '0'
+          break;
+        case 97:
+        case 98:
+        case 99:
+        case 100:
+        case 101:
+        case 102:
+          codepoint |= digit - 97 + 10; // 'a'
+          break;
+        case 65:
+        case 66:
+        case 67:
+        case 68:
+        case 69:
+        case 70:
+          codepoint |= digit - 65 + 10; // 'A'
+          break;
+        default:
+          throw new JSONPathSyntaxError("invalid \\uXXXX escape sequence", token);
+      }
+    }
+    return codepoint;
+  }
+
+  /** Check the codepoint is valid and return its string representation. */
+  stringFromCodePoint(codepoint, token) {
+    if (codepoint === undefined || codepoint <= 0x1f) {
+      throw new JSONPathSyntaxError(`invalid character`, token);
+    }
     try {
-      return JSON.parse(token.kind === TokenKind.SINGLE_QUOTE_STRING ? `"${token.value.replaceAll('"', '\\"').replaceAll("\\'", "'")}"` : `"${token.value}"`);
+      return String.fromCodePoint(codepoint);
     } catch {
-      throw new JSONPathSyntaxError(`invalid ${isName ? "name selector" : "string literal"} '${token.value}'`, token);
+      // This should not be reachable.
+      throw new JSONPathSyntaxError("invalid escape sequence", token);
     }
   }
   throwForNonComparable(expr) {
@@ -4203,6 +4365,12 @@ class Parser {
     }
   }
 }
+function isHighSurrogate(codepoint) {
+  return codepoint >= 0xd800 && codepoint <= 0xdbff;
+}
+function isLowSurrogate(codepoint) {
+  return codepoint >= 0xdc00 && codepoint <= 0xdfff;
+}
 
 /**
  * JSONPath environment options. The defaults are in compliance with JSONPath
@@ -4252,7 +4420,7 @@ 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.
    */
@@ -4260,7 +4428,7 @@ class JSONPathEnvironment {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.strict = options.strict ?? true;
     this.maxIntIndex = options.maxIntIndex ?? Math.pow(2, 53) - 1;
-    this.minIntIndex = options.maxIntIndex ?? -Math.pow(2, 53) - 1;
+    this.minIntIndex = options.maxIntIndex ?? -Math.pow(2, 53) + 1;
     this.maxRecursionDepth = options.maxRecursionDepth ?? 50;
     this.nondeterministic = options.nondeterministic ?? false;
     this.keysPattern = options.keysPattern ?? /~/y;
@@ -4695,7 +4863,11 @@ class OpMove {
       throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
     }
     if (isArray(destParent)) {
-      destParent.splice(Number(destTarget), 0, sourceObj);
+      if (destTarget === "-") {
+        destParent.push(sourceObj);
+      } else {
+        destParent.splice(Number(destTarget), 0, sourceObj);
+      }
     } else if (isObject(destParent)) {
       destParent[destTarget] = sourceObj;
     } else {
@@ -4737,11 +4909,15 @@ class OpCopy {
       throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
     }
     if (isArray(destParent)) {
-      destParent.splice(Number(destTarget), 0, this.deepCopy(sourceObj));
+      if (destTarget === "-") {
+        destParent.push(this.deepCopy(sourceObj));
+      } else {
+        destParent.splice(Number(destTarget), 0, this.deepCopy(sourceObj));
+      }
     } else if (isObject(destParent)) {
       destParent[destTarget] = this.deepCopy(sourceObj);
     } else {
-      throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      throw new JSONPatchError(`unexpected operation on '${typeof destParent}' (${this.name}:${index})`);
     }
     return value;
   }
@@ -4984,6 +5160,6 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.3.3";
+const version = "1.3.5";
 
 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 };