json-diff-ts 5.0.0-alpha.1 → 5.0.0-alpha.4

package/dist/index.cjs

@@ -22,17 +22,39 @@ var index_exports = {};
 __export(index_exports, {
   CompareOperation: () => CompareOperation,
   Operation: () => Operation,
+  applyAtom: () => applyAtom,
   applyChangelist: () => applyChangelist,
   applyChangeset: () => applyChangeset,
+  atomExtensions: () => atomExtensions,
+  atomGroupBy: () => atomGroupBy,
+  atomMap: () => atomMap,
+  atomSpecDict: () => atomSpecDict,
+  atomStamp: () => atomStamp,
   atomizeChangeset: () => atomizeChangeset,
+  buildAtomPath: () => buildAtomPath,
   compare: () => compare2,
+  comparisonToDict: () => comparisonToDict,
+  comparisonToFlatList: () => comparisonToFlatList,
   createContainer: () => createContainer,
   createValue: () => createValue,
   diff: () => diff,
+  diffAtom: () => diffAtom,
   enrich: () => enrich,
+  formatFilterLiteral: () => formatFilterLiteral,
+  fromAtom: () => fromAtom,
   getTypeOfObj: () => getTypeOfObj,
+  invertAtom: () => invertAtom,
+  leafProperty: () => leafProperty,
+  operationExtensions: () => operationExtensions,
+  operationSpecDict: () => operationSpecDict,
+  parseAtomPath: () => parseAtomPath,
+  parseFilterLiteral: () => parseFilterLiteral,
+  revertAtom: () => revertAtom,
   revertChangeset: () => revertChangeset,
-  unatomizeChangeset: () => unatomizeChangeset
+  squashAtoms: () => squashAtoms,
+  toAtom: () => toAtom,
+  unatomizeChangeset: () => unatomizeChangeset,
+  validateAtom: () => validateAtom
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -73,13 +95,13 @@ function arrayIntersection(first, second) {
 }
 function keyBy(arr, getKey2) {
   const result = {};
-  for (const item of arr) {
-    result[String(getKey2(item))] = item;
+  for (const [index, item] of Object.entries(arr)) {
+    result[String(getKey2(item, false, Number(index)))] = item;
   }
   return result;
 }
 function setByPath(obj, path, value) {
-  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  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];
@@ -88,7 +110,7 @@ function setByPath(obj, path, value) {
     }
     current = current[part];
   }
-  current[parts[parts.length - 1]] = value;
+  current[parts.at(-1)] = value;
 }
 
 // src/jsonDiff.ts
@@ -96,12 +118,11 @@ var Operation = /* @__PURE__ */ ((Operation2) => {
   Operation2["REMOVE"] = "REMOVE";
   Operation2["ADD"] = "ADD";
   Operation2["UPDATE"] = "UPDATE";
-  Operation2["MOVE"] = "MOVE";
   return Operation2;
 })(Operation || {});
 function diff(oldObj, newObj, options = {}) {
-  let { embeddedObjKeys } = options;
-  const { keysToSkip, treatTypeChangeAsReplace, detectArrayMoves: detectArrayMoves2 } = 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]) => [
@@ -117,8 +138,7 @@ function diff(oldObj, newObj, options = {}) {
   return compare(oldObj, newObj, [], [], {
     embeddedObjKeys,
     keysToSkip: keysToSkip ?? [],
-    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true,
-    detectArrayMoves: detectArrayMoves2 ?? false
+    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true
   });
 }
 var applyChangeset = (obj, changeset) => {
@@ -128,7 +148,7 @@ var applyChangeset = (obj, changeset) => {
       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(obj[key], change);
+        applyBranchChange(key === "$root" ? obj : obj[key], change);
       }
     });
   }
@@ -141,7 +161,7 @@ var revertChangeset = (obj, changeset) => {
       if (!change.changes || value === null && type === "REMOVE" /* REMOVE */) {
         revertLeafChange(obj, change);
       } else {
-        revertBranchChange(obj[change.key], change);
+        revertBranchChange(change.key === "$root" ? obj : obj[change.key], change);
       }
     });
   }
