json-diff-ts 5.0.0-alpha.8 → 5.0.0

package/dist/index.cjs

@@ -58,331 +58,622 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/helpers.ts
-function splitJSONPath(path) {
-  const parts = [];
-  let currentPart = "";
-  let inSingleQuotes = false;
-  let inBrackets = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "'" && path[i - 1] !== "\\") {
-      inSingleQuotes = !inSingleQuotes;
-    } else if (char === "[" && !inSingleQuotes) {
-      inBrackets++;
-    } else if (char === "]" && !inSingleQuotes) {
-      inBrackets--;
-    }
-    if (char === "." && !inSingleQuotes && inBrackets === 0) {
-      parts.push(currentPart);
-      currentPart = "";
-    } else {
-      currentPart += char;
-    }
-  }
-  if (currentPart !== "") {
-    parts.push(currentPart);
-  }
-  return parts;
-}
-function arrayDifference(first, second) {
-  const secondSet = new Set(second);
-  return first.filter((item) => !secondSet.has(item));
-}
-function arrayIntersection(first, second) {
-  const secondSet = new Set(second);
-  return first.filter((item) => secondSet.has(item));
-}
-function keyBy(arr, getKey2) {
-  const result = {};
-  for (const [index, item] of Object.entries(arr)) {
-    result[String(getKey2(item, false, Number(index)))] = item;
+// src/atomPath.ts
+function formatFilterLiteral(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`Cannot format non-finite number as filter literal: ${value}`);
+    return String(value);
   }
-  return result;
+  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+  throw new Error(`Cannot format filter literal for type ${typeof value}`);
 }
