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

package/dist/index.cjs

@@ -22,39 +22,39 @@ var index_exports = {};
 __export(index_exports, {
   CompareOperation: () => CompareOperation,
   Operation: () => Operation,
+  applyAtom: () => applyAtom,
   applyChangelist: () => applyChangelist,
   applyChangeset: () => applyChangeset,
-  applyDelta: () => applyDelta,
+  atomExtensions: () => atomExtensions,
+  atomGroupBy: () => atomGroupBy,
+  atomMap: () => atomMap,
+  atomSpecDict: () => atomSpecDict,
+  atomStamp: () => atomStamp,
   atomizeChangeset: () => atomizeChangeset,
-  buildDeltaPath: () => buildDeltaPath,
+  buildAtomPath: () => buildAtomPath,
   compare: () => compare2,
   comparisonToDict: () => comparisonToDict,
   comparisonToFlatList: () => comparisonToFlatList,
   createContainer: () => createContainer,
   createValue: () => createValue,
-  deltaExtensions: () => deltaExtensions,
-  deltaGroupBy: () => deltaGroupBy,
-  deltaMap: () => deltaMap,
-  deltaSpecDict: () => deltaSpecDict,
-  deltaStamp: () => deltaStamp,
   diff: () => diff,
-  diffDelta: () => diffDelta,
+  diffAtom: () => diffAtom,
   enrich: () => enrich,
   formatFilterLiteral: () => formatFilterLiteral,
-  fromDelta: () => fromDelta,
+  fromAtom: () => fromAtom,
   getTypeOfObj: () => getTypeOfObj,
-  invertDelta: () => invertDelta,
+  invertAtom: () => invertAtom,
   leafProperty: () => leafProperty,
   operationExtensions: () => operationExtensions,
   operationSpecDict: () => operationSpecDict,
-  parseDeltaPath: () => parseDeltaPath,
+  parseAtomPath: () => parseAtomPath,
   parseFilterLiteral: () => parseFilterLiteral,
+  revertAtom: () => revertAtom,
   revertChangeset: () => revertChangeset,
-  revertDelta: () => revertDelta,
-  squashDeltas: () => squashDeltas,
-  toDelta: () => toDelta,
+  squashAtoms: () => squashAtoms,
+  toAtom: () => toAtom,
   unatomizeChangeset: () => unatomizeChangeset,
-  validateDelta: () => validateDelta
+  validateAtom: () => validateAtom
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -185,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).replaceAll(/(^'|'$)/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 [
       {
@@ -254,19 +250,19 @@ var unatomizeChangeset = (changes) => {
     } 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;
@@ -710,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
@@ -825,7 +823,7 @@ var comparisonToDict = (node) => {
   }
   return result;
 };
-var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var IDENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var comparisonToFlatList = (node, options = {}) => {
   const results = [];
   flattenNode(node, "$", options.includeUnchanged ?? false, results);
@@ -844,7 +842,7 @@ function flattenNode(node, path, includeUnchanged, results) {
         node.value
       )) {
         if (child == null) continue;
-        const childPath = IDENT_RE.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
+        const childPath = IDENT_RE2.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
         flattenNode(child, childPath, includeUnchanged, results);
       }
     }
@@ -863,7 +861,7 @@ function flattenNode(node, path, includeUnchanged, results) {
   results.push(entry);
 }
 
-// src/deltaPath.ts
+// src/atomPath.ts
 function formatFilterLiteral(value) {
   if (value === null) return "null";
   if (typeof value === "boolean") return String(value);
@@ -934,6 +932,9 @@ function parseFilter(inner) {
     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("@['")) {
@@ -946,7 +947,7 @@ function parseFilter(inner) {
   }
   throw new Error(`Invalid filter expression: ${inner}`);
 }
-function parseDeltaPath(path) {
+function parseAtomPath(path) {
   if (!path.startsWith("$")) {
     throw new Error(`Path must start with '$': ${path}`);
   }
@@ -999,7 +1000,7 @@ function formatMemberAccess(name) {
   }
   return `['${name.replace(/'/g, "''")}']`;
 }
-function buildDeltaPath(segments) {
+function buildAtomPath(segments) {
   let result = "";
   for (const seg of segments) {
     switch (seg.type) {
@@ -1024,7 +1025,41 @@ function buildDeltaPath(segments) {
   }
   return result;
 }
-function atomicPathToDeltaPath(atomicPath) {
+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("$")) {
@@ -1045,7 +1080,8 @@ function atomicPathToDeltaPath(atomicPath) {
       if (atomicPath[i + 1] === "?") {
         const closingIdx = findFilterClose(atomicPath, i + 2);
         if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomicPath}`);
-        result += atomicPath.slice(i, closingIdx + 2);
+        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);
@@ -1065,45 +1101,45 @@ function atomicPathToDeltaPath(atomicPath) {
   }
   return result;
 }
-function deltaPathToAtomicPath(deltaPath) {
-  if (!deltaPath.startsWith("$")) {
-    throw new Error(`Delta path must start with '$': ${deltaPath}`);
+function atomPathToAtomicPath(atomPath) {
+  if (!atomPath.startsWith("$")) {
+    throw new Error(`Atom path must start with '$': ${atomPath}`);
   }
-  if (deltaPath === "$") {
+  if (atomPath === "$") {
     return "$.$root";
   }
   let result = "$";
   let i = 1;
-  while (i < deltaPath.length) {
-    if (deltaPath[i] === ".") {
+  while (i < atomPath.length) {
+    if (atomPath[i] === ".") {
       i += 1;
       const start = i;
-      while (i < deltaPath.length && /[a-zA-Z0-9_]/.test(deltaPath[i])) {
+      while (i < atomPath.length && /[a-zA-Z0-9_]/.test(atomPath[i])) {
         i += 1;
       }
-      result += "." + deltaPath.slice(start, i);
-    } else if (deltaPath[i] === "[") {
-      if (deltaPath[i + 1] === "?") {
-        const closingIdx = findFilterClose(deltaPath, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${deltaPath}`);
-        const filterContent = deltaPath.slice(i, closingIdx + 2);
-        result += normalizeFilterToStringLiterals(filterContent);
+      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 (deltaPath[i + 1] === "'") {
-        const [key, endIdx] = extractQuotedString(deltaPath, i + 2);
-        if (deltaPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${deltaPath}`);
+      } 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(deltaPath[i + 1])) {
-        const end = deltaPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${deltaPath}`);
-        result += deltaPath.slice(i, end + 1);
+      } 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: ${deltaPath}`);
+        throw new Error(`Unexpected character after '[' in: ${atomPath}`);
       }
     } else {
-      throw new Error(`Unexpected character '${deltaPath[i]}' in delta path: ${deltaPath}`);
+      throw new Error(`Unexpected character '${atomPath[i]}' in atom path: ${atomPath}`);
     }
   }
   return result;
@@ -1153,15 +1189,15 @@ function extractKeyFromAtomicPath(atomicPath) {
   return atomicPath;
 }
 
-// src/jsonDelta.ts
-function validateDelta(delta) {
+// src/jsonAtom.ts
+function validateAtom(atom) {
   const errors = [];
-  if (typeof delta !== "object" || delta === null) {
-    return { valid: false, errors: ["Delta must be a non-null object"] };
+  if (typeof atom !== "object" || atom === null) {
+    return { valid: false, errors: ["Atom must be a non-null object"] };
   }
-  const d = delta;
-  if (d.format !== "json-delta") {
-    errors.push(`Invalid or missing format: expected 'json-delta', got '${d.format}'`);
+  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}'`);
@@ -1199,7 +1235,7 @@ function validateDelta(delta) {
   }
   return { valid: errors.length === 0, errors };
 }
-function diffDelta(oldObj, newObj, options = {}) {
+function diffAtom(oldObj, newObj, options = {}) {
   const changeset = diff(oldObj, newObj, {
     ...options,
     treatTypeChangeAsReplace: true
@@ -1208,7 +1244,7 @@ function diffDelta(oldObj, newObj, options = {}) {
   const operations = [];
   walkChanges(changeset, "$", oldObj, newObj, operations, options);
   return {
-    format: "json-delta",
+    format: "json-atom",
     version: 1,
     operations
   };
@@ -1388,10 +1424,10 @@ function findElementByFn(oldArr, newArr, fn, changeKey, opType) {
   }
   return void 0;
 }
-function toDelta(changeset, options = {}) {
+function toAtom(changeset, options = {}) {
   let atoms;
   if (changeset.length === 0) {
-    return { format: "json-delta", version: 1, operations: [] };
+    return { format: "json-atom", version: 1, operations: [] };
   }
   if ("path" in changeset[0]) {
     atoms = changeset;
@@ -1399,7 +1435,7 @@ function toDelta(changeset, options = {}) {
     atoms = atomizeChangeset(changeset);
   }
   const rawOps = atoms.map((atom) => {
-    const path = atomicPathToDeltaPath(atom.path);
+    const path = atomicPathToAtomPath(atom.path);
     switch (atom.type) {
       case "ADD" /* ADD */:
         return { op: "add", path, value: atom.value };
@@ -1423,7 +1459,7 @@ function toDelta(changeset, options = {}) {
     }
   });
   const operations = mergeConsecutiveOps(rawOps);
-  return { format: "json-delta", version: 1, operations };
+  return { format: "json-atom", version: 1, operations };
 }
 function mergeConsecutiveOps(ops) {
   const result = [];
@@ -1447,13 +1483,13 @@ function mergeConsecutiveOps(ops) {
   }
   return result;
 }
-function fromDelta(delta) {
-  const validation = validateDelta(delta);
+function fromAtom(atom) {
+  const validation = validateAtom(atom);
   if (!validation.valid) {
-    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
   }
-  return delta.operations.map((op) => {
-    const atomicPath = deltaPathToAtomicPath(op.path);
+  return atom.operations.map((op) => {
+    const atomicPath = atomPathToAtomicPath(op.path);
     const key = extractKeyFromAtomicPath(atomicPath);
     switch (op.op) {
       case "add": {
@@ -1466,11 +1502,11 @@ function fromDelta(delta) {
       }
       case "replace": {
         const valueType = getValueType(op.value);
-        const atom = { type: "UPDATE" /* UPDATE */, key, path: atomicPath, valueType, value: op.value };
+        const atom2 = { type: "UPDATE" /* UPDATE */, key, path: atomicPath, valueType, value: op.value };
         if (op.oldValue !== void 0) {
-          atom.oldValue = op.oldValue;
+          atom2.oldValue = op.oldValue;
         }
-        return atom;
+        return atom2;
       }
       /* istanbul ignore next -- exhaustive switch */
       default:
@@ -1485,21 +1521,21 @@ function getValueType(value) {
   const type = typeof value;
   return type.charAt(0).toUpperCase() + type.slice(1);
 }
-function invertDelta(delta) {
-  const validation = validateDelta(delta);
+function invertAtom(atom) {
+  const validation = validateAtom(atom);
   if (!validation.valid) {
-    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
   }
-  for (let i = 0; i < delta.operations.length; i++) {
-    const op = delta.operations[i];
+  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 delta is not reversible`);
+      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 delta is not reversible`);
+      throw new Error(`operations[${i}]: remove operation missing oldValue \u2014 atom is not reversible`);
     }
   }
-  const invertedOps = [...delta.operations].reverse().map((op) => {
+  const invertedOps = [...atom.operations].reverse().map((op) => {
     const extensions = {};
     for (const key of Object.keys(op)) {
       if (!["op", "path", "value", "oldValue"].includes(key)) {
@@ -1518,25 +1554,25 @@ function invertDelta(delta) {
         throw new Error(`Unknown operation: ${op.op}`);
     }
   });
-  const envelope = { format: "json-delta", version: delta.version, operations: invertedOps };
-  for (const key of Object.keys(delta)) {
+  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] = delta[key];
+      envelope[key] = atom[key];
     }
   }
   return envelope;
 }
-function applyDelta(obj, delta) {
-  const validation = validateDelta(delta);
+function applyAtom(obj, atom) {
+  const validation = validateAtom(atom);
   if (!validation.valid) {
-    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
   }
   let result = obj;
-  for (const op of delta.operations) {
+  for (const op of atom.operations) {
     if (op.path === "$") {
       result = applyRootOp(result, op);
     } else {
-      const atomicChange = deltaOpToAtomicChange(op);
+      const atomicChange = atomOpToAtomicChange(op);
       const miniChangeset = unatomizeChangeset([atomicChange]);
       applyChangeset(result, miniChangeset);
     }
@@ -1564,8 +1600,8 @@ function applyRootOp(obj, op) {
       throw new Error(`Unknown operation: ${op.op}`);
   }
 }
-function deltaOpToAtomicChange(op) {
-  const atomicPath = deltaPathToAtomicPath(op.path);
+function atomOpToAtomicChange(op) {
+  const atomicPath = atomPathToAtomicPath(op.path);
   const key = extractKeyFromAtomicPath(atomicPath);
   switch (op.op) {
     case "add":
@@ -1586,14 +1622,14 @@ function deltaOpToAtomicChange(op) {
       throw new Error(`Unknown operation: ${op.op}`);
   }
 }
-function revertDelta(obj, delta) {
-  const inverse = invertDelta(delta);
-  return applyDelta(obj, inverse);
+function revertAtom(obj, atom) {
+  const inverse = invertAtom(atom);
+  return applyAtom(obj, inverse);
 }
 
-// src/deltaHelpers.ts
+// src/atomHelpers.ts
 var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "value", "oldValue"]);
-var DELTA_SPEC_KEYS = /* @__PURE__ */ new Set(["format", "version", "operations"]);
+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;
@@ -1610,44 +1646,44 @@ function operationExtensions(op) {
   return result;
 }
 function leafProperty(op) {
-  const segments = parseDeltaPath(op.path);
+  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 deltaSpecDict(delta) {
+function atomSpecDict(atom) {
   return {
-    format: delta.format,
-    version: delta.version,
-    operations: delta.operations.map(operationSpecDict)
+    format: atom.format,
+    version: atom.version,
+    operations: atom.operations.map(operationSpecDict)
   };
 }
-function deltaExtensions(delta) {
+function atomExtensions(atom) {
   const result = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(delta)) {
-    if (!DELTA_SPEC_KEYS.has(key)) {
-      result[key] = delta[key];
+  for (const key of Object.keys(atom)) {
+    if (!ATOM_SPEC_KEYS.has(key)) {
+      result[key] = atom[key];
     }
   }
   return result;
 }
-function deltaMap(delta, fn) {
-  return { ...delta, operations: delta.operations.map((op, i) => fn(op, i)) };
+function atomMap(atom, fn) {
+  return { ...atom, operations: atom.operations.map((op, i) => fn(op, i)) };
 }
-function deltaStamp(delta, extensions) {
-  return deltaMap(delta, (op) => ({ ...op, ...extensions }));
+function atomStamp(atom, extensions) {
+  return atomMap(atom, (op) => ({ ...op, ...extensions }));
 }
-function deltaGroupBy(delta, keyFn) {
+function atomGroupBy(atom, keyFn) {
   const groups = /* @__PURE__ */ Object.create(null);
-  for (const op of delta.operations) {
+  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(delta)) {
+  for (const key of Object.keys(atom)) {
     if (key !== "operations") {
-      envelope[key] = delta[key];
+      envelope[key] = atom[key];
     }
   }
   const result = /* @__PURE__ */ Object.create(null);
@@ -1659,18 +1695,18 @@ function deltaGroupBy(delta, keyFn) {
 function deepClone(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
-function squashDeltas(source, deltas, options = {}) {
+function squashAtoms(source, atoms, options = {}) {
   const { target, verifyTarget = true, ...diffOptions } = options;
   let final;
-  if (target !== void 0 && deltas.length > 0 && verifyTarget) {
+  if (target !== void 0 && atoms.length > 0 && verifyTarget) {
     let computed = deepClone(source);
-    for (const d of deltas) {
-      computed = applyDelta(computed, d);
+    for (const d of atoms) {
+      computed = applyAtom(computed, d);
     }
-    const verification = diffDelta(computed, target, diffOptions);
+    const verification = diffAtom(computed, target, diffOptions);
     if (verification.operations.length > 0) {
       throw new Error(
-        "squashDeltas: provided target does not match sequential application of deltas to source"
+        "squashAtoms: provided target does not match sequential application of atoms to source"
       );
     }
     final = target;
@@ -1678,14 +1714,14 @@ function squashDeltas(source, deltas, options = {}) {
     final = target;
   } else {
     final = deepClone(source);
-    for (const d of deltas) {
-      final = applyDelta(final, d);
+    for (const d of atoms) {
+      final = applyAtom(final, d);
     }
   }
-  const result = diffDelta(source, final, diffOptions);
-  for (const d of deltas) {
+  const result = diffAtom(source, final, diffOptions);
+  for (const d of atoms) {
     for (const key of Object.keys(d)) {
-      if (!DELTA_SPEC_KEYS.has(key)) {
+      if (!ATOM_SPEC_KEYS.has(key)) {
         Object.defineProperty(result, key, {
           value: d[key],
           writable: true,
@@ -1701,38 +1737,38 @@ function squashDeltas(source, deltas, options = {}) {
 0 && (module.exports = {
   CompareOperation,
   Operation,
+  applyAtom,
   applyChangelist,
   applyChangeset,
-  applyDelta,
+  atomExtensions,
+  atomGroupBy,
+  atomMap,
+  atomSpecDict,
+  atomStamp,
   atomizeChangeset,
-  buildDeltaPath,
+  buildAtomPath,
   compare,
   comparisonToDict,
   comparisonToFlatList,
   createContainer,
   createValue,
-  deltaExtensions,
-  deltaGroupBy,
-  deltaMap,
-  deltaSpecDict,
-  deltaStamp,
   diff,
-  diffDelta,
+  diffAtom,
   enrich,
   formatFilterLiteral,
-  fromDelta,
+  fromAtom,
   getTypeOfObj,
-  invertDelta,
+  invertAtom,
   leafProperty,
   operationExtensions,
   operationSpecDict,
-  parseDeltaPath,
+  parseAtomPath,
   parseFilterLiteral,
+  revertAtom,
   revertChangeset,
-  revertDelta,
-  squashDeltas,
-  toDelta,
+  squashAtoms,
+  toAtom,
   unatomizeChangeset,
-  validateDelta
+  validateAtom
 });
 //# sourceMappingURL=index.cjs.map