@@ -165,22 +185,18 @@ var atomizeChangeset = (obj, path = "$", embeddedKey) => {
     const valueType = getTypeOfObj(obj.value);
     let finalPath = path;
     if (!finalPath.endsWith(`[${obj.key}]`)) {
-      const isTestEnv = typeof process !== "undefined" && process.env.NODE_ENV === "test";
-      const isSpecialTestCase = isTestEnv && (path === "$[a.b]" || path === "$.a" || path.includes("items") || path.includes("$.a[?(@[c.d]"));
-      if (!isSpecialTestCase || valueType === "Object") {
-        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).replace(/(^'|'$)/g, "");
-            endsWithFilterValue = filterValue === String(obj.key);
-          }
-        }
-        if (!endsWithFilterValue) {
-          finalPath = append(path, 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);
+      }
     }
     return [
       {
@@ -230,27 +246,23 @@ var unatomizeChangeset = (changes) => {
       ptr.type = change.type;
       ptr.value = change.value;
       ptr.oldValue = change.oldValue;
-      if (change.type === "MOVE" /* MOVE */) {
-        ptr.oldIndex = change.oldIndex;
-        ptr.newIndex = change.newIndex;
-      }
       changesArr.push(ptr);
     } else {
       for (let i = 1; i < segments.length; i++) {
         const segment = segments[i];
-        const result = /^([^[\]]+)\[\?\(@\.?([^=]*)=+'([^']+)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
+        const result = /^([^[\]]+)\[\?\(@(?:\.?([^=[]*)|(?:\['([^']*)'\]))=+'([^']+)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
         if (result) {
           let key;
           let embeddedKey;
           let arrKey;
           if (result[1]) {
             key = result[1];
-            embeddedKey = result[2] || "$value";
-            arrKey = result[3];
+            embeddedKey = result[3] || result[2] || "$value";
+            arrKey = result[4];
           } else {
-            key = result[4];
+            key = result[5];
             embeddedKey = "$index";
-            arrKey = Number(result[5]);
+            arrKey = Number(result[6]);
           }
           if (i === segments.length - 1) {
             ptr.key = key;
@@ -261,8 +273,7 @@ var unatomizeChangeset = (changes) => {
                 type: change.type,
                 key: arrKey,
                 value: change.value,
-                oldValue: change.oldValue,
-                ...change.type === "MOVE" /* MOVE */ && { oldIndex: change.oldIndex, newIndex: change.newIndex }
+                oldValue: change.oldValue
               }
             ];
           } else {
@@ -285,10 +296,6 @@ var unatomizeChangeset = (changes) => {
             ptr.type = change.type;
             ptr.value = change.value;
             ptr.oldValue = change.oldValue;
-            if (change.type === "MOVE" /* MOVE */) {
-              ptr.oldIndex = change.oldIndex;
-              ptr.newIndex = change.newIndex;
-            }
           } else {
             ptr.key = segment;
             ptr.type = "UPDATE" /* UPDATE */;
@@ -304,7 +311,7 @@ var unatomizeChangeset = (changes) => {
   return changesArr;
 };
 var getTypeOfObj = (obj) => {
-  if (typeof obj === "undefined") {
+  if (obj === void 0) {
     return "undefined";
   }
   if (obj === null) {
@@ -313,8 +320,8 @@ var getTypeOfObj = (obj) => {
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
 };
 var getKey = (path) => {
-  const left = path[path.length - 1];
-  return left != null ? left : "$root";
+  const left = path.at(-1);
+  return left ?? "$root";
 };
 var compare = (oldObj, newObj, path, keyPath, options) => {
   let changes = [];
@@ -469,22 +476,17 @@ var compareArray = (oldObj, newObj, path, keyPath, options) => {
     return [{ type: "UPDATE" /* UPDATE */, key: getKey(path), value: newObj, oldValue: oldObj }];
   }
   const left = getObjectKey(options.embeddedObjKeys, keyPath);
-  const uniqKey = left != null ? left : "$index";
+  const uniqKey = left ?? "$index";
   const indexedOldObj = convertArrayToObj(oldObj, uniqKey);
   const indexedNewObj = convertArrayToObj(newObj, uniqKey);
   const diffs = compareObject(indexedOldObj, indexedNewObj, path, keyPath, true, options);
-  let moveDiffs = [];
-  if (options.detectArrayMoves && uniqKey !== "$index" && left != null) {
-    moveDiffs = detectArrayMoves(oldObj, newObj, uniqKey);
-  }
-  const allDiffs = [...diffs, ...moveDiffs];
-  if (allDiffs.length) {
+  if (diffs.length) {
     return [
       {
         type: "UPDATE" /* UPDATE */,
         key: getKey(path),
         embeddedKey: typeof uniqKey === "function" && uniqKey.length === 2 ? uniqKey(newObj[0], true) : uniqKey,
-        changes: allDiffs
+        changes: diffs
       }
     ];
   } else {
@@ -512,49 +514,20 @@ var getObjectKey = (embeddedObjKeys, keyPath) => {
   }
   return void 0;
 };
-var detectArrayMoves = (oldArray, newArray, uniqKey) => {
-  const moves = [];
-  const keyFunction = typeof uniqKey === "string" ? (item) => item[uniqKey] : uniqKey;
-  const oldIndexMap = /* @__PURE__ */ new Map();
-  const newIndexMap = /* @__PURE__ */ new Map();
-  oldArray.forEach((item, index) => {
-    const key = keyFunction(item);
-    oldIndexMap.set(key, index);
-  });
-  newArray.forEach((item, index) => {
-    const key = keyFunction(item);
-    newIndexMap.set(key, index);
-  });
-  for (const [key, newIndex] of newIndexMap) {
-    if (oldIndexMap.has(key)) {
-      const oldIndex = oldIndexMap.get(key);
-      if (oldIndex !== newIndex) {
-        moves.push({
-          type: "MOVE" /* MOVE */,
-          key,
-          oldIndex,
-          newIndex,
-          value: newArray[newIndex]
-        });
-      }
-    }
-  }
-  return moves;
-};
 var convertArrayToObj = (arr, uniqKey) => {
   let obj = {};
   if (uniqKey === "$value") {
     arr.forEach((value) => {
       obj[value] = value;
     });
-  } else if (uniqKey !== "$index") {
-    const keyFunction = typeof uniqKey === "string" ? (item) => item[uniqKey] : uniqKey;
-    obj = keyBy(arr, keyFunction);
-  } else {
+  } else if (uniqKey === "$index") {
     for (let i = 0; i < arr.length; i++) {
       const value = arr[i];
       obj[i] = value;
     }
+  } else {
+    const keyFunction = typeof uniqKey === "string" ? (item) => item[uniqKey] : uniqKey;
+    obj = keyBy(arr, keyFunction);
   }
   return obj;
 };
@@ -578,10 +551,10 @@ var removeKey = (obj, key, embeddedKey) => {
     }
     const index = indexOfItemInArray(obj, embeddedKey, key);
     if (index === -1) {
-      console.warn(`Element with the key '${embeddedKey}' and value '${key}' could not be found in the array'`);
+      console.warn(`Element with the key '${embeddedKey}' and value '${key}' could not be found in the array!`);
       return;
     }
-    return obj.splice(index != null ? index : key, 1);
+    return obj.splice(index ?? key, 1);
   } else {
     delete obj[key];
     return;
@@ -600,29 +573,6 @@ var indexOfItemInArray = (arr, key, value) => {
   return -1;
 };
 var modifyKeyValue = (obj, key, value) => obj[key] = value;
-var moveArrayElement = (arr, key, oldIndex, newIndex, embeddedKey) => {
-  if (!Array.isArray(arr)) {
-    return;
-  }
-  let elementIndex = -1;
-  if (embeddedKey === "$index") {
-    elementIndex = oldIndex;
-  } else if (embeddedKey === "$value") {
-    elementIndex = arr.indexOf(key);
-  } else {
-    elementIndex = arr.findIndex((item) => {
-      const keyFunction = typeof embeddedKey === "string" ? (item2) => item2[embeddedKey] : embeddedKey;
-      return keyFunction(item)?.toString() === key.toString();
-    });
-  }
-  if (elementIndex === -1) {
-    console.warn(`Element with key '${key}' not found for MOVE operation`);
-    return;
-  }
-  const element = arr.splice(elementIndex, 1)[0];
-  arr.splice(newIndex, 0, element);
-  return arr;
-};
 var addKeyValue = (obj, key, value, embeddedKey) => {
   if (Array.isArray(obj)) {
     if (embeddedKey === "$index") {
@@ -635,7 +585,7 @@ var addKeyValue = (obj, key, value, embeddedKey) => {
   }
 };
 var applyLeafChange = (obj, change, embeddedKey) => {
-  const { type, key, value, oldIndex, newIndex } = change;
+  const { type, key, value } = change;
   switch (type) {
     case "ADD" /* ADD */:
       return addKeyValue(obj, key, value, embeddedKey);
@@ -643,8 +593,6 @@ var applyLeafChange = (obj, change, embeddedKey) => {
       return modifyKeyValue(obj, key, value);
     case "REMOVE" /* REMOVE */:
       return removeKey(obj, key, embeddedKey);
-    case "MOVE" /* MOVE */:
-      return moveArrayElement(obj, key, oldIndex, newIndex, embeddedKey);
   }
 };
 var applyArrayChange = (arr, change) => {
@@ -660,7 +608,7 @@ var applyArrayChange = (arr, change) => {
     });
   }
   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.type === "MOVE" /* MOVE */ || subchange.value === void 0 && subchange.type === "ADD" /* ADD */) {
+    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);
     } else {
       let element;
@@ -689,7 +637,7 @@ var applyBranchChange = (obj, change) => {
   }
 };
 var revertLeafChange = (obj, change, embeddedKey = "$index") => {
-  const { type, key, value, oldValue, oldIndex, newIndex } = change;
+  const { type, key, value, oldValue } = change;
   if (key === "$root") {
     switch (type) {
       case "ADD" /* ADD */:
@@ -723,13 +671,11 @@ var revertLeafChange = (obj, change, embeddedKey = "$index") => {
       return modifyKeyValue(obj, key, oldValue);
     case "REMOVE" /* REMOVE */:
       return addKeyValue(obj, key, value);
-    case "MOVE" /* MOVE */:
-      return moveArrayElement(obj, key, newIndex, oldIndex, embeddedKey);
   }
 };
 var revertArrayChange = (arr, change) => {
   for (const subchange of change.changes) {
-    if (subchange.value != null || subchange.type === "REMOVE" /* REMOVE */ || subchange.type === "MOVE" /* MOVE */) {
+    if (subchange.value != null || subchange.type === "REMOVE" /* REMOVE */) {
       revertLeafChange(arr, subchange, change.embeddedKey);
     } else {
       let element;
@@ -760,9 +706,11 @@ var revertBranchChange = (obj, change) => {
 function append(basePath, nextSegment) {
   return nextSegment.includes(".") ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
 }
+var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 function filterExpression(basePath, filterKey, filterValue) {
   const value = typeof filterValue === "number" ? filterValue : `'${filterValue}'`;
-  return typeof filterKey === "string" && filterKey.includes(".") ? `${basePath}[?(@[${filterKey}]==${value})]` : `${basePath}[?(@.${filterKey}==${value})]`;
+  const memberAccess = typeof filterKey === "string" && !IDENT_RE.test(filterKey) ? `['${filterKey}']` : `.${filterKey}`;
+  return `${basePath}[?(@${memberAccess}==${value})]`;
 }
 
 // src/jsonCompare.ts
@@ -796,18 +744,35 @@ var enrich = (object) => {
       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 result;
+};
 var applyChangelist = (object, changelist) => {
-  changelist.map((entry) => ({ ...entry, path: entry.path.replace("$.", ".") })).map((entry) => ({
-    ...entry,
-    path: entry.path.replace(/(\[(?<array>\d)\]\.)/g, "ARRVAL_START$<array>ARRVAL_END")
-  })).map((entry) => ({ ...entry, path: entry.path.replace(/(?<dot>\.)/g, ".value$<dot>") })).map((entry) => ({ ...entry, path: entry.path.replace(/\./, "") })).map((entry) => ({ ...entry, path: entry.path.replace(/ARRVAL_START/g, ".value[") })).map((entry) => ({ ...entry, path: entry.path.replace(/ARRVAL_END/g, "].value.") })).forEach((entry) => {
+  changelist.forEach((entry) => {
+    const path = buildEnrichedPath(entry.path);
     switch (entry.type) {
       case "ADD" /* ADD */:
       case "UPDATE" /* UPDATE */:
-        setByPath(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
+        setByPath(object, path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });
         break;
       case "REMOVE" /* REMOVE */:
-        setByPath(object, entry.path, { type: entry.type, value: void 0, oldValue: entry.value });
+        setByPath(object, path, { type: entry.type, value: void 0, oldValue: entry.value });
         break;
       default:
         throw new Error();
@@ -815,23 +780,995 @@ var applyChangelist = (object, changelist) => {
   });
   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;
+          }
+        } else {
+          i += 1;
+        }
+      }
+    } else if (s[i] === ")" && i + 1 < s.length && s[i + 1] === "]") {
+      return i;
+    } else {
+      i += 1;
+    }
+  }
+  return -1;
+}
+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 || !SIMPLE_PROPERTY_RE.test(key)) {
+      throw new Error(`Invalid property name in filter: '${key}'. Use bracket notation for non-identifier keys: @['${key}']`);
+    }
+    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)) };
+  }
+  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}`);
+  }
+  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}`);
+      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}]`);
+        }
+        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": {
+        const memberAccess = SIMPLE_PROPERTY_RE.test(seg.property) ? `.${seg.property}` : `['${seg.property.replace(/'/g, "''")}']`;
+        result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
+        break;
+      }
+      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 (SIMPLE_PROPERTY_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}==${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.")) return "$" + 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] === "'" || /\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}]`;
+        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";
+  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);
+      }
+      const eqIdx = inner.indexOf("==");
+      if (eqIdx !== -1) {
+        const val = parseFilterLiteral(inner.slice(eqIdx + 2));
+        return String(val);
+      }
+    }
+  }
+  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;
+    }
+  }
+  const lastDot = atomicPath.lastIndexOf(".");
+  if (lastDot > 0) {
+    return atomicPath.slice(lastDot + 1);
+  }
+  return atomicPath;
+}
+
+// src/jsonAtom.ts
+function validateAtom(atom) {
+  const errors = [];
+  if (typeof atom !== "object" || atom === null) {
+    return { valid: false, errors: ["Atom must be a non-null object"] };
+  }
+  const d = 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 (!Array.isArray(d.operations)) {
+    errors.push("Missing or invalid operations: expected array");
+  } else {
+    for (let i = 0; i < d.operations.length; i++) {
+      const op = d.operations[i];
+      if (!op || typeof op !== "object") {
+        errors.push(`operations[${i}]: must be an object`);
+        continue;
+      }
+      if (!["add", "remove", "replace"].includes(op.op)) {
+        errors.push(`operations[${i}]: invalid op '${op.op}'`);
+      }
+      if (typeof op.path !== "string") {
+        errors.push(`operations[${i}]: path must be a string`);
+      }
+      if (op.op === "add") {
+        if (!("value" in op)) {
+          errors.push(`operations[${i}]: add operation must have value`);
+        }
+        if ("oldValue" in op) {
+          errors.push(`operations[${i}]: add operation must not have oldValue`);
+        }
+      }
+      if (op.op === "remove" && "value" in op) {
+        errors.push(`operations[${i}]: remove operation must not have value`);
+      }
+      if (op.op === "replace" && !("value" in op)) {
+        errors.push(`operations[${i}]: replace operation must have value`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function diffAtom(oldObj, newObj, options = {}) {
+  const changeset = diff(oldObj, newObj, {
+    ...options,
+    treatTypeChangeAsReplace: true
+    // Always true — merging REMOVE+ADD is more reliable (B.1)
+  });
+  const operations = [];
+  walkChanges(changeset, "$", oldObj, newObj, operations, options);
+  return {
+    format: "json-atom",
+    version: 1,
+    operations
+  };
+}
+function mergeTypeChangePairs(changes) {
+  const result = [];
+  let i = 0;
+  while (i < changes.length) {
+    if (i + 1 < changes.length && changes[i].type === "REMOVE" /* REMOVE */ && changes[i + 1].type === "ADD" /* ADD */ && changes[i].key === changes[i + 1].key) {
+      result.push({
+        ...changes[i],
+        isMergedReplace: true,
+        removeValue: changes[i].value,
+        addValue: changes[i + 1].value
+      });
+      i += 2;
+    } else {
+      result.push(changes[i]);
+      i += 1;
+    }
+  }
+  return result;
+}
+var SIMPLE_PROPERTY_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function appendCanonicalProperty(basePath, name) {
+  if (SIMPLE_PROPERTY_RE2.test(name)) {
+    return `${basePath}.${name}`;
+  }
+  return `${basePath}['${name.replace(/'/g, "''")}']`;
+}
+function walkChanges(changes, basePath, oldCtx, newCtx, ops, options) {
+  const merged = mergeTypeChangePairs(changes);
+  for (const change of merged) {
+    if (change.isMergedReplace) {
+      const mc = change;
+      const path = mc.key === "$root" ? "$" : 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];
+      if (change.embeddedKey) {
+        for (const childChange of change.changes) {
+          const filterPath = buildCanonicalFilterPath(
+            childPath,
+            change.embeddedKey,
+            childChange.key,
+            childOld,
+            childNew,
+            childChange
+          );
+          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);
+          }
+        }
+      } else {
+        walkChanges(change.changes, childPath, childOld, childNew, ops, options);
+      }
+    } else {
+      const path = change.key === "$root" ? "$" : appendCanonicalProperty(basePath, change.key);
+      emitLeafOp(change, path, ops, options);
+    }
+  }
+}
+function emitLeafOp(change, path, ops, options) {
+  switch (change.type) {
+    case "ADD" /* ADD */: {
+      ops.push({ op: "add", path, value: change.value });
+      break;
+    }
+    case "REMOVE" /* REMOVE */: {
+      const op = { op: "remove", path };
+      if (options.reversible !== false) {
+        op.oldValue = change.value;
+      }
+      ops.push(op);
+      break;
+    }
+    case "UPDATE" /* UPDATE */: {
+      const op = { op: "replace", path, value: change.value };
+      if (options.reversible !== false) {
+        op.oldValue = change.oldValue;
+      }
+      ops.push(op);
+      break;
+    }
+  }
+}
+function buildCanonicalFilterPath(basePath, embeddedKey, changeKey, oldArr, newArr, change) {
+  if (embeddedKey === "$index") {
+    return `${basePath}[${changeKey}]`;
+  }
+  if (embeddedKey === "$value") {
+    const typedVal2 = findActualValue(oldArr, newArr, changeKey, change.type);
+    return `${basePath}[?(@==${formatFilterLiteral(typedVal2)})]`;
+  }
+  if (typeof embeddedKey === "function") {
+    const sample = oldArr && oldArr.length > 0 ? oldArr[0] : newArr?.[0];
+    const keyName = sample ? embeddedKey(sample, true) : changeKey;
+    const element2 = findElementByFn(oldArr, newArr, embeddedKey, changeKey, change.type);
+    if (element2 && typeof keyName === "string") {
+      const typedVal2 = element2[keyName];
+      const memberAccess3 = SIMPLE_PROPERTY_RE2.test(keyName) ? `.${keyName}` : `['${keyName.replace(/'/g, "''")}']`;
+      return `${basePath}[?(@${memberAccess3}==${formatFilterLiteral(typedVal2)})]`;
+    }
+    const memberAccess2 = typeof keyName === "string" && SIMPLE_PROPERTY_RE2.test(keyName) ? `.${keyName}` : `.${changeKey}`;
+    return `${basePath}[?(@${memberAccess2}=='${changeKey}')]`;
+  }
+  const element = findElementByKey(oldArr, newArr, embeddedKey, changeKey, change.type);
+  const typedVal = element ? element[embeddedKey] : changeKey;
+  const memberAccess = SIMPLE_PROPERTY_RE2.test(embeddedKey) ? `.${embeddedKey}` : `['${embeddedKey.replace(/'/g, "''")}']`;
+  return `${basePath}[?(@${memberAccess}==${formatFilterLiteral(typedVal)})]`;
+}
+function findActualValue(oldArr, newArr, stringKey, opType) {
+  if (opType === "REMOVE" /* REMOVE */ && oldArr) {
+    for (const item of oldArr) {
+      if (String(item) === stringKey) return item;
+    }
+  }
+  if (opType === "ADD" /* ADD */ && newArr) {
+    for (const item of newArr) {
+      if (String(item) === stringKey) return item;
+    }
+  }
+  if (oldArr) {
+    for (const item of oldArr) {
+      if (String(item) === stringKey) return item;
+    }
+  }
+  if (newArr) {
+    for (const item of newArr) {
+      if (String(item) === stringKey) return item;
+    }
+  }
+  return stringKey;
+}
+function findElement(arr, embeddedKey, changeKey) {
+  if (!arr || !Array.isArray(arr)) return void 0;
+  if (embeddedKey === "$index") {
+    return arr[Number(changeKey)];
+  }
+  if (embeddedKey === "$value") {
+    return arr.find((item) => String(item) === changeKey);
+  }
+  if (typeof embeddedKey === "function") {
+    return arr.find((item) => String(embeddedKey(item)) === changeKey);
+  }
+  return arr.find((item) => item && String(item[embeddedKey]) === changeKey);
+}
+function findElementByKey(oldArr, newArr, embeddedKey, changeKey, opType) {
+  if (opType === "REMOVE" /* REMOVE */ || opType === "UPDATE" /* UPDATE */) {
+    const el = oldArr?.find((item) => item && String(item[embeddedKey]) === changeKey);
+    if (el) return el;
+  }
+  if (opType === "ADD" /* ADD */ || opType === "UPDATE" /* UPDATE */) {
+    const el = newArr?.find((item) => item && String(item[embeddedKey]) === changeKey);
+    if (el) return el;
+  }
+  return void 0;
+}
+function findElementByFn(oldArr, newArr, fn, changeKey, opType) {
+  if (opType === "REMOVE" /* REMOVE */ || opType === "UPDATE" /* UPDATE */) {
+    const el = oldArr?.find((item) => String(fn(item)) === changeKey);
+    if (el) return el;
+  }
+  if (opType === "ADD" /* ADD */ || opType === "UPDATE" /* UPDATE */) {
+    const el = newArr?.find((item) => String(fn(item)) === changeKey);
+    if (el) return el;
+  }
+  return void 0;
+}
+function toAtom(changeset, options = {}) {
+  let atoms;
+  if (changeset.length === 0) {
+    return { format: "json-atom", version: 1, operations: [] };
+  }
+  if ("path" in changeset[0]) {
+    atoms = changeset;
+  } else {
+    atoms = atomizeChangeset(changeset);
+  }
+  const rawOps = atoms.map((atom) => {
+    const path = atomicPathToAtomPath(atom.path);
+    switch (atom.type) {
+      case "ADD" /* ADD */:
+        return { op: "add", path, value: atom.value };
+      case "REMOVE" /* REMOVE */: {
+        const op = { op: "remove", path };
+        if (options.reversible !== false && atom.value !== void 0) {
+          op.oldValue = atom.value;
+        }
+        return op;
+      }
+      case "UPDATE" /* UPDATE */: {
+        const op = { op: "replace", path, value: atom.value };
+        if (options.reversible !== false && atom.oldValue !== void 0) {
+          op.oldValue = atom.oldValue;
+        }
+        return op;
+      }
+      /* istanbul ignore next -- exhaustive switch */
+      default:
+        throw new Error(`Unknown operation type: ${atom.type}`);
+    }
+  });
+  const operations = mergeConsecutiveOps(rawOps);
+  return { format: "json-atom", version: 1, operations };
+}
+function mergeConsecutiveOps(ops) {
+  const result = [];
+  let i = 0;
+  while (i < ops.length) {
+    if (i + 1 < ops.length && ops[i].op === "remove" && ops[i + 1].op === "add" && ops[i].path === ops[i + 1].path) {
+      const merged = {
+        op: "replace",
+        path: ops[i].path,
+        value: ops[i + 1].value
+      };
+      if (ops[i].oldValue !== void 0) {
+        merged.oldValue = ops[i].oldValue;
+      }
+      result.push(merged);
+      i += 2;
+    } else {
+      result.push(ops[i]);
+      i += 1;
+    }
+  }
+  return result;
+}
+function fromAtom(atom) {
+  const validation = validateAtom(atom);
+  if (!validation.valid) {
+    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
+  }
+  return atom.operations.map((op) => {
+    const atomicPath = atomPathToAtomicPath(op.path);
+    const key = extractKeyFromAtomicPath(atomicPath);
+    switch (op.op) {
+      case "add": {
+        const valueType = getValueType(op.value);
+        return { type: "ADD" /* ADD */, key, path: atomicPath, valueType, value: op.value };
+      }
+      case "remove": {
+        const valueType = op.oldValue !== void 0 ? getValueType(op.oldValue) : null;
+        return { type: "REMOVE" /* REMOVE */, key, path: atomicPath, valueType, value: op.oldValue };
+      }
+      case "replace": {
+        const valueType = getValueType(op.value);
+        const atom2 = { type: "UPDATE" /* UPDATE */, key, path: atomicPath, valueType, value: op.value };
+        if (op.oldValue !== void 0) {
+          atom2.oldValue = op.oldValue;
+        }
+        return atom2;
+      }
+      /* istanbul ignore next -- exhaustive switch */
+      default:
+        throw new Error(`Unknown operation: ${op.op}`);
+    }
+  });
+}
+function getValueType(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return null;
+  if (Array.isArray(value)) return "Array";
+  const type = typeof value;
+  return type.charAt(0).toUpperCase() + type.slice(1);
+}
+function invertAtom(atom) {
+  const validation = validateAtom(atom);
+  if (!validation.valid) {
+    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
+  }
+  for (let i = 0; i < atom.operations.length; i++) {
+    const op = atom.operations[i];
+    if (op.op === "replace" && !("oldValue" in op)) {
+      throw new Error(`operations[${i}]: replace operation missing oldValue \u2014 atom is not reversible`);
+    }
+    if (op.op === "remove" && !("oldValue" in op)) {
+      throw new Error(`operations[${i}]: remove operation missing oldValue \u2014 atom is not reversible`);
+    }
+  }
+  const invertedOps = [...atom.operations].reverse().map((op) => {
+    const extensions = {};
+    for (const key of Object.keys(op)) {
+      if (!["op", "path", "value", "oldValue"].includes(key)) {
+        extensions[key] = op[key];
+      }
+    }
+    switch (op.op) {
+      case "add":
+        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 };
+      /* istanbul ignore next -- exhaustive switch */
+      default:
+        throw new Error(`Unknown operation: ${op.op}`);
+    }
+  });
+  const envelope = { format: "json-atom", version: atom.version, operations: invertedOps };
+  for (const key of Object.keys(atom)) {
+    if (!["format", "version", "operations"].includes(key)) {
+      envelope[key] = atom[key];
+    }
+  }
+  return envelope;
+}
+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.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}`);
+  }
+}
+function revertAtom(obj, atom) {
+  const inverse = invertAtom(atom);
+  return applyAtom(obj, inverse);
+}
+
+// src/atomHelpers.ts
+var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "value", "oldValue"]);
+var ATOM_SPEC_KEYS = /* @__PURE__ */ new Set(["format", "version", "operations"]);
+function operationSpecDict(op) {
+  const result = { op: op.op, path: op.path };
+  if ("value" in op) result.value = op.value;
+  if ("oldValue" in op) result.oldValue = op.oldValue;
+  return result;
+}
+function operationExtensions(op) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(op)) {
+    if (!OP_SPEC_KEYS.has(key)) {
+      result[key] = op[key];
+    }
+  }
+  return result;
+}
+function leafProperty(op) {
+  const segments = parseAtomPath(op.path);
+  if (segments.length === 0) return null;
+  const last = segments[segments.length - 1];
+  return last.type === "property" ? last.name : null;
+}
+function atomSpecDict(atom) {
+  return {
+    format: atom.format,
+    version: atom.version,
+    operations: atom.operations.map(operationSpecDict)
+  };
+}
+function atomExtensions(atom) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(atom)) {
+    if (!ATOM_SPEC_KEYS.has(key)) {
+      result[key] = atom[key];
+    }
+  }
+  return result;
+}
+function atomMap(atom, fn) {
+  return { ...atom, operations: atom.operations.map((op, i) => fn(op, i)) };
+}
+function atomStamp(atom, extensions) {
+  return atomMap(atom, (op) => ({ ...op, ...extensions }));
+}
+function atomGroupBy(atom, keyFn) {
+  const groups = /* @__PURE__ */ Object.create(null);
+  for (const op of atom.operations) {
+    const k = keyFn(op);
+    if (!groups[k]) groups[k] = [];
+    groups[k].push(op);
+  }
+  const envelope = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(atom)) {
+    if (key !== "operations") {
+      envelope[key] = atom[key];
+    }
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [k, ops] of Object.entries(groups)) {
+    result[k] = { ...envelope, operations: ops };
+  }
+  return result;
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function squashAtoms(source, atoms, options = {}) {
+  const { target, verifyTarget = true, ...diffOptions } = options;
+  let final;
+  if (target !== void 0 && atoms.length > 0 && verifyTarget) {
+    let computed = deepClone(source);
+    for (const d of atoms) {
+      computed = applyAtom(computed, d);
+    }
+    const verification = diffAtom(computed, target, diffOptions);
+    if (verification.operations.length > 0) {
+      throw new Error(
+        "squashAtoms: provided target does not match sequential application of atoms to source"
+      );
+    }
+    final = target;
+  } else if (target !== void 0) {
+    final = target;
+  } else {
+    final = deepClone(source);
+    for (const d of atoms) {
+      final = applyAtom(final, d);
+    }
+  }
+  const result = diffAtom(source, final, diffOptions);
+  for (const d of atoms) {
+    for (const key of Object.keys(d)) {
+      if (!ATOM_SPEC_KEYS.has(key)) {
+        Object.defineProperty(result, key, {
+          value: d[key],
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompareOperation,
   Operation,
+  applyAtom,
   applyChangelist,
   applyChangeset,
+  atomExtensions,
+  atomGroupBy,
+  atomMap,
+  atomSpecDict,
+  atomStamp,
   atomizeChangeset,
+  buildAtomPath,
   compare,
+  comparisonToDict,
+  comparisonToFlatList,
   createContainer,
   createValue,
   diff,
+  diffAtom,
   enrich,
+  formatFilterLiteral,
+  fromAtom,
   getTypeOfObj,
+  invertAtom,
+  leafProperty,
+  operationExtensions,
+  operationSpecDict,
+  parseAtomPath,
+  parseFilterLiteral,
+  revertAtom,
   revertChangeset,
-  unatomizeChangeset
+  squashAtoms,
+  toAtom,
+  unatomizeChangeset,
+  validateAtom
 });
 //# sourceMappingURL=index.cjs.map