-function setByPath(obj, path, value) {
-  const parts = path.replaceAll(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (!(part in current)) {
-      current[part] = /^\d+$/.test(parts[i + 1]) ? [] : {};
-    }
-    current = current[part];
+function parseFilterLiteral(s) {
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s === "null") return null;
+  if (s.startsWith("'") && s.endsWith("'")) {
+    const [value, end] = extractQuotedString(s, 1);
+    if (end !== s.length - 1) throw new Error(`Invalid filter literal: ${s}`);
+    return value;
   }
-  current[parts.at(-1)] = value;
-}
-
-// src/jsonDiff.ts
-var Operation = /* @__PURE__ */ ((Operation2) => {
-  Operation2["REMOVE"] = "REMOVE";
-  Operation2["ADD"] = "ADD";
-  Operation2["UPDATE"] = "UPDATE";
-  return Operation2;
-})(Operation || {});
-function diff(oldObj, newObj, options = {}) {
-  let embeddedObjKeys = options.arrayIdentityKeys ?? options.embeddedObjKeys;
-  const { keysToSkip, treatTypeChangeAsReplace } = options;
-  if (embeddedObjKeys instanceof Map) {
-    embeddedObjKeys = new Map(
-      Array.from(embeddedObjKeys.entries()).map(([key, value]) => [
-        key instanceof RegExp ? key : key.replace(/^\./, ""),
-        value
-      ])
-    );
-  } else if (embeddedObjKeys) {
-    embeddedObjKeys = Object.fromEntries(
-      Object.entries(embeddedObjKeys).map(([key, value]) => [key.replace(/^\./, ""), value])
-    );
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+    const value = Number(s);
+    if (!Number.isFinite(value)) throw new Error(`Invalid non-finite filter literal: ${s}`);
+    return value;
   }
-  return compare(oldObj, newObj, [], [], {
-    embeddedObjKeys,
-    keysToSkip: keysToSkip ?? [],
-    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true
-  });
+  throw new Error(`Invalid filter literal: ${s}`);
 }
-var applyChangeset = (obj, changeset) => {
-  if (changeset) {
-    changeset.forEach((change) => {
-      const { type, key, value, embeddedKey } = change;
-      if (value !== null && value !== void 0 || type === "REMOVE" /* REMOVE */ || value === null && type === "ADD" /* ADD */ || value === void 0 && type === "ADD" /* ADD */) {
-        applyLeafChange(obj, change, embeddedKey);
-      } else {
-        applyBranchChange(key === "$root" ? obj : obj[key], change);
-      }
-    });
-  }
-  return obj;
-};
-var revertChangeset = (obj, changeset) => {
-  if (changeset) {
-    changeset.reverse().forEach((change) => {
-      const { value, type } = change;
-      if (!change.changes || value === null && type === "REMOVE" /* REMOVE */) {
-        revertLeafChange(obj, change);
+function extractQuotedString(s, start) {
+  const result = [];
+  let i = start;
+  while (i < s.length) {
+    if (s[i] === "'") {
+      if (i + 1 < s.length && s[i + 1] === "'") {
+        result.push("'");
+        i += 2;
       } else {
-        revertBranchChange(change.key === "$root" ? obj : obj[change.key], change);
-      }
-    });
-  }
-  return obj;
-};
-var atomizeChangeset = (obj, path = "$", embeddedKey, embeddedKeyIsPath) => {
-  if (Array.isArray(obj)) {
-    return handleArray(obj, path, embeddedKey, embeddedKeyIsPath);
-  } else if (obj.changes || embeddedKey) {
-    if (embeddedKey) {
-      const [updatedPath, atomicChange] = handleEmbeddedKey(embeddedKey, obj, path, embeddedKeyIsPath);
-      path = updatedPath;
-      if (atomicChange) {
-        return atomicChange;
+        return [result.join(""), i];
       }
     } else {
-      path = append(path, obj.key);
-    }
-    return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey, obj.embeddedKeyIsPath);
-  } else {
-    const valueType = getTypeOfObj(obj.value);
-    let finalPath = path;
-    if (!finalPath.endsWith(`[${obj.key}]`)) {
-      let endsWithFilterValue = false;
-      const filterEndIdx = path.lastIndexOf(")]");
-      if (filterEndIdx !== -1) {
-        const filterStartIdx = path.lastIndexOf("==", filterEndIdx);
-        if (filterStartIdx !== -1) {
-          const filterValue = path.slice(filterStartIdx + 2, filterEndIdx).replaceAll(/(^'|'$)/g, "");
-          endsWithFilterValue = filterValue === String(obj.key);
-        }
-      }
-      if (!endsWithFilterValue) {
-        finalPath = append(path, obj.key);
-      }
+      result.push(s[i]);
+      i += 1;
     }
-    return [
-      {
-        ...obj,
-        path: finalPath,
-        valueType
-      }
-    ];
-  }
-};
-function handleEmbeddedKey(embeddedKey, obj, path, isPath) {
-  if (embeddedKey === "$index") {
-    path = `${path}[${obj.key}]`;
-    return [path];
-  } else if (embeddedKey === "$value") {
-    path = `${path}[?(@=='${obj.key}')]`;
-    const valueType = getTypeOfObj(obj.value);
-    return [
-      path,
-      [
-        {
-          ...obj,
-          path,
-          valueType
-        }
-      ]
-    ];
-  } else {
-    path = filterExpression(path, embeddedKey, obj.key, isPath);
-    return [path];
   }
+  throw new Error("Unterminated quoted string");
 }
-var handleArray = (obj, path, embeddedKey, embeddedKeyIsPath) => {
-  return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey, embeddedKeyIsPath)], []);
-};
-var unatomizeChangeset = (changes) => {
-  if (!Array.isArray(changes)) {
-    changes = [changes];
-  }
-  const changesArr = [];
-  changes.forEach((change) => {
-    const obj = {};
-    let ptr = obj;
-    const segments = splitJSONPath(change.path);
-    if (segments.length === 1) {
-      ptr.key = change.key;
-      ptr.type = change.type;
-      ptr.value = change.value;
-      ptr.oldValue = change.oldValue;
-      changesArr.push(ptr);
-    } else {
-      for (let i = 1; i < segments.length; i++) {
-        const segment = segments[i];
-        const result = /^([^[\]]+)\[\?\(@(?:\.?([^=[]*)|(?:\['([^']*(?:''[^']*)*)'\]))=+'([^']*(?:''[^']*)*)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
-        if (result) {
-          let key;
-          let embeddedKey;
-          let arrKey;
-          let isPath;
-          if (result[1]) {
-            key = result[1];
-            embeddedKey = result[3]?.replace(/''/g, "'") || result[2] || "$value";
-            isPath = !result[3] && !!result[2] && result[2].includes(".") && NESTED_PATH_RE.test(result[2]) ? true : void 0;
-            arrKey = result[4]?.replace(/''/g, "'");
-          } else {
-            key = result[5];
-            embeddedKey = "$index";
-            arrKey = Number(result[6]);
-          }
-          if (i === segments.length - 1) {
-            ptr.key = key;
-            ptr.embeddedKey = embeddedKey;
-            if (isPath) ptr.embeddedKeyIsPath = true;
-            ptr.type = "UPDATE" /* UPDATE */;
-            ptr.changes = [
-              {
-                type: change.type,
-                key: arrKey,
-                value: change.value,
-                oldValue: change.oldValue
-              }
-            ];
+function findFilterClose(s, from) {
+  let i = from;
+  while (i < s.length) {
+    if (s[i] === "'") {
+      i += 1;
+      while (i < s.length) {
+        if (s[i] === "'") {
+          if (i + 1 < s.length && s[i + 1] === "'") {
+            i += 2;
           } else {
-            ptr.key = key;
-            ptr.embeddedKey = embeddedKey;
-            if (isPath) ptr.embeddedKeyIsPath = true;
-            ptr.type = "UPDATE" /* UPDATE */;
-            const newPtr = {};
-            ptr.changes = [
-              {
-                type: "UPDATE" /* UPDATE */,
-                key: arrKey,
-                changes: [newPtr]
-              }
-            ];
-            ptr = newPtr;
+            i += 1;
+            break;
           }
         } else {
-          if (i === segments.length - 1) {
-            ptr.key = segment;
-            ptr.type = change.type;
-            ptr.value = change.value;
-            ptr.oldValue = change.oldValue;
-          } else {
-            ptr.key = segment;
-            ptr.type = "UPDATE" /* UPDATE */;
-            const newPtr = {};
-            ptr.changes = [newPtr];
-            ptr = newPtr;
-          }
+          i += 1;
         }
       }
-      changesArr.push(obj);
+    } else if (s[i] === ")" && i + 1 < s.length && s[i + 1] === "]") {
+      return i;
+    } else {
+      i += 1;
     }
-  });
-  return changesArr;
-};
-var getTypeOfObj = (obj) => {
-  if (obj === void 0) {
-    return "undefined";
-  }
-  if (obj === null) {
-    return null;
   }
-  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
-};
-var getKey = (path) => {
-  const left = path.at(-1);
-  return left ?? "$root";
-};
-var compare = (oldObj, newObj, path, keyPath, options) => {
-  let changes = [];
-  const currentPath = keyPath.join(".");
-  if (options.keysToSkip?.some((skipPath) => {
-    if (currentPath === skipPath) {
-      return true;
-    }
-    if (skipPath.includes(".") && skipPath.startsWith(currentPath + ".")) {
-      return false;
-    }
-    if (skipPath.includes(".")) {
-      const skipParts = skipPath.split(".");
-      const currentParts = currentPath.split(".");
-      if (currentParts.length >= skipParts.length) {
-        for (let i = 0; i < skipParts.length; i++) {
-          if (skipParts[i] !== currentParts[i]) {
-            return false;
-          }
-        }
-        return true;
+  return -1;
+}
+var NESTED_PATH_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function parseFilter(inner) {
+  if (inner.startsWith("@==")) return { type: "valueFilter", value: parseFilterLiteral(inner.slice(3)) };
+  if (!inner.startsWith("@.") && !inner.startsWith("@['")) throw new Error(`Invalid filter expression: ${inner}`);
+  let quoted = false;
+  let eq = -1;
+  for (let i = 1; i < inner.length; i++) {
+    if (inner[i] === "'") {
+      if (quoted && inner[i + 1] === "'") {
+        i++;
+        continue;
       }
+      quoted = !quoted;
+    } else if (!quoted && inner.slice(i, i + 2) === "==") {
+      eq = i;
+      break;
     }
-    return false;
-  })) {
-    return changes;
-  }
-  const typeOfOldObj = getTypeOfObj(oldObj);
-  const typeOfNewObj = getTypeOfObj(newObj);
-  if (options.treatTypeChangeAsReplace && typeOfOldObj !== typeOfNewObj) {
-    if (typeOfOldObj !== "undefined") {
-      changes.push({ type: "REMOVE" /* REMOVE */, key: getKey(path), value: oldObj });
-    }
-    const lastPathSegment = path[path.length - 1];
-    const isArrayElement = path.length > 0 && (typeof lastPathSegment === "number" || typeof lastPathSegment === "string" && /^\d+$/.test(lastPathSegment));
-    if (typeOfNewObj !== "undefined" || isArrayElement) {
-      changes.push({ type: "ADD" /* ADD */, key: getKey(path), value: newObj });
-    }
-    return changes;
-  }
-  if (typeOfNewObj === "undefined" && typeOfOldObj !== "undefined") {
-    const lastPathSegment = path[path.length - 1];
-    const isArrayElement = path.length > 0 && (typeof lastPathSegment === "number" || typeof lastPathSegment === "string" && /^\d+$/.test(lastPathSegment));
-    if (isArrayElement) {
-      changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
-    } else {
-      changes.push({ type: "REMOVE" /* REMOVE */, key: getKey(path), value: oldObj });
-    }
-    return changes;
   }
-  if (typeOfNewObj === "Object" && typeOfOldObj === "Array") {
-    changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
-    return changes;
+  if (eq === -1) throw new Error(`Invalid filter: missing '==' in ${inner}`);
+  const access = inner.slice(1, eq);
+  let members;
+  try {
+    members = parseAtomPath("$" + access).slice(1);
+  } catch {
+    throw new Error(`Invalid property name in filter: ${inner}`);
+  }
+  if (!members.length || members.some((member) => member.type !== "property")) throw new Error(`Invalid property name in filter: ${inner}`);
+  const names = members.map((member) => member.name);
+  const property = names.join(".");
+  const value = parseFilterLiteral(inner.slice(eq + 2));
+  if (names.length === 1 && access.startsWith("[")) return { type: "keyFilter", property, value, literalKey: true };
+  if (names.some((name) => !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name))) return { type: "keyFilter", property, value, memberPath: names };
+  return { type: "keyFilter", property, value };
+}
+function parseAtomPath(path) {
+  if (!path.startsWith("$")) {
+    throw new Error(`Path must start with '$': ${path}`);
   }
-  if (typeOfNewObj === null) {
-    if (typeOfOldObj !== null) {
-      changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
+  const segments = [{ type: "root" }];
+  let i = 1;
+  while (i < path.length) {
+    if (path[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < path.length && /[a-zA-Z0-9_]/.test(path[i])) {
+        i += 1;
+      }
+      if (i === start) throw new Error(`Empty property name at position ${i} in: ${path}`);
+      if (!/^[a-zA-Z_]/.test(path.slice(start, i))) throw new Error(`Invalid dot property in: ${path}`);
+      segments.push({ type: "property", name: path.slice(start, i) });
+    } else if (path[i] === "[") {
+      if (i + 1 >= path.length) throw new Error(`Unexpected end of path after '[': ${path}`);
+      if (path[i + 1] === "?") {
+        const closingIdx = findFilterClose(path, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter expression in: ${path}`);
+        const inner = path.slice(i + 3, closingIdx);
+        segments.push(parseFilter(inner));
+        i = closingIdx + 2;
+      } else if (path[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(path, i + 2);
+        if (path[endIdx + 1] !== "]") throw new Error(`Expected ']' after bracket property in: ${path}`);
+        segments.push({ type: "property", name: key });
+        i = endIdx + 2;
+      } else if (/\d/.test(path[i + 1])) {
+        const end = path.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated array index in: ${path}`);
+        const indexStr = path.slice(i + 1, end);
+        if (indexStr.length > 1 && indexStr[0] === "0") {
+          throw new Error(`Leading zeros not allowed in array index: [${indexStr}]`);
+        }
+        if (!/^(0|[1-9]\d*)$/.test(indexStr) || !Number.isSafeInteger(Number(indexStr))) {
+          throw new Error(`Invalid array index: [${indexStr}]`);
+        }
+        segments.push({ type: "index", index: Number(indexStr) });
+        i = end + 1;
+      } else {
+        throw new Error(`Unexpected character after '[': '${path[i + 1]}' in: ${path}`);
+      }
+    } else {
+      throw new Error(`Unexpected character '${path[i]}' at position ${i} in: ${path}`);
+    }
+  }
+  return segments;
+}
+var SIMPLE_PROPERTY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function formatMemberAccess(name) {
+  if (SIMPLE_PROPERTY_RE.test(name)) {
+    return `.${name}`;
+  }
+  return `['${name.replace(/'/g, "''")}']`;
+}
+function buildAtomPath(segments) {
+  let result = "";
+  for (const seg of segments) {
+    switch (seg.type) {
+      case "root":
+        result += "$";
+        break;
+      case "property":
+        result += formatMemberAccess(seg.name);
+        break;
+      case "index":
+        result += `[${seg.index}]`;
+        break;
+      case "keyFilter": {
+        let memberAccess;
+        if (seg.memberPath) {
+          memberAccess = seg.memberPath.map(formatMemberAccess).join("");
+        } else if (seg.literalKey) {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        } else if (NESTED_PATH_RE.test(seg.property)) {
+          memberAccess = `.${seg.property}`;
+        } else {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        }
+        result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
+        break;
+      }
+      case "valueFilter":
+        result += `[?(@==${formatFilterLiteral(seg.value)})]`;
+        break;
+    }
+  }
+  return result;
+}
+function normalizeLegacyFilterOperator(inner) {
+  let quoted = false;
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "'") {
+      if (quoted && inner[i + 1] === "'") {
+        i++;
+        continue;
+      }
+      quoted = !quoted;
+    } else if (inner[i] === "=" && !quoted) {
+      let end = i + 1;
+      while (inner[end] === "=") end++;
+      inner = inner.slice(0, i) + "==" + inner.slice(end);
+      break;
+    }
+  }
+  return inner;
+}
+function canonicalizeFilterForAtom(inner) {
+  inner = normalizeLegacyFilterOperator(inner);
+  if (inner.startsWith("@.")) {
+    const eqIdx = inner.indexOf("==");
+    if (eqIdx === -1) return `[?(${inner})]`;
+    const key = inner.slice(2, eqIdx);
+    const valuePart = inner.slice(eqIdx);
+    if (NESTED_PATH_RE.test(key)) {
+      return `[?(@.${key}${valuePart})]`;
+    }
+    return `[?(@['${key.replace(/'/g, "''")}']${valuePart})]`;
+  }
+  return `[?(${inner})]`;
+}
+function canonicalizeFilterForV4(inner) {
+  if (inner.startsWith("@['")) {
+    const [key, endIdx] = extractQuotedString(inner, 3);
+    const rest = inner.slice(endIdx + 2);
+    if (rest.startsWith("==")) {
+      const literal = rest.slice(2);
+      const normalizedLiteral = normalizeToStringQuoted(literal);
+      return `[?(@['${key.replace(/'/g, "''")}']==${normalizedLiteral})]`;
+    }
+    return `[?(${inner})]`;
+  }
+  return normalizeFilterToStringLiterals(`[?(${inner})]`);
+}
+function normalizeToStringQuoted(literal) {
+  if (literal.startsWith("'") && literal.endsWith("'")) {
+    return literal;
+  }
+  const value = parseFilterLiteral(literal);
+  const stringValue = String(value).replace(/'/g, "''");
+  return `'${stringValue}'`;
+}
+function atomicPathToAtomPath(atomicPath) {
+  if (atomicPath === "$.$root") return "$";
+  if (atomicPath.startsWith("$.$root.") || atomicPath.startsWith("$.$root[")) {
+    atomicPath = "$" + atomicPath.slice(7);
+  }
+  if (!atomicPath.startsWith("$")) {
+    throw new Error(`Atomic path must start with '$': ${atomicPath}`);
+  }
+  let result = "$";
+  let i = 1;
+  while (i < atomicPath.length) {
+    if (atomicPath[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < atomicPath.length && atomicPath[i] !== "." && atomicPath[i] !== "[") {
+        i += 1;
+      }
+      const name = atomicPath.slice(start, i);
+      result += formatMemberAccess(name);
+    } else if (atomicPath[i] === "[") {
+      if (atomicPath[i + 1] === "?") {
+        const closingIdx = findFilterClose(atomicPath, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomicPath}`);
+        const inner = atomicPath.slice(i + 3, closingIdx);
+        result += canonicalizeFilterForAtom(inner);
+        i = closingIdx + 2;
+      } else if (atomicPath[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(atomicPath, i + 2);
+        if (atomicPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomicPath}`);
+        result += formatMemberAccess(key);
+        i = endIdx + 2;
+      } else if (/\d/.test(atomicPath[i + 1])) {
+        const end = atomicPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
+        result += atomicPath.slice(i, end + 1);
+        i = end + 1;
+      } else {
+        const end = atomicPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
+        const name = atomicPath.slice(i + 1, end);
+        result += `['${name.replace(/'/g, "''")}']`;
+        i = end + 1;
+      }
+    } else {
+      throw new Error(`Unexpected character '${atomicPath[i]}' in atomic path: ${atomicPath}`);
+    }
+  }
+  return result;
+}
+function atomPathToAtomicPath(atomPath) {
+  if (!atomPath.startsWith("$")) {
+    throw new Error(`Atom path must start with '$': ${atomPath}`);
+  }
+  if (atomPath === "$") {
+    return "$.$root";
+  }
+  let result = "$";
+  let i = 1;
+  while (i < atomPath.length) {
+    if (atomPath[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < atomPath.length && /[a-zA-Z0-9_]/.test(atomPath[i])) {
+        i += 1;
+      }
+      result += "." + atomPath.slice(start, i);
+    } else if (atomPath[i] === "[") {
+      if (atomPath[i + 1] === "?") {
+        const closingIdx = findFilterClose(atomPath, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomPath}`);
+        const inner = atomPath.slice(i + 3, closingIdx);
+        result += canonicalizeFilterForV4(inner);
+        i = closingIdx + 2;
+      } else if (atomPath[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(atomPath, i + 2);
+        if (atomPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomPath}`);
+        result += key.includes(".") && !/[[\]'\\]/.test(key) && !/^\d/.test(key) ? `[${key}]` : `['${key.replace(/'/g, "''")}']`;
+        i = endIdx + 2;
+      } else if (/\d/.test(atomPath[i + 1])) {
+        const end = atomPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomPath}`);
+        result += atomPath.slice(i, end + 1);
+        i = end + 1;
+      } else {
+        throw new Error(`Unexpected character after '[' in: ${atomPath}`);
+      }
+    } else {
+      throw new Error(`Unexpected character '${atomPath[i]}' in atom path: ${atomPath}`);
+    }
+  }
+  return result;
+}
+function normalizeFilterToStringLiterals(filter) {
+  const eqIdx = filter.indexOf("==");
+  if (eqIdx === -1) return filter;
+  const literalStart = eqIdx + 2;
+  const literalEnd = filter.length - 2;
+  const literal = filter.slice(literalStart, literalEnd);
+  if (literal.startsWith("'") && literal.endsWith("'")) {
+    return filter;
+  }
+  const value = parseFilterLiteral(literal);
+  const stringValue = String(value).replace(/'/g, "''");
+  return filter.slice(0, literalStart) + `'${stringValue}'` + filter.slice(literalEnd);
+}
+function extractKeyFromAtomicPath(atomicPath) {
+  if (atomicPath === "$.$root") return "$root";
+  const last = parseAtomPath(atomicPathToAtomPath(atomicPath)).at(-1);
+  switch (last.type) {
+    case "property":
+      return last.name;
+    case "index":
+      return String(last.index);
+    case "keyFilter":
+    case "valueFilter":
+      return String(last.value);
+    default:
+      return atomicPath;
+  }
+}
+
+// src/helpers.ts
+function splitJSONPath(path) {
+  const parts = [];
+  let currentPart = "";
+  let inSingleQuotes = false;
+  let inBrackets = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === "'" && path[i - 1] !== "\\") {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === "[" && !inSingleQuotes) {
+      inBrackets++;
+    } else if (char === "]" && !inSingleQuotes) {
+      inBrackets--;
+    }
+    if (char === "." && !inSingleQuotes && inBrackets === 0) {
+      parts.push(currentPart);
+      currentPart = "";
+    } else {
+      currentPart += char;
+    }
+  }
+  if (currentPart !== "") {
+    parts.push(currentPart);
+  }
+  return parts;
+}
+function arrayDifference(first, second) {
+  const secondSet = new Set(second);
+  return first.filter((item) => !secondSet.has(item));
+}
+function arrayIntersection(first, second) {
+  const secondSet = new Set(second);
+  return first.filter((item) => secondSet.has(item));
+}
+function keyBy(arr, getKey2) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [index, item] of Object.entries(arr)) {
+    const key = String(getKey2(item, false, Number(index)));
+    if (Object.prototype.hasOwnProperty.call(result, key)) throw new Error(`Duplicate array identity: ${key}`);
+    result[key] = item;
+  }
+  return result;
+}
+function setByPath(obj, path, value) {
+  const parts = path.replaceAll(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current)) {
+      current[part] = /^\d+$/.test(parts[i + 1]) ? [] : {};
+    }
+    current = current[part];
+  }
+  current[parts.at(-1)] = value;
+}
+
+// src/jsonDiff.ts
+var Operation = /* @__PURE__ */ ((Operation2) => {
+  Operation2["REMOVE"] = "REMOVE";
+  Operation2["ADD"] = "ADD";
+  Operation2["UPDATE"] = "UPDATE";
+  return Operation2;
+})(Operation || {});
+function diff(oldObj, newObj, options = {}) {
+  let embeddedObjKeys = options.arrayIdentityKeys ?? options.embeddedObjKeys;
+  const { keysToSkip, keysToInclude, treatTypeChangeAsReplace } = options;
+  if (embeddedObjKeys instanceof Map) {
+    embeddedObjKeys = new Map(
+      Array.from(embeddedObjKeys.entries()).map(([key, value]) => [
+        key instanceof RegExp ? key : key.replace(/^\./, ""),
+        value
+      ])
+    );
+  } else if (embeddedObjKeys) {
+    embeddedObjKeys = Object.fromEntries(
+      Object.entries(embeddedObjKeys).map(([key, value]) => [key.replace(/^\./, ""), value])
+    );
+  }
+  return compare(oldObj, newObj, [], [], {
+    embeddedObjKeys,
+    keysToSkip: keysToSkip ?? [],
+    keysToInclude,
+    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true
+  });
+}
+var applyChangeset = (obj, changeset) => {
+  if (changeset) {
+    changeset.forEach((change) => {
+      const { type, key, value, embeddedKey } = change;
+      if (value !== null && value !== void 0 || type === "REMOVE" /* REMOVE */ || value === null && type === "ADD" /* ADD */ || value === void 0 && type === "ADD" /* ADD */) {
+        applyLeafChange(obj, change, embeddedKey);
+      } else {
+        applyBranchChange(key === "$root" ? obj : obj[key], change);
+      }
+    });
+  }
+  return obj;
+};
+var revertChangeset = (obj, changeset) => {
+  if (changeset) {
+    [...changeset].reverse().forEach((change) => {
+      const { value, type } = change;
+      if (!change.changes || value === null && type === "REMOVE" /* REMOVE */) {
+        revertLeafChange(obj, change);
+      } else {
+        revertBranchChange(change.key === "$root" ? obj : obj[change.key], change);
+      }
+    });
+  }
+  return obj;
+};
+var atomizeChangeset = (obj, path = "$", embeddedKey, embeddedKeyIsPath) => {
+  if (Array.isArray(obj)) {
+    return handleArray(obj, path, embeddedKey, embeddedKeyIsPath);
+  } else if (obj.changes || embeddedKey) {
+    if (embeddedKey) {
+      const [updatedPath, atomicChange] = handleEmbeddedKey(embeddedKey, obj, path, embeddedKeyIsPath);
+      path = updatedPath;
+      if (atomicChange) {
+        return atomicChange;
+      }
+      if (!obj.changes) {
+        return [{ ...obj, path, valueType: getTypeOfObj(obj.value) }];
+      }
+    } else {
+      path = append(path, obj.key);
+    }
+    return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey, obj.embeddedKeyIsPath);
+  } else {
+    const valueType = getTypeOfObj(obj.value);
+    const finalPath = append(path, obj.key);
+    return [
+      {
+        ...obj,
+        path: finalPath,
+        valueType
+      }
+    ];
+  }
+};
+function handleEmbeddedKey(embeddedKey, obj, path, isPath) {
+  if (embeddedKey === "$index") {
+    path = `${path}[${obj.key}]`;
+    return [path];
+  } else if (embeddedKey === "$value") {
+    path = `${path}[?(@=='${obj.key}')]`;
+    const valueType = getTypeOfObj(obj.value);
+    return [
+      path,
+      [
+        {
+          ...obj,
+          path,
+          valueType
+        }
+      ]
+    ];
+  } else {
+    path = filterExpression(path, embeddedKey, obj.key, isPath);
+    return [path];
+  }
+}
+var handleArray = (obj, path, embeddedKey, embeddedKeyIsPath) => {
+  return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey, embeddedKeyIsPath)], []);
+};
+var unatomizeChangeset = (changes) => {
+  return (Array.isArray(changes) ? changes : [changes]).map((change) => {
+    const segments = parseAtomPath(atomicPathToAtomPath(change.path)).slice(1);
+    const buildChange = (key, offset) => {
+      const segment = segments[offset];
+      if (!segment) {
+        return { key, type: change.type, value: change.value, oldValue: change.oldValue };
+      }
+      if (segment.type === "property") {
+        return { key, type: "UPDATE" /* UPDATE */, changes: [buildChange(segment.name, offset + 1)] };
+      }
+      if (segment.type === "index" || segment.type === "keyFilter" || segment.type === "valueFilter") {
+        const embeddedKey = segment.type === "index" ? "$index" : segment.type === "valueFilter" ? "$value" : segment.property;
+        const childKey = segment.type === "index" ? String(segment.index) : String(segment.value);
+        const isPath = segment.type === "keyFilter" && !segment.literalKey && segment.property.includes(".");
+        return {
+          key,
+          type: "UPDATE" /* UPDATE */,
+          embeddedKey,
+          ...isPath ? { embeddedKeyIsPath: true } : {},
+          changes: [buildChange(childKey, offset + 1)]
+        };
+      }
+      throw new Error(`Unexpected root segment in: ${change.path}`);
+    };
+    const first = segments[0];
+    return first?.type === "property" ? buildChange(first.name, 1) : buildChange(first ? "$root" : change.key, 0);
+  });
+};
+var getTypeOfObj = (obj) => {
+  if (obj === void 0) {
+    return "undefined";
+  }
+  if (obj === null) {
+    return null;
+  }
+  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
+};
+var getKey = (path) => {
+  const left = path.at(-1);
+  return left ?? "$root";
+};
+var shouldComparePath = (path, options) => {
+  if (options.keysToSkip?.some((skip) => path === skip || path.startsWith(skip + "."))) return false;
+  return options.keysToInclude === void 0 || options.keysToInclude.some(
+    (include) => path === "" || path === include || path.startsWith(include + ".") || include.startsWith(path + ".")
+  );
+};
+var compare = (oldObj, newObj, path, keyPath, options) => {
+  let changes = [];
+  if (!shouldComparePath(keyPath.join("."), options)) return changes;
+  const typeOfOldObj = getTypeOfObj(oldObj);
+  const typeOfNewObj = getTypeOfObj(newObj);
+  if (options.treatTypeChangeAsReplace && typeOfOldObj !== typeOfNewObj) {
+    if (typeOfOldObj !== "undefined") {
+      changes.push({ type: "REMOVE" /* REMOVE */, key: getKey(path), value: oldObj });
+    }
+    const lastPathSegment = path[path.length - 1];
+    const isArrayElement = path.length > 0 && (typeof lastPathSegment === "number" || typeof lastPathSegment === "string" && /^\d+$/.test(lastPathSegment));
+    if (typeOfNewObj !== "undefined" || isArrayElement) {
+      changes.push({ type: "ADD" /* ADD */, key: getKey(path), value: newObj });
+    }
+    return changes;
+  }
+  if (typeOfNewObj === "undefined" && typeOfOldObj !== "undefined") {
+    const lastPathSegment = path[path.length - 1];
+    const isArrayElement = path.length > 0 && (typeof lastPathSegment === "number" || typeof lastPathSegment === "string" && /^\d+$/.test(lastPathSegment));
+    if (isArrayElement) {
+      changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
+    } else {
+      changes.push({ type: "REMOVE" /* REMOVE */, key: getKey(path), value: oldObj });
+    }
+    return changes;
+  }
+  if (typeOfNewObj === "Object" && typeOfOldObj === "Array") {
+    changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
+    return changes;
+  }
+  if (typeOfNewObj === null) {
+    if (typeOfOldObj !== null) {
+      changes.push({ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj });
     }
     return changes;
   }
@@ -440,6 +731,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
   for (k of intersectionKeys) {
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
+    if (!shouldComparePath(newKeyPath.join("."), options)) continue;
     const diffs = compare(oldObj[k], newObj[k], newPath, newKeyPath, options);
     if (diffs.length) {
       changes = changes.concat(diffs);
@@ -450,7 +742,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
     const currentPath = newKeyPath.join(".");
-    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
+    if (!shouldComparePath(currentPath, options)) {
       continue;
     }
     changes.push({
@@ -464,7 +756,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
     const currentPath = newKeyPath.join(".");
-    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
+    if (!shouldComparePath(currentPath, options)) {
       continue;
     }
     changes.push({
@@ -488,7 +780,7 @@ var compareArray = (oldObj, newObj, path, keyPath, options) => {
   if (diffs.length) {
     const resolvedKey = isFunctionKey ? uniqKey(newObj[0] ?? oldObj[0], true) : uniqKey;
     const sampleEl = newObj[0] ?? oldObj[0];
-    const isNestedPath = typeof resolvedKey === "string" && resolvedKey.includes(".") && NESTED_PATH_RE.test(resolvedKey) && (isFunctionKey || !(sampleEl != null && typeof sampleEl === "object" && resolvedKey in sampleEl));
+    const isNestedPath = typeof resolvedKey === "string" && resolvedKey.includes(".") && NESTED_PATH_RE2.test(resolvedKey) && (isFunctionKey || !(sampleEl != null && typeof sampleEl === "object" && resolvedKey in sampleEl));
     return [
       {
         type: "UPDATE" /* UPDATE */,
@@ -524,9 +816,10 @@ var getObjectKey = (embeddedObjKeys, keyPath) => {
   return void 0;
 };
 var convertArrayToObj = (arr, uniqKey) => {
-  let obj = {};
+  let obj = /* @__PURE__ */ Object.create(null);
   if (uniqKey === "$value") {
     arr.forEach((value) => {
+      if (Object.prototype.hasOwnProperty.call(obj, String(value))) throw new Error(`Duplicate array value identity: ${value}`);
       obj[value] = value;
     });
   } else if (uniqKey === "$index") {
@@ -535,7 +828,7 @@ var convertArrayToObj = (arr, uniqKey) => {
       obj[i] = value;
     }
   } else {
-    const maybeNestedPath = typeof uniqKey === "string" && uniqKey.includes(".") && NESTED_PATH_RE.test(uniqKey);
+    const maybeNestedPath = typeof uniqKey === "string" && uniqKey.includes(".") && NESTED_PATH_RE2.test(uniqKey);
     const keyFunction = typeof uniqKey === "string" ? maybeNestedPath ? (item) => item != null && typeof item === "object" && uniqKey in item ? item[uniqKey] : resolveProperty(item, uniqKey, true) : (item) => item[uniqKey] : uniqKey;
     obj = keyBy(arr, keyFunction);
   }
@@ -601,106 +894,36 @@ var addKeyValue = (obj, key, value, embeddedKey) => {
     return obj ? obj[key] = value : null;
   }
 };
-var applyLeafChange = (obj, change, embeddedKey, isPath) => {
-  const { type, key, value } = change;
-  switch (type) {
-    case "ADD" /* ADD */:
-      return addKeyValue(obj, key, value, embeddedKey);
-    case "UPDATE" /* UPDATE */:
-      return modifyKeyValue(obj, key, value);
-    case "REMOVE" /* REMOVE */:
-      return removeKey(obj, key, embeddedKey, isPath);
-  }
-};
-var applyArrayChange = (arr, change) => {
-  let changes = change.changes;
-  if (change.embeddedKey === "$index") {
-    changes = [...changes].sort((a, b) => {
-      if (a.type === "REMOVE" /* REMOVE */ && b.type === "REMOVE" /* REMOVE */) {
-        return Number(b.key) - Number(a.key);
-      }
-      if (a.type === "REMOVE" /* REMOVE */) return -1;
-      if (b.type === "REMOVE" /* REMOVE */) return 1;
-      return Number(a.key) - Number(b.key);
-    });
-  }
-  for (const subchange of changes) {
-    if (subchange.value !== null && subchange.value !== void 0 || subchange.type === "REMOVE" /* REMOVE */ || subchange.value === null && subchange.type === "ADD" /* ADD */ || subchange.value === void 0 && subchange.type === "ADD" /* ADD */) {
-      applyLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
-    } else {
-      let element;
-      if (change.embeddedKey === "$index") {
-        element = arr[subchange.key];
-      } else if (change.embeddedKey === "$value") {
-        const index = arr.indexOf(subchange.key);
-        if (index !== -1) {
-          element = arr[index];
-        }
-      } else {
-        element = arr.find((el) => {
-          const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
-          return resolved !== void 0 && String(resolved) === String(subchange.key);
-        });
-      }
-      if (element) {
-        applyChangeset(element, subchange.changes);
-      }
-    }
-  }
-  return arr;
-};
-var applyBranchChange = (obj, change) => {
-  if (Array.isArray(obj)) {
-    return applyArrayChange(obj, change);
-  } else {
-    return applyChangeset(obj, change.changes);
-  }
-};
-var revertLeafChange = (obj, change, embeddedKey = "$index", isPath) => {
-  const { type, key, value, oldValue } = change;
-  if (key === "$root") {
-    switch (type) {
-      case "ADD" /* ADD */:
-        for (const prop in obj) {
-          if (Object.prototype.hasOwnProperty.call(obj, prop)) {
-            delete obj[prop];
-          }
-        }
-        return obj;
-      case "UPDATE" /* UPDATE */:
-        for (const prop in obj) {
-          if (Object.prototype.hasOwnProperty.call(obj, prop)) {
-            delete obj[prop];
-          }
-        }
-        if (oldValue && typeof oldValue === "object") {
-          Object.assign(obj, oldValue);
-        }
-        return obj;
-      case "REMOVE" /* REMOVE */:
-        if (value && typeof value === "object") {
-          Object.assign(obj, value);
-        }
-        return obj;
-    }
-  }
+var applyLeafChange = (obj, change, embeddedKey, isPath) => {
+  const { type, key, value } = change;
   switch (type) {
     case "ADD" /* ADD */:
-      return removeKey(obj, key, embeddedKey, isPath);
+      return addKeyValue(obj, key, value, embeddedKey);
     case "UPDATE" /* UPDATE */:
-      return modifyKeyValue(obj, key, oldValue);
+      return modifyKeyValue(obj, key, value);
     case "REMOVE" /* REMOVE */:
-      return addKeyValue(obj, key, value);
+      return removeKey(obj, key, embeddedKey, isPath);
   }
 };
-var revertArrayChange = (arr, change) => {
-  for (const subchange of change.changes) {
-    if (subchange.value != null || subchange.type === "REMOVE" /* REMOVE */) {
-      revertLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
+var applyArrayChange = (arr, change) => {
+  let changes = change.changes;
+  if (change.embeddedKey === "$index") {
+    changes = [...changes].sort((a, b) => {
+      if (a.type === "REMOVE" /* REMOVE */ && b.type === "REMOVE" /* REMOVE */) {
+        return Number(b.key) - Number(a.key);
+      }
+      if (a.type === "REMOVE" /* REMOVE */) return -1;
+      if (b.type === "REMOVE" /* REMOVE */) return 1;
+      return Number(a.key) - Number(b.key);
+    });
+  }
+  for (const subchange of changes) {
+    if (subchange.value !== null && subchange.value !== void 0 || subchange.type === "REMOVE" /* REMOVE */ || subchange.value === null && subchange.type === "ADD" /* ADD */ || subchange.value === void 0 && subchange.type === "ADD" /* ADD */) {
+      applyLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
     } else {
       let element;
       if (change.embeddedKey === "$index") {
-        element = arr[+subchange.key];
+        element = arr[subchange.key];
       } else if (change.embeddedKey === "$value") {
         const index = arr.indexOf(subchange.key);
         if (index !== -1) {
@@ -713,519 +936,378 @@ var revertArrayChange = (arr, change) => {
         });
       }
       if (element) {
-        revertChangeset(element, subchange.changes);
+        applyChangeset(element, subchange.changes);
       }
     }
   }
   return arr;
 };
-var revertBranchChange = (obj, change) => {
+var applyBranchChange = (obj, change) => {
   if (Array.isArray(obj)) {
-    return revertArrayChange(obj, change);
-  } else {
-    return revertChangeset(obj, change.changes);
-  }
-};
-function append(basePath, nextSegment) {
-  return nextSegment.includes(".") ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
-}
-var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var NESTED_PATH_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function filterExpression(basePath, filterKey, filterValue, isPath) {
-  const escapedValue = `'${filterValue.replace(/'/g, "''")}'`;
-  let memberAccess;
-  if (isPath && NESTED_PATH_RE.test(filterKey)) {
-    memberAccess = "." + filterKey;
-  } else if (IDENT_RE.test(filterKey)) {
-    memberAccess = `.${filterKey}`;
+    return applyArrayChange(obj, change);
   } else {
-    memberAccess = `['${filterKey.replace(/'/g, "''")}']`;
-  }
-  return `${basePath}[?(@${memberAccess}==${escapedValue})]`;
-}
-
-// src/jsonCompare.ts
-var CompareOperation = /* @__PURE__ */ ((CompareOperation2) => {
-  CompareOperation2["CONTAINER"] = "CONTAINER";
-  CompareOperation2["UNCHANGED"] = "UNCHANGED";
-  return CompareOperation2;
-})(CompareOperation || {});
-var createValue = (value) => ({ type: "UNCHANGED" /* UNCHANGED */, value });
-var createContainer = (value) => ({
-  type: "CONTAINER" /* CONTAINER */,
-  value
-});
-var enrich = (object) => {
-  const objectType = getTypeOfObj(object);
-  switch (objectType) {
-    case "Object":
-      return Object.keys(object).map((key) => ({ key, value: enrich(object[key]) })).reduce((accumulator, entry) => {
-        accumulator.value[entry.key] = entry.value;
-        return accumulator;
-      }, createContainer({}));
-    case "Array":
-      return object.map((value) => enrich(value)).reduce((accumulator, value) => {
-        accumulator.value.push(value);
-        return accumulator;
-      }, createContainer([]));
-    case "Function":
-      return void 0;
-    case "Date":
-    default:
-      return createValue(object);
-  }
-};
-var buildEnrichedPath = (atomicPath) => {
-  const segments = splitJSONPath(atomicPath);
-  let result = "value";
-  for (let i = 1; i < segments.length; i++) {
-    const seg = segments[i];
-    const isLast = i === segments.length - 1;
-    const arrayMatch = /^(.+?)\[(\d+)\]$/.exec(seg);
-    if (arrayMatch) {
-      const [, key, index] = arrayMatch;
-      result += `.${key}.value[${index}]`;
-    } else {
-      result += `.${seg}`;
-    }
-    if (!isLast) {
-      result += ".value";
-    }
+    return applyChangeset(obj, change.changes);
   }
-  return result;
 };
-var applyChangelist = (object, changelist) => {
-  changelist.forEach((entry) => {
-    const path = buildEnrichedPath(entry.path);
-    switch (entry.type) {
+var revertLeafChange = (obj, change, embeddedKey = "$index", isPath) => {
+  const { type, key, value, oldValue } = change;
+  if (key === "$root") {
+    switch (type) {
       case "ADD" /* ADD */:
+        for (const prop in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+            delete obj[prop];
+          }
+        }
+        return obj;
       case "UPDATE" /* UPDATE */:
-        setByPath(object, path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
-        break;
-      case "REMOVE" /* REMOVE */:
-        setByPath(object, path, { type: entry.type, value: void 0, oldValue: entry.value });
-        break;
-      default:
-        throw new Error();
-    }
-  });
-  return object;
-};
-var ARRAY_WRAPPER_KEY = "_$arr";
-var compare2 = (oldObject, newObject) => {
-  if (Array.isArray(oldObject) || Array.isArray(newObject)) {
-    const wrappedOld = { [ARRAY_WRAPPER_KEY]: oldObject };
-    const wrappedNew = { [ARRAY_WRAPPER_KEY]: newObject };
-    const enriched = enrich(wrappedOld);
-    const changes = atomizeChangeset(diff(wrappedOld, wrappedNew));
-    const result = applyChangelist(enriched, changes);
-    return result.value[ARRAY_WRAPPER_KEY];
-  }
-  return applyChangelist(enrich(oldObject), atomizeChangeset(diff(oldObject, newObject)));
-};
-var comparisonToDict = (node) => {
-  const result = { type: node.type };
-  if (node.type === "CONTAINER" /* CONTAINER */) {
-    if (Array.isArray(node.value)) {
-      const children = node.value;
-      const serialized = new Array(children.length);
-      for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        serialized[i] = child != null ? comparisonToDict(child) : null;
-      }
-      result.value = serialized;
-    } else if (node.value && typeof node.value === "object") {
-      const obj = /* @__PURE__ */ Object.create(null);
-      for (const [key, child] of Object.entries(
-        node.value
-      )) {
-        if (child == null) continue;
-        obj[key] = comparisonToDict(child);
-      }
-      result.value = obj;
-    }
-  } else {
-    if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
-      result.value = node.value;
-    }
-    if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
-      result.oldValue = node.oldValue;
-    }
-  }
-  return result;
-};
-var IDENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var comparisonToFlatList = (node, options = {}) => {
-  const results = [];
-  flattenNode(node, "$", options.includeUnchanged ?? false, results);
-  return results;
-};
-function flattenNode(node, path, includeUnchanged, results) {
-  if (node.type === "CONTAINER" /* CONTAINER */) {
-    if (Array.isArray(node.value)) {
-      for (let i = 0; i < node.value.length; i++) {
-        const child = node.value[i];
-        if (child == null) continue;
-        flattenNode(child, `${path}[${i}]`, includeUnchanged, results);
-      }
-    } else if (node.value && typeof node.value === "object") {
-      for (const [key, child] of Object.entries(
-        node.value
-      )) {
-        if (child == null) continue;
-        const childPath = IDENT_RE2.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
-        flattenNode(child, childPath, includeUnchanged, results);
-      }
-    }
-    return;
-  }
-  if (node.type === "UNCHANGED" /* UNCHANGED */ && !includeUnchanged) {
-    return;
-  }
-  const entry = { path, type: node.type };
-  if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
-    entry.value = node.value;
-  }
-  if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
-    entry.oldValue = node.oldValue;
-  }
-  results.push(entry);
-}
-
-// src/atomPath.ts
-function formatFilterLiteral(value) {
-  if (value === null) return "null";
-  if (typeof value === "boolean") return String(value);
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`Cannot format non-finite number as filter literal: ${value}`);
-    return String(value);
-  }
-  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
-  throw new Error(`Cannot format filter literal for type ${typeof value}`);
-}
-function parseFilterLiteral(s) {
-  if (s === "true") return true;
-  if (s === "false") return false;
-  if (s === "null") return null;
-  if (s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1).replace(/''/g, "'");
-  }
-  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-    return Number(s);
-  }
-  throw new Error(`Invalid filter literal: ${s}`);
-}
-function extractQuotedString(s, start) {
-  const result = [];
-  let i = start;
-  while (i < s.length) {
-    if (s[i] === "'") {
-      if (i + 1 < s.length && s[i + 1] === "'") {
-        result.push("'");
-        i += 2;
-      } else {
-        return [result.join(""), i];
-      }
-    } else {
-      result.push(s[i]);
-      i += 1;
-    }
-  }
-  throw new Error("Unterminated quoted string");
-}
-function findFilterClose(s, from) {
-  let i = from;
-  while (i < s.length) {
-    if (s[i] === "'") {
-      i += 1;
-      while (i < s.length) {
-        if (s[i] === "'") {
-          if (i + 1 < s.length && s[i + 1] === "'") {
-            i += 2;
-          } else {
-            i += 1;
-            break;
+        for (const prop in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+            delete obj[prop];
           }
-        } else {
-          i += 1;
         }
-      }
-    } else if (s[i] === ")" && i + 1 < s.length && s[i + 1] === "]") {
-      return i;
-    } else {
-      i += 1;
-    }
-  }
-  return -1;
-}
-var NESTED_PATH_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function parseFilter(inner) {
-  if (inner.startsWith("@.")) {
-    const eq = inner.indexOf("==");
-    if (eq === -1) throw new Error(`Invalid filter: missing '==' in ${inner}`);
-    const key = inner.slice(2, eq);
-    if (!key || !NESTED_PATH_RE2.test(key)) {
-      throw new Error(`Invalid property name in filter: '${key}'. Use bracket notation for non-identifier keys: @['${key}']`);
+        if (oldValue && typeof oldValue === "object") {
+          Object.assign(obj, oldValue);
+        }
+        return obj;
+      case "REMOVE" /* REMOVE */:
+        if (value && typeof value === "object") {
+          Object.assign(obj, value);
+        }
+        return obj;
     }
-    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(eq + 2)) };
-  }
-  if (inner.startsWith("@['")) {
-    const [key, endIdx] = extractQuotedString(inner, 3);
-    const valStart = endIdx + 4;
-    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(valStart)), literalKey: true };
-  }
-  if (inner.startsWith("@==")) {
-    return { type: "valueFilter", value: parseFilterLiteral(inner.slice(3)) };
   }
-  throw new Error(`Invalid filter expression: ${inner}`);
-}
-function parseAtomPath(path) {
-  if (!path.startsWith("$")) {
-    throw new Error(`Path must start with '$': ${path}`);
+  switch (type) {
+    case "ADD" /* ADD */:
+      return removeKey(obj, key, embeddedKey, isPath);
+    case "UPDATE" /* UPDATE */:
+      return modifyKeyValue(obj, key, oldValue);
+    case "REMOVE" /* REMOVE */:
+      return addKeyValue(obj, key, value, embeddedKey);
   }
-  const segments = [{ type: "root" }];
-  let i = 1;
-  while (i < path.length) {
-    if (path[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < path.length && /[a-zA-Z0-9_]/.test(path[i])) {
-        i += 1;
+};
+var revertArrayChange = (arr, change) => {
+  let changes = change.changes;
+  if (change.embeddedKey === "$index") {
+    changes = [...changes].sort((a, b) => {
+      if (a.type === "ADD" /* ADD */ && b.type === "ADD" /* ADD */) {
+        return Number(b.key) - Number(a.key);
       }
-      if (i === start) throw new Error(`Empty property name at position ${i} in: ${path}`);
-      segments.push({ type: "property", name: path.slice(start, i) });
-    } else if (path[i] === "[") {
-      if (i + 1 >= path.length) throw new Error(`Unexpected end of path after '[': ${path}`);
-      if (path[i + 1] === "?") {
-        const closingIdx = findFilterClose(path, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter expression in: ${path}`);
-        const inner = path.slice(i + 3, closingIdx);
-        segments.push(parseFilter(inner));
-        i = closingIdx + 2;
-      } else if (path[i + 1] === "'") {
-        const [key, endIdx] = extractQuotedString(path, i + 2);
-        if (path[endIdx + 1] !== "]") throw new Error(`Expected ']' after bracket property in: ${path}`);
-        segments.push({ type: "property", name: key });
-        i = endIdx + 2;
-      } else if (/\d/.test(path[i + 1])) {
-        const end = path.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated array index in: ${path}`);
-        const indexStr = path.slice(i + 1, end);
-        if (indexStr.length > 1 && indexStr[0] === "0") {
-          throw new Error(`Leading zeros not allowed in array index: [${indexStr}]`);
+      if (a.type === "ADD" /* ADD */) return -1;
+      if (b.type === "ADD" /* ADD */) return 1;
+      return Number(a.key) - Number(b.key);
+    });
+  }
+  for (const subchange of changes) {
+    if (!subchange.changes) {
+      revertLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
+    } else {
+      let element;
+      if (change.embeddedKey === "$index") {
+        element = arr[+subchange.key];
+      } else if (change.embeddedKey === "$value") {
+        const index = arr.indexOf(subchange.key);
+        if (index !== -1) {
+          element = arr[index];
         }
-        segments.push({ type: "index", index: Number(indexStr) });
-        i = end + 1;
       } else {
-        throw new Error(`Unexpected character after '[': '${path[i + 1]}' in: ${path}`);
+        element = arr.find((el) => {
+          const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
+          return resolved !== void 0 && String(resolved) === String(subchange.key);
+        });
       }
-    } else {
-      throw new Error(`Unexpected character '${path[i]}' at position ${i} in: ${path}`);
-    }
-  }
-  return segments;
-}
-var SIMPLE_PROPERTY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function formatMemberAccess(name) {
-  if (SIMPLE_PROPERTY_RE.test(name)) {
-    return `.${name}`;
-  }
-  return `['${name.replace(/'/g, "''")}']`;
-}
-function buildAtomPath(segments) {
-  let result = "";
-  for (const seg of segments) {
-    switch (seg.type) {
-      case "root":
-        result += "$";
-        break;
-      case "property":
-        result += formatMemberAccess(seg.name);
-        break;
-      case "index":
-        result += `[${seg.index}]`;
-        break;
-      case "keyFilter": {
-        let memberAccess;
-        if (seg.literalKey) {
-          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
-        } else if (NESTED_PATH_RE2.test(seg.property)) {
-          memberAccess = `.${seg.property}`;
-        } else {
-          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
-        }
-        result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
-        break;
+      if (element) {
+        revertChangeset(element, subchange.changes);
       }
-      case "valueFilter":
-        result += `[?(@==${formatFilterLiteral(seg.value)})]`;
-        break;
     }
   }
-  return result;
-}
-function canonicalizeFilterForAtom(inner) {
-  if (inner.startsWith("@.")) {
-    const eqIdx = inner.indexOf("==");
-    if (eqIdx === -1) return `[?(${inner})]`;
-    const key = inner.slice(2, eqIdx);
-    const valuePart = inner.slice(eqIdx);
-    if (NESTED_PATH_RE2.test(key)) {
-      return `[?(@.${key}${valuePart})]`;
-    }
-    return `[?(@['${key.replace(/'/g, "''")}']${valuePart})]`;
+  return arr;
+};
+var revertBranchChange = (obj, change) => {
+  if (Array.isArray(obj)) {
+    return revertArrayChange(obj, change);
+  } else {
+    return revertChangeset(obj, change.changes);
   }
-  return `[?(${inner})]`;
-}
-function canonicalizeFilterForV4(inner) {
-  if (inner.startsWith("@['")) {
-    const [key, endIdx] = extractQuotedString(inner, 3);
-    const rest = inner.slice(endIdx + 2);
-    if (rest.startsWith("==")) {
-      const literal = rest.slice(2);
-      const normalizedLiteral = normalizeToStringQuoted(literal);
-      return `[?(@.${key}==${normalizedLiteral})]`;
-    }
-    return `[?(${inner})]`;
+};
+function append(basePath, nextSegment) {
+  if (!nextSegment || /[[\]'\\]/.test(nextSegment) || /^\d/.test(nextSegment)) {
+    return `${basePath}['${nextSegment.replace(/'/g, "''")}']`;
   }
-  return normalizeFilterToStringLiterals(`[?(${inner})]`);
+  return nextSegment.includes(".") ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
 }
-function normalizeToStringQuoted(literal) {
-  if (literal.startsWith("'") && literal.endsWith("'")) {
-    return literal;
+var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var NESTED_PATH_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function filterExpression(basePath, filterKey, filterValue2, isPath) {
+  const escapedValue = `'${filterValue2.replace(/'/g, "''")}'`;
+  let memberAccess;
+  if (isPath && NESTED_PATH_RE2.test(filterKey)) {
+    memberAccess = "." + filterKey;
+  } else if (IDENT_RE.test(filterKey)) {
+    memberAccess = `.${filterKey}`;
+  } else {
+    memberAccess = `['${filterKey.replace(/'/g, "''")}']`;
   }
-  const value = parseFilterLiteral(literal);
-  const stringValue = String(value).replace(/'/g, "''");
-  return `'${stringValue}'`;
+  return `${basePath}[?(@${memberAccess}==${escapedValue})]`;
 }
-function atomicPathToAtomPath(atomicPath) {
-  if (atomicPath === "$.$root") return "$";
-  if (atomicPath.startsWith("$.$root.")) return "$" + atomicPath.slice(7);
-  if (!atomicPath.startsWith("$")) {
-    throw new Error(`Atomic path must start with '$': ${atomicPath}`);
+
+// src/jsonCompare.ts
+var CompareOperation = /* @__PURE__ */ ((CompareOperation2) => {
+  CompareOperation2["CONTAINER"] = "CONTAINER";
+  CompareOperation2["UNCHANGED"] = "UNCHANGED";
+  return CompareOperation2;
+})(CompareOperation || {});
+var createValue = (value) => ({ type: "UNCHANGED" /* UNCHANGED */, value });
+var createContainer = (value) => ({
+  type: "CONTAINER" /* CONTAINER */,
+  value
+});
+var enrich = (object) => {
+  const objectType = getTypeOfObj(object);
+  switch (objectType) {
+    case "Object":
+      return Object.keys(object).map((key) => ({ key, value: enrich(object[key]) })).reduce((accumulator, entry) => {
+        accumulator.value[entry.key] = entry.value;
+        return accumulator;
+      }, createContainer({}));
+    case "Array":
+      return object.map((value) => enrich(value)).reduce((accumulator, value) => {
+        accumulator.value.push(value);
+        return accumulator;
+      }, createContainer([]));
+    case "Function":
+      return void 0;
+    case "Date":
+    default:
+      return createValue(object);
   }
-  let result = "$";
-  let i = 1;
-  while (i < atomicPath.length) {
-    if (atomicPath[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < atomicPath.length && atomicPath[i] !== "." && atomicPath[i] !== "[") {
-        i += 1;
-      }
-      const name = atomicPath.slice(start, i);
-      result += formatMemberAccess(name);
-    } else if (atomicPath[i] === "[") {
-      if (atomicPath[i + 1] === "?") {
-        const closingIdx = findFilterClose(atomicPath, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomicPath}`);
-        const inner = atomicPath.slice(i + 3, closingIdx);
-        result += canonicalizeFilterForAtom(inner);
-        i = closingIdx + 2;
-      } else if (atomicPath[i + 1] === "'" || /\d/.test(atomicPath[i + 1])) {
-        const end = atomicPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
-        result += atomicPath.slice(i, end + 1);
-        i = end + 1;
-      } else {
-        const end = atomicPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
-        const name = atomicPath.slice(i + 1, end);
-        result += `['${name.replace(/'/g, "''")}']`;
-        i = end + 1;
-      }
+};
+var buildEnrichedPath = (atomicPath) => {
+  const segments = splitJSONPath(atomicPath);
+  let result = "value";
+  for (let i = 1; i < segments.length; i++) {
+    const seg = segments[i];
+    const isLast = i === segments.length - 1;
+    const arrayMatch = /^(.+?)\[(\d+)\]$/.exec(seg);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      result += `.${key}.value[${index}]`;
     } else {
-      throw new Error(`Unexpected character '${atomicPath[i]}' in atomic path: ${atomicPath}`);
+      result += `.${seg}`;
+    }
+    if (!isLast) {
+      result += ".value";
     }
   }
   return result;
-}
-function atomPathToAtomicPath(atomPath) {
-  if (!atomPath.startsWith("$")) {
-    throw new Error(`Atom path must start with '$': ${atomPath}`);
-  }
-  if (atomPath === "$") {
-    return "$.$root";
+};
+var applyChangelist = (object, changelist) => {
+  changelist.forEach((entry) => {
+    const path = buildEnrichedPath(entry.path);
+    switch (entry.type) {
+      case "ADD" /* ADD */:
+      case "UPDATE" /* UPDATE */:
+        setByPath(object, path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
+        break;
+      case "REMOVE" /* REMOVE */:
+        setByPath(object, path, { type: entry.type, value: void 0, oldValue: entry.value });
+        break;
+      default:
+        throw new Error();
+    }
+  });
+  return object;
+};
+var ARRAY_WRAPPER_KEY = "_$arr";
+var compare2 = (oldObject, newObject) => {
+  if (Array.isArray(oldObject) || Array.isArray(newObject)) {
+    const wrappedOld = { [ARRAY_WRAPPER_KEY]: oldObject };
+    const wrappedNew = { [ARRAY_WRAPPER_KEY]: newObject };
+    const enriched = enrich(wrappedOld);
+    const changes = atomizeChangeset(diff(wrappedOld, wrappedNew));
+    const result = applyChangelist(enriched, changes);
+    return result.value[ARRAY_WRAPPER_KEY];
   }
-  let result = "$";
-  let i = 1;
-  while (i < atomPath.length) {
-    if (atomPath[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < atomPath.length && /[a-zA-Z0-9_]/.test(atomPath[i])) {
-        i += 1;
+  return applyChangelist(enrich(oldObject), atomizeChangeset(diff(oldObject, newObject)));
+};
+var comparisonToDict = (node) => {
+  const result = { type: node.type };
+  if (node.type === "CONTAINER" /* CONTAINER */) {
+    if (Array.isArray(node.value)) {
+      const children = node.value;
+      const serialized = new Array(children.length);
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        serialized[i] = child != null ? comparisonToDict(child) : null;
       }
-      result += "." + atomPath.slice(start, i);
-    } else if (atomPath[i] === "[") {
-      if (atomPath[i + 1] === "?") {
-        const closingIdx = findFilterClose(atomPath, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomPath}`);
-        const inner = atomPath.slice(i + 3, closingIdx);
-        result += canonicalizeFilterForV4(inner);
-        i = closingIdx + 2;
-      } else if (atomPath[i + 1] === "'") {
-        const [key, endIdx] = extractQuotedString(atomPath, i + 2);
-        if (atomPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomPath}`);
-        result += `[${key}]`;
-        i = endIdx + 2;
-      } else if (/\d/.test(atomPath[i + 1])) {
-        const end = atomPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomPath}`);
-        result += atomPath.slice(i, end + 1);
-        i = end + 1;
-      } else {
-        throw new Error(`Unexpected character after '[' in: ${atomPath}`);
+      result.value = serialized;
+    } else if (node.value && typeof node.value === "object") {
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (const [key, child] of Object.entries(
+        node.value
+      )) {
+        if (child == null) continue;
+        obj[key] = comparisonToDict(child);
       }
-    } else {
-      throw new Error(`Unexpected character '${atomPath[i]}' in atom path: ${atomPath}`);
+      result.value = obj;
+    }
+  } else {
+    if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
+      result.value = node.value;
+    }
+    if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
+      result.oldValue = node.oldValue;
     }
   }
   return result;
-}
-function normalizeFilterToStringLiterals(filter) {
-  const eqIdx = filter.indexOf("==");
-  if (eqIdx === -1) return filter;
-  const literalStart = eqIdx + 2;
-  const literalEnd = filter.length - 2;
-  const literal = filter.slice(literalStart, literalEnd);
-  if (literal.startsWith("'") && literal.endsWith("'")) {
-    return filter;
-  }
-  const value = parseFilterLiteral(literal);
-  const stringValue = String(value).replace(/'/g, "''");
-  return filter.slice(0, literalStart) + `'${stringValue}'` + filter.slice(literalEnd);
-}
-function extractKeyFromAtomicPath(atomicPath) {
-  if (atomicPath === "$.$root") return "$root";
-  if (atomicPath.endsWith(")]")) {
-    const filterStart = atomicPath.lastIndexOf("[?(");
-    if (filterStart !== -1) {
-      const inner = atomicPath.slice(filterStart + 3, atomicPath.length - 2);
-      if (inner.startsWith("@==")) {
-        const val = parseFilterLiteral(inner.slice(3));
-        return String(val);
+};
+var IDENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var comparisonToFlatList = (node, options = {}) => {
+  const results = [];
+  flattenNode(node, "$", options.includeUnchanged ?? false, results);
+  return results;
+};
+function flattenNode(node, path, includeUnchanged, results) {
+  if (node.type === "CONTAINER" /* CONTAINER */) {
+    if (Array.isArray(node.value)) {
+      for (let i = 0; i < node.value.length; i++) {
+        const child = node.value[i];
+        if (child == null) continue;
+        flattenNode(child, `${path}[${i}]`, includeUnchanged, results);
       }
-      const eqIdx = inner.indexOf("==");
-      if (eqIdx !== -1) {
-        const val = parseFilterLiteral(inner.slice(eqIdx + 2));
-        return String(val);
+    } else if (node.value && typeof node.value === "object") {
+      for (const [key, child] of Object.entries(
+        node.value
+      )) {
+        if (child == null) continue;
+        const childPath = IDENT_RE2.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
+        flattenNode(child, childPath, includeUnchanged, results);
       }
     }
+    return;
   }
-  if (atomicPath.endsWith("]")) {
-    const bracketStart = atomicPath.lastIndexOf("[");
-    if (bracketStart !== -1) {
-      const inner = atomicPath.slice(bracketStart + 1, atomicPath.length - 1);
-      if (/^\d+$/.test(inner)) return inner;
-      return inner;
-    }
+  if (node.type === "UNCHANGED" /* UNCHANGED */ && !includeUnchanged) {
+    return;
+  }
+  const entry = { path, type: node.type };
+  if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
+    entry.value = node.value;
+  }
+  if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
+    entry.oldValue = node.oldValue;
+  }
+  results.push(entry);
+}
+
+// src/atomValidation.ts
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return false;
+  if (Object.getOwnPropertySymbols(value).length) return false;
+  if (Array.isArray(value) && Object.keys(value).length !== value.length) return false;
+  ancestors.add(value);
+  const valid = Object.values(value).every((child) => isJsonValue(child, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+
+// src/atomApply.ts
+var owns = (obj, key) => obj !== null && typeof obj === "object" && Object.prototype.hasOwnProperty.call(obj, key);
+function filterValue(item, filter) {
+  if (filter.type === "valueFilter") return item;
+  const keys = filter.memberPath ?? (filter.literalKey ? [filter.property] : filter.property.split("."));
+  return keys.reduce((value, key) => owns(value, key) ? value[key] : void 0, item);
+}
+function locate(parent, segment, adding = false) {
+  if (segment.type === "property") {
+    if (parent === null || typeof parent !== "object" || Array.isArray(parent)) {
+      throw new Error(`Cannot access property '${segment.name}' on non-object`);
+    }
+    const exists = owns(parent, segment.name);
+    if (adding ? exists : !exists) throw new Error(`Property '${segment.name}' ${exists ? "already exists" : "does not exist"}`);
+    return segment.name;
+  }
+  if (!Array.isArray(parent)) {
+    const names = { index: "access index", keyFilter: "apply key filter", valueFilter: "apply value filter" };
+    throw new Error(`Cannot ${names[segment.type]} on non-array`);
+  }
+  if (segment.type === "index") {
+    const limit = adding ? parent.length : parent.length - 1;
+    if (segment.index > limit) throw new Error(`Array index ${segment.index} is out of bounds`);
+    return segment.index;
+  }
+  const matches = parent.flatMap((item, index) => filterValue(item, segment) === segment.value ? [index] : []);
+  if (matches.length > 1) throw new Error("Array filter matches multiple elements");
+  if (adding) {
+    if (matches.length) throw new Error("Array filter target already exists");
+    return parent.length;
+  }
+  if (!matches.length) throw new Error("Array filter does not match an element");
+  return matches[0];
+}
+function resolve(obj, segments) {
+  return segments.reduce((current, segment) => current[locate(current, segment)], obj);
+}
+function selectors(path) {
+  return parseAtomPath(path).slice(1);
+}
+function setOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function applyValue(obj, op) {
+  const segments = selectors(op.path);
+  if (segments.length === 0) {
+    if (op.op === "add" && obj !== null) throw new Error("Root add requires a null source");
+    if (op.op !== "add" && obj === null) throw new Error("Root remove/replace requires a non-null source");
+    if (op.op === "remove") return null;
+    const value = structuredClone(op.value);
+    if (op.op === "replace" && obj && value && typeof obj === "object" && typeof value === "object" && !Array.isArray(obj) && !Array.isArray(value)) {
+      for (const key2 of Object.keys(obj)) delete obj[key2];
+      for (const key2 of Object.keys(value)) setOwn(obj, key2, value[key2]);
+      return obj;
+    }
+    return value;
+  }
+  const last = segments.at(-1);
+  const parent = resolve(obj, segments.slice(0, -1));
+  const key = locate(parent, last, op.op === "add");
+  if (op.op !== "remove" && last.type === "keyFilter" && filterValue(op.value, last) !== last.value) {
+    throw new Error("Keyed-array value does not match its identity filter");
+  }
+  if (op.op === "add" && last.type === "valueFilter" && op.value !== last.value) {
+    throw new Error("Added value does not match its value filter");
+  }
+  if (op.op === "remove") {
+    if (Array.isArray(parent)) parent.splice(Number(key), 1);
+    else delete parent[key];
+  } else {
+    const value = structuredClone(op.value);
+    if (Array.isArray(parent) && op.op === "add") parent.splice(Number(key), 0, value);
+    else setOwn(parent, key, value);
   }
-  const lastDot = atomicPath.lastIndexOf(".");
-  if (lastDot > 0) {
-    return atomicPath.slice(lastDot + 1);
+  return obj;
+}
+function applyAtomOperations(obj, atom) {
+  let result = obj;
+  for (const op of atom.operations) {
+    if (op.op === "move" || op.op === "copy") {
+      const value = resolve(result, selectors(op.from));
+      const add = { op: "add", path: op.path, value };
+      if (op.op === "move") {
+        const remove = { op: "remove", path: op.from };
+        const probe = applyValue(structuredClone(result), remove);
+        applyValue(probe, add);
+        result = applyValue(result, remove);
+      }
+      result = applyValue(result, add);
+    } else {
+      result = applyValue(result, op);
+    }
   }
-  return atomicPath;
+  return result;
 }
 
 // src/jsonAtom.ts
@@ -1238,8 +1320,8 @@ function validateAtom(atom) {
   if (d.format !== "json-atom") {
     errors.push(`Invalid or missing format: expected 'json-atom', got '${d.format}'`);
   }
-  if (typeof d.version !== "number") {
-    errors.push(`Missing or invalid version: expected number, got '${typeof d.version}'`);
+  if (d.version !== 1) {
+    errors.push(`Missing or invalid version: expected 1, got '${d.version}'`);
   }
   if (!Array.isArray(d.operations)) {
     errors.push("Missing or invalid operations: expected array");
@@ -1256,6 +1338,18 @@ function validateAtom(atom) {
       if (typeof op.path !== "string") {
         errors.push(`operations[${i}]: path must be a string`);
       }
+      for (const field of ["value", "oldValue"]) {
+        if (field in op && !isJsonValue(op[field])) errors.push(`operations[${i}]: ${field} must be a JSON value`);
+      }
+      for (const field of ["path", ...["move", "copy"].includes(op.op) ? ["from"] : []]) {
+        if (typeof op[field] === "string") {
+          try {
+            parseAtomPath(op[field]);
+          } catch (error) {
+            errors.push(`operations[${i}]: invalid ${field}: ${error.message}`);
+          }
+        }
+      }
       if (op.op === "add") {
         if (!("value" in op)) {
           errors.push(`operations[${i}]: add operation must have value`);
@@ -1280,11 +1374,13 @@ function validateAtom(atom) {
         if ("oldValue" in op) {
           errors.push(`operations[${i}]: move operation must not have oldValue`);
         }
-        if (typeof op.from === "string" && typeof op.path === "string") {
-          if (op.from === op.path) {
+        if (typeof op.from === "string" && typeof op.path === "string" && !errors.length) {
+          const from = buildAtomPath(parseAtomPath(op.from));
+          const path = buildAtomPath(parseAtomPath(op.path));
+          if (from === path) {
             errors.push(`operations[${i}]: move operation from must not equal path (self-move)`);
           }
-          if (op.from !== "$" && (op.path.startsWith(op.from + ".") || op.path.startsWith(op.from + "["))) {
+          if (path.startsWith(from + ".") || path.startsWith(from + "[")) {
             errors.push(`operations[${i}]: move operation path must not be a subtree of from`);
           }
         }
@@ -1309,11 +1405,16 @@ function diffAtom(oldObj, newObj, options = {}) {
   });
   const operations = [];
   walkChanges(changeset, "$", oldObj, newObj, operations, options);
-  return {
-    format: "json-atom",
-    version: 1,
-    operations
-  };
+  if (operations.length === 1 && operations[0].path === "$") {
+    if (oldObj === null && newObj !== null) operations[0] = { op: "add", path: "$", value: newObj };
+    if (newObj === null && oldObj !== null) {
+      operations[0] = { op: "remove", path: "$", ...options.reversible === false ? {} : { oldValue: oldObj } };
+    }
+  }
+  const atom = { format: "json-atom", version: 1, operations };
+  const validation = validateAtom(atom);
+  if (!validation.valid) throw new Error(`Cannot produce JSON Atom: ${validation.errors.join(", ")}`);
+  return atom;
 }
 function mergeTypeChangePairs(changes) {
   const result = [];
@@ -1334,6 +1435,7 @@ function mergeTypeChangePairs(changes) {
   }
   return result;
 }
+var NESTED_PATH_RE3 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
 var SIMPLE_PROPERTY_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 function appendCanonicalProperty(basePath, name) {
   if (SIMPLE_PROPERTY_RE2.test(name)) {
@@ -1344,46 +1446,91 @@ function appendCanonicalProperty(basePath, name) {
 function walkChanges(changes, basePath, oldCtx, newCtx, ops, options) {
   const merged = mergeTypeChangePairs(changes);
   for (const change of merged) {
+    const isRoot = change.key === "$root" && basePath === "$" && (oldCtx === null || newCtx === null || typeof oldCtx !== "object" || typeof newCtx !== "object" || Array.isArray(oldCtx) || Array.isArray(newCtx));
     if (change.isMergedReplace) {
       const mc = change;
-      const path = mc.key === "$root" ? "$" : appendCanonicalProperty(basePath, mc.key);
+      const path = isRoot ? "$" : appendCanonicalProperty(basePath, mc.key);
       const op = { op: "replace", path, value: mc.addValue };
       if (options.reversible !== false) {
         op.oldValue = mc.removeValue;
       }
       ops.push(op);
     } else if (change.changes) {
-      const childPath = change.key === "$root" ? "$" : appendCanonicalProperty(basePath, change.key);
-      const childOld = change.key === "$root" ? oldCtx : oldCtx?.[change.key];
-      const childNew = change.key === "$root" ? newCtx : newCtx?.[change.key];
+      const childPath = isRoot ? "$" : appendCanonicalProperty(basePath, change.key);
+      const childOld = isRoot ? oldCtx : oldCtx?.[change.key];
+      const childNew = isRoot ? newCtx : newCtx?.[change.key];
       if (change.embeddedKey) {
-        for (const childChange of change.changes) {
-          const filterPath = buildCanonicalFilterPath(
-            childPath,
-            change.embeddedKey,
-            childChange.key,
-            childOld,
-            childNew,
-            childChange,
-            change.embeddedKeyIsPath
-          );
-          if (childChange.changes) {
-            const oldEl = findElement(childOld, change.embeddedKey, childChange.key);
-            const newEl = findElement(childNew, change.embeddedKey, childChange.key);
-            walkChanges(childChange.changes, filterPath, oldEl, newEl, ops, options);
-          } else {
-            emitLeafOp(childChange, filterPath, ops, options);
-          }
-        }
+        walkArrayChanges(change, childPath, childOld, childNew, ops, options);
       } else {
         walkChanges(change.changes, childPath, childOld, childNew, ops, options);
       }
     } else {
-      const path = change.key === "$root" ? "$" : appendCanonicalProperty(basePath, change.key);
+      const path = isRoot ? "$" : appendCanonicalProperty(basePath, change.key);
       emitLeafOp(change, path, ops, options);
     }
   }
 }
+function walkArrayChanges(change, path, oldArr, newArr, ops, options) {
+  const ordered = orderArrayChildChanges(change.changes, change.embeddedKey);
+  for (const child of mergeTypeChangePairs(ordered)) {
+    const childPath = buildCanonicalFilterPath(path, change.embeddedKey, child.key, oldArr, newArr, child, change.embeddedKeyIsPath);
+    if (child.isMergedReplace) {
+      ops.push({
+        op: "replace",
+        path: childPath,
+        value: child.addValue,
+        ...options.reversible === false ? {} : { oldValue: child.removeValue }
+      });
+    } else if (child.changes) {
+      const oldEl = findElement(oldArr, change.embeddedKey, child.key, change.embeddedKeyIsPath);
+      const newEl = findElement(newArr, change.embeddedKey, child.key, change.embeddedKeyIsPath);
+      if (child.embeddedKey) walkArrayChanges(child, childPath, oldEl, newEl, ops, options);
+      else walkChanges(child.changes, childPath, oldEl, newEl, ops, options);
+    } else {
+      emitLeafOp(child, childPath, ops, options);
+    }
+  }
+}
+function orderArrayChildChanges(changes, embeddedKey) {
+  if (embeddedKey !== "$index") {
+    return changes;
+  }
+  const groups = [];
+  const pureRemoves = [];
+  for (let i = 0; i < changes.length; i++) {
+    const current = changes[i];
+    const next = changes[i + 1];
+    if (current.type === "REMOVE" /* REMOVE */ && next && next.type === "ADD" /* ADD */ && String(current.key) === String(next.key)) {
+      groups.push({ kind: "preserved", changes: [current, next] });
+      i++;
+      continue;
+    }
+    if (current.type === "REMOVE" /* REMOVE */) {
+      pureRemoves.push(current);
+      groups.push({ kind: "pure-remove" });
+      continue;
+    }
+    groups.push({ kind: "preserved", changes: [current] });
+  }
+  if (pureRemoves.length < 2) {
+    return changes;
+  }
+  const removeIndices = pureRemoves.map((change) => Number(change.key));
+  if (removeIndices.some((idx) => !Number.isInteger(idx))) {
+    return changes;
+  }
+  pureRemoves.sort((a, b) => Number(b.key) - Number(a.key));
+  const ordered = [];
+  let removeIndex = 0;
+  for (const group of groups) {
+    if (group.kind === "pure-remove") {
+      ordered.push(pureRemoves[removeIndex++]);
+    } else {
+      ordered.push(...group.changes);
+    }
+  }
+  return ordered;
+}
 function emitLeafOp(change, path, ops, options) {
   switch (change.type) {
     case "ADD" /* ADD */: {
@@ -1458,7 +1605,7 @@ function findActualValue(oldArr, newArr, stringKey, opType) {
   }
   return stringKey;
 }
-function findElement(arr, embeddedKey, changeKey) {
+function findElement(arr, embeddedKey, changeKey, isPath = false) {
   if (!arr || !Array.isArray(arr)) return void 0;
   if (embeddedKey === "$index") {
     return arr[Number(changeKey)];
@@ -1469,7 +1616,7 @@ function findElement(arr, embeddedKey, changeKey) {
   if (typeof embeddedKey === "function") {
     return arr.find((item) => String(embeddedKey(item)) === changeKey);
   }
-  return arr.find((item) => item && String(item[embeddedKey]) === changeKey);
+  return arr.find((item) => item && String(resolveNestedKey(item, embeddedKey, isPath)) === changeKey);
 }
 function resolveNestedKey(item, key, isPath) {
   if (isPath) {
@@ -1534,9 +1681,30 @@ function toAtom(changeset, options = {}) {
         throw new Error(`Unknown operation type: ${atom.type}`);
     }
   });
-  const operations = mergeConsecutiveOps(rawOps);
+  const operations = orderLegacyIndexRemoves(mergeConsecutiveOps(rawOps));
   return { format: "json-atom", version: 1, operations };
 }
+function orderLegacyIndexRemoves(operations) {
+  const groups = /* @__PURE__ */ new Map();
+  operations.forEach((operation, slot) => {
+    if (operation.op !== "remove") return;
+    const segments = parseAtomPath(operation.path);
+    const last = segments.at(-1);
+    if (last.type !== "index") return;
+    const parent = buildAtomPath(segments.slice(0, -1));
+    const group = groups.get(parent) ?? [];
+    group.push({ slot, index: last.index, operation });
+    groups.set(parent, group);
+  });
+  const result = [...operations];
+  for (const group of groups.values()) {
+    const ordered = [...group].sort((a, b) => b.index - a.index);
+    group.forEach((entry, index) => {
+      result[entry.slot] = ordered[index].operation;
+    });
+  }
+  return result;
+}
 function mergeConsecutiveOps(ops) {
   const result = [];
   let i = 0;
@@ -1629,8 +1797,13 @@ function invertAtom(atom) {
         return { op: "remove", path: op.path, oldValue: op.value, ...extensions };
       case "remove":
         return { op: "add", path: op.path, value: op.oldValue, ...extensions };
-      case "replace":
-        return { op: "replace", path: op.path, value: op.oldValue, oldValue: op.value, ...extensions };
+      case "replace": {
+        if (op.path === "$" && op.value === null) return { op: "add", path: "$", value: op.oldValue, ...extensions };
+        const segments = parseAtomPath(op.path);
+        const last = segments.at(-1);
+        if (last.type === "valueFilter") last.value = op.value;
+        return { op: "replace", path: buildAtomPath(segments), value: op.oldValue, oldValue: op.value, ...extensions };
+      }
       case "move":
         return { op: "move", from: op.path, path: op.from, ...extensions };
       case "copy":
@@ -1648,134 +1821,10 @@ function invertAtom(atom) {
   }
   return envelope;
 }
-var NESTED_PATH_RE3 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function resolveValueAtPath(obj, atomPath) {
-  const segments = parseAtomPath(atomPath);
-  let current = obj;
-  for (const seg of segments) {
-    switch (seg.type) {
-      case "root":
-        break;
-      case "property":
-        if (current == null || typeof current !== "object") {
-          throw new Error(`Cannot access property '${seg.name}' on ${current === null ? "null" : typeof current} at path: ${atomPath}`);
-        }
-        current = current[seg.name];
-        break;
-      case "index":
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot access index ${seg.index} on non-array at path: ${atomPath}`);
-        }
-        current = current[seg.index];
-        break;
-      case "keyFilter": {
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot apply key filter on non-array at path: ${atomPath}`);
-        }
-        const prop = seg.property;
-        const isPath = !seg.literalKey && prop.includes(".") && NESTED_PATH_RE3.test(prop);
-        current = current.find((el) => {
-          const resolved = isPath ? prop.split(".").reduce((c, s) => c?.[s], el) : el[prop];
-          return JSON.stringify(resolved) === JSON.stringify(seg.value);
-        });
-        break;
-      }
-      case "valueFilter": {
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot apply value filter on non-array at path: ${atomPath}`);
-        }
-        current = current.find((el) => JSON.stringify(el) === JSON.stringify(seg.value));
-        break;
-      }
-    }
-  }
-  return current;
-}
 function applyAtom(obj, atom) {
   const validation = validateAtom(atom);
-  if (!validation.valid) {
-    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
-  }
-  let result = obj;
-  for (const op of atom.operations) {
-    if (op.op === "move") {
-      const value = resolveValueAtPath(result, op.from);
-      const removeOp = { op: "remove", path: op.from, oldValue: value };
-      if (removeOp.path === "$") {
-        result = applyRootOp(result, removeOp);
-      } else {
-        const removeChange = atomOpToAtomicChange(removeOp);
-        applyChangeset(result, unatomizeChangeset([removeChange]));
-      }
-      const addOp = { op: "add", path: op.path, value };
-      if (addOp.path === "$") {
-        result = applyRootOp(result, addOp);
-      } else {
-        const addChange = atomOpToAtomicChange(addOp);
-        applyChangeset(result, unatomizeChangeset([addChange]));
-      }
-    } else if (op.op === "copy") {
-      const source = resolveValueAtPath(result, op.from);
-      const value = source === void 0 ? void 0 : JSON.parse(JSON.stringify(source));
-      const addOp = { op: "add", path: op.path, value };
-      if (addOp.path === "$") {
-        result = applyRootOp(result, addOp);
-      } else {
-        const addChange = atomOpToAtomicChange(addOp);
-        applyChangeset(result, unatomizeChangeset([addChange]));
-      }
-    } else if (op.path === "$") {
-      result = applyRootOp(result, op);
-    } else {
-      const atomicChange = atomOpToAtomicChange(op);
-      const miniChangeset = unatomizeChangeset([atomicChange]);
-      applyChangeset(result, miniChangeset);
-    }
-  }
-  return result;
-}
-function applyRootOp(obj, op) {
-  switch (op.op) {
-    case "add":
-      return op.value;
-    case "remove":
-      return null;
-    case "replace": {
-      if (typeof obj === "object" && obj !== null && !Array.isArray(obj) && typeof op.value === "object" && op.value !== null && !Array.isArray(op.value)) {
-        for (const key of Object.keys(obj)) {
-          delete obj[key];
-        }
-        Object.assign(obj, op.value);
-        return obj;
-      }
-      return op.value;
-    }
-    /* istanbul ignore next -- exhaustive switch */
-    default:
-      throw new Error(`Unknown operation: ${op.op}`);
-  }
-}
-function atomOpToAtomicChange(op) {
-  const atomicPath = atomPathToAtomicPath(op.path);
-  const key = extractKeyFromAtomicPath(atomicPath);
-  switch (op.op) {
-    case "add":
-      return { type: "ADD" /* ADD */, key, path: atomicPath, valueType: getValueType(op.value), value: op.value };
-    case "remove":
-      return { type: "REMOVE" /* REMOVE */, key, path: atomicPath, valueType: getValueType(op.oldValue), value: op.oldValue };
-    case "replace":
-      return {
-        type: "UPDATE" /* UPDATE */,
-        key,
-        path: atomicPath,
-        valueType: getValueType(op.value),
-        value: op.value,
-        oldValue: op.oldValue
-      };
-    /* istanbul ignore next -- exhaustive switch */
-    default:
-      throw new Error(`Unknown operation: ${op.op}`);
-  }
+  if (!validation.valid) throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
+  return applyAtomOperations(obj, atom);
 }
 function revertAtom(obj, atom) {
   const inverse = invertAtom(atom);
@@ -1783,10 +1832,11 @@ function revertAtom(obj, atom) {
 }
 
 // src/atomHelpers.ts
-var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "value", "oldValue"]);
+var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "from", "value", "oldValue"]);
 var ATOM_SPEC_KEYS = /* @__PURE__ */ new Set(["format", "version", "operations"]);
 function operationSpecDict(op) {
   const result = { op: op.op, path: op.path };
+  if ("from" in op) result.from = op.from;
   if ("value" in op) result.value = op.value;
   if ("oldValue" in op) result.oldValue = op.oldValue;
   return result;