json-p3 2.2.2 → 2.3.1

package/dist/json-p3.cjs.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 2.2.2
+ * json-p3 version 2.3.1
  * 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
@@ -3011,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(); // ~
@@ -3403,97 +3393,58 @@ 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);
       }
     }
   }
-
-  // eslint-disable-next-line sonarjs/cognitive-complexity
   slice(arr, start, stop, step) {
-    if (!arr.length) return [];
-
-    // Handle negative start and stop 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);
-    }
-    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);
-    }
-
-    // Handle step value
-    if (step === 0) {
-      return [];
-    }
-    if (!step) {
-      step = 1;
-    }
-
-    // Perform the slice
-    const slicedArray = [];
+    const len = arr.length;
+    step = step ?? 1;
+    if (step === 0 || !len) return [];
+    const result = [];
+    let i;
     if (step > 0) {
-      for (let i = start; i < stop; i += step) {
-        slicedArray.push([i, arr[i]]);
+      i = this.normalizeIndex(start, 0, len, step);
+      const stop_ = this.normalizeIndex(stop, len, len, step);
+      for (; i < stop_; i += step) {
+        result.push([i, arr[i]]);
       }
     } else {
-      for (let i = start; i > stop; i += step) {
-        slicedArray.push([i, arr[i]]);
+      i = this.normalizeIndex(start, len - 1, len, step);
+      const stop_ = this.normalizeIndex(stop, -1, len, step);
+      for (; i > stop_; i += step) {
+        result.push([i, arr[i]]);
       }
     }
-    return slicedArray;
+    return result;
   }
-
-  // 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) {
+    const len = arr.length;
+    step = step ?? 1;
+    if (step === 0 || !len) return [];
+    let i;
+    if (step > 0) {
+      i = this.normalizeIndex(start, 0, len, step);
+      const stop_ = this.normalizeIndex(stop, len, len, step);
+      for (; i < stop_; i += step) {
         yield [i, arr[i]];
       }
-    } else if (step < 0) {
-      for (let i = start; i > stop; i += step) {
+    } else {
+      i = this.normalizeIndex(start, len - 1, len, step);
+      const stop_ = this.normalizeIndex(stop, -1, len, step);
+      for (; i > stop_; i += step) {
         yield [i, arr[i]];
       }
     }
   }
+  normalizeIndex(n, defaultValue, len, step) {
+    if (n === undefined) return defaultValue;
+    if (n < 0) return step < 0 ? Math.max(n + len, -1) : Math.max(n + len, 0);
+    return step < 0 ? Math.min(n, len - 1) : Math.min(n, len);
+  }
 }
 class WildcardSelector extends JSONPathSelector {
   constructor(environment, token) {
@@ -3693,53 +3644,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;
@@ -4005,8 +3948,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) {
@@ -4158,8 +4100,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) {
@@ -4273,8 +4214,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;
@@ -4344,7 +4284,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 {
@@ -4524,12 +4463,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;
@@ -4674,11 +4612,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;
@@ -4873,31 +4810,7 @@ class OpAdd {
     this.value = value;
   }
   apply(value, index) {
-    const [parent, obj] = this.path.resolveWithParent(value);
-    if (parent === UNDEFINED) {
-      // Replace the root object.
-      return this.value;
-    }
-    const target = this.path.tokens.at(-1);
-    if (target === undefined) {
-      // this should not be possible
-      throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
-    } else if (isArray(parent)) {
-      if (obj === UNDEFINED) {
-        if (target === "-") {
-          parent.push(this.value);
-        } else {
-          throw new JSONPatchError(`index out of range (${this.name}:${index})`);
-        }
-      } else {
-        parent.splice(Number(target), 0, this.value);
-      }
-    } else if (isObject(parent)) {
-      parent[target] = this.value;
-    } else {
-      throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
-    }
-    return value;
+    return add(value, this.path, this.value, this.name, index);
   }
   toObject() {
     return {
@@ -4917,27 +4830,7 @@ class OpRemove {
     this.path = path;
   }
   apply(value, index) {
-    const [parent, obj] = this.path.resolveWithParent(value);
-    if (parent === UNDEFINED) {
-      throw new JSONPatchError(`can't remove root (${this.name}:${index})`);
-    }
-    const target = this.path.tokens.at(-1);
-    if (target === undefined) {
-      // this should not be possible
-      throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
-    } else if (isArray(parent)) {
-      if (obj === UNDEFINED) {
-        throw new JSONPatchError(`can't remove nonexistent item (${this.name}:${index})`);
-      }
-      parent.splice(Number(target), 1);
-    } else if (isObject(parent)) {
-      if (obj === UNDEFINED) {
-        throw new JSONPatchError(`can't remove nonexistent property (${this.name}:${index})`);
-      }
-      delete parent[target];
-    } else {
-      throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
-    }
+    remove(value, this.path, this.name, index);
     return value;
   }
   toObject() {
@@ -4973,15 +4866,16 @@ class OpReplace {
         throw new JSONPatchError(`can't replace nonexistent item (${this.name}:${index})`);
       }
       parent.splice(Number(target), 1, this.value);
-    } else if (isObject(parent)) {
+      return value;
+    }
+    if (isObject(parent)) {
       if (obj === UNDEFINED) {
         throw new JSONPatchError(`can't replace nonexistent property (${this.name}:${index})`);
       }
       parent[target] = this.value;
-    } else {
-      throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      return value;
     }
-    return value;
+    throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
   }
   toObject() {
     return {
@@ -5005,42 +4899,8 @@ class OpMove {
     if (this.path.isRelativeTo(this.from)) {
       throw new JSONPatchError(`can't move object to one of its own children (${this.name}:${index})`);
     }
-    const [sourceParent, sourceObj] = this.from.resolveWithParent(value);
-    if (sourceObj === UNDEFINED) {
-      throw new JSONPatchError(`source object does not exist (${this.name}:${index})`);
-    }
-    const sourceTarget = this.from.tokens.at(-1);
-    if (sourceTarget === undefined) {
-      // this should not be possible
-      throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
-    }
-    if (isArray(sourceParent)) {
-      sourceParent.splice(Number(sourceTarget), 1);
-    } else if (isObject(sourceParent)) {
-      delete sourceParent[sourceTarget];
-    }
-    const [destParent, _] = this.path.resolveWithParent(value);
-    if (destParent === UNDEFINED) {
-      // move source to root
-      return sourceObj;
-    }
-    const destTarget = this.path.tokens.at(-1);
-    if (destTarget === undefined) {
-      // this should not be possible
-      throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
-    }
-    if (isArray(destParent)) {
-      if (destTarget === "-") {
-        destParent.push(sourceObj);
-      } else {
-        destParent.splice(Number(destTarget), 0, sourceObj);
-      }
-    } else if (isObject(destParent)) {
-      destParent[destTarget] = sourceObj;
-    } else {
-      throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
-    }
-    return value;
+    const obj = remove(value, this.from, this.name, index);
+    return add(value, this.path, obj, this.name, index);
   }
   toObject() {
     return {
@@ -5065,28 +4925,7 @@ class OpCopy {
     if (sourceObj === UNDEFINED) {
       throw new JSONPatchError(`source object does not exist (${this.name}:${index})`);
     }
-    const [destParent] = this.path.resolveWithParent(value);
-    if (destParent === UNDEFINED) {
-      // copy source to root
-      return this.deepCopy(sourceObj);
-    }
-    const destTarget = this.path.tokens.at(-1);
-    if (destTarget === undefined) {
-      // this should not be possible
-      throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
-    }
-    if (isArray(destParent)) {
-      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 destParent}' (${this.name}:${index})`);
-    }
-    return value;
+    return add(value, this.path, sourceObj, this.name, index);
   }
 
   // eslint-disable-next-line sonarjs/no-identical-functions
@@ -5127,6 +4966,72 @@ class OpTest {
   }
 }
 
+/**
+ * Add _value_ to _data_ at _path_.
+ *
+ * This is semantically the `add` operation, used by `OpAdd`, `OpMove` and
+ * `OpCopy`.
+ */
+function add(data, path, value, opLabel, opIndex) {
+  const [parent, obj] = path.resolveWithParent(data);
+  if (parent === UNDEFINED) {
+    // Replace the root object.
+    return value;
+  }
+  const target = path.tokens.at(-1);
+  if (target === undefined) {
+    throw new JSONPatchError(`unexpected operation on 'undefined' (${opLabel}:${opIndex})`);
+  }
+  if (isArray(parent)) {
+    if (obj === UNDEFINED) {
+      if (!(target === "-" || Number(target) === parent.length)) {
+        throw new JSONPatchError(`index out of range (${opLabel}:${opIndex})`);
+      }
+      parent.push(value);
+      return data;
+    }
+    parent.splice(Number(target), 0, value);
+    return data;
+  }
+  if (isObject(parent)) {
+    parent[target] = value;
+    return data;
+  }
+  throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${opLabel}:${opIndex})`);
+}
+
+/**
+ * Remove the element at _path_ from _data_ and return the removed value.
+ *
+ * This is semantically the `remove` operation used by `OpRemove` and
+ * `OpMove`.
+ */
+function remove(data, path, opLabel, opIndex) {
+  const [parent, obj] = path.resolveWithParent(data);
+  if (parent === UNDEFINED) {
+    throw new JSONPatchError(`can't remove root (${opLabel}:${opIndex})`);
+  }
+  const target = path.tokens.at(-1);
+  if (target === undefined) {
+    throw new JSONPatchError(`unexpected operation on 'undefined' (${opLabel}:${opIndex})`);
+  }
+  if (isArray(parent)) {
+    if (obj === UNDEFINED) {
+      throw new JSONPatchError(`can't ${opLabel} nonexistent item (${opLabel}:${opIndex})`);
+    }
+    parent.splice(Number(target), 1);
+    return obj;
+  }
+  if (isObject(parent)) {
+    if (obj === UNDEFINED) {
+      throw new JSONPatchError(`can't ${opLabel} nonexistent property (${opLabel}:${opIndex})`);
+    }
+    delete parent[target];
+    return obj;
+  }
+  throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${opLabel}:${opIndex})`);
+}
+
 /**
  *
  */
@@ -5327,7 +5232,7 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "2.2.2";
+const version = "2.3.1";
 
 exports.DEFAULT_ENVIRONMENT = DEFAULT_ENVIRONMENT;
 exports.FunctionExpressionType = FunctionExpressionType;