json-diff-ts 4.9.1 → 5.0.0-alpha.0

package/dist/index.cjs

@@ -24,15 +24,26 @@ __export(index_exports, {
   Operation: () => Operation,
   applyChangelist: () => applyChangelist,
   applyChangeset: () => applyChangeset,
+  applyDelta: () => applyDelta,
   atomizeChangeset: () => atomizeChangeset,
+  buildDeltaPath: () => buildDeltaPath,
   compare: () => compare2,
   createContainer: () => createContainer,
   createValue: () => createValue,
   diff: () => diff,
+  diffDelta: () => diffDelta,
   enrich: () => enrich,
+  formatFilterLiteral: () => formatFilterLiteral,
+  fromDelta: () => fromDelta,
   getTypeOfObj: () => getTypeOfObj,
+  invertDelta: () => invertDelta,
+  parseDeltaPath: () => parseDeltaPath,
+  parseFilterLiteral: () => parseFilterLiteral,
   revertChangeset: () => revertChangeset,
-  unatomizeChangeset: () => unatomizeChangeset
+  revertDelta: () => revertDelta,
+  toDelta: () => toDelta,
+  unatomizeChangeset: () => unatomizeChangeset,
+  validateDelta: () => validateDelta
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -99,7 +110,7 @@ var Operation = /* @__PURE__ */ ((Operation2) => {
   return Operation2;
 })(Operation || {});
 function diff(oldObj, newObj, options = {}) {
-  let { embeddedObjKeys } = options;
+  let embeddedObjKeys = options.arrayIdentityKeys ?? options.embeddedObjKeys;
   const { keysToSkip, treatTypeChangeAsReplace } = options;
   if (embeddedObjKeys instanceof Map) {
     embeddedObjKeys = new Map(
@@ -772,20 +783,759 @@ var compare2 = (oldObject, newObject) => {
   }
   return applyChangelist(enrich(oldObject), atomizeChangeset(diff(oldObject, newObject)));
 };
+
+// src/deltaPath.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);
+    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 parseDeltaPath(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 buildDeltaPath(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 atomicPathToDeltaPath(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}`);
+        result += atomicPath.slice(i, closingIdx + 2);
+        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 deltaPathToAtomicPath(deltaPath) {
+  if (!deltaPath.startsWith("$")) {
+    throw new Error(`Delta path must start with '$': ${deltaPath}`);
+  }
+  if (deltaPath === "$") {
+    return "$.$root";
+  }
+  let result = "$";
+  let i = 1;
+  while (i < deltaPath.length) {
+    if (deltaPath[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < deltaPath.length && /[a-zA-Z0-9_]/.test(deltaPath[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);
+        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}`);
+        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);
+        i = end + 1;
+      } else {
+        throw new Error(`Unexpected character after '[' in: ${deltaPath}`);
+      }
+    } else {
+      throw new Error(`Unexpected character '${deltaPath[i]}' in delta path: ${deltaPath}`);
+    }
+  }
+  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/jsonDelta.ts
+function validateDelta(delta) {
+  const errors = [];
+  if (typeof delta !== "object" || delta === null) {
+    return { valid: false, errors: ["Delta 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}'`);
+  }
+  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 diffDelta(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-delta",
+    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 toDelta(changeset, options = {}) {
+  let atoms;
+  if (changeset.length === 0) {
+    return { format: "json-delta", version: 1, operations: [] };
+  }
+  if ("path" in changeset[0]) {
+    atoms = changeset;
+  } else {
+    atoms = atomizeChangeset(changeset);
+  }
+  const rawOps = atoms.map((atom) => {
+    const path = atomicPathToDeltaPath(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-delta", 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 fromDelta(delta) {
+  const validation = validateDelta(delta);
+  if (!validation.valid) {
+    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+  }
+  return delta.operations.map((op) => {
+    const atomicPath = deltaPathToAtomicPath(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 atom = { type: "UPDATE" /* UPDATE */, key, path: atomicPath, valueType, value: op.value };
+        if (op.oldValue !== void 0) {
+          atom.oldValue = op.oldValue;
+        }
+        return atom;
+      }
+      /* 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 invertDelta(delta) {
+  const validation = validateDelta(delta);
+  if (!validation.valid) {
+    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+  }
+  for (let i = 0; i < delta.operations.length; i++) {
+    const op = delta.operations[i];
+    if (op.op === "replace" && !("oldValue" in op)) {
+      throw new Error(`operations[${i}]: replace operation missing oldValue \u2014 delta is not reversible`);
+    }
+    if (op.op === "remove" && !("oldValue" in op)) {
+      throw new Error(`operations[${i}]: remove operation missing oldValue \u2014 delta is not reversible`);
+    }
+  }
+  const invertedOps = [...delta.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-delta", version: delta.version, operations: invertedOps };
+  for (const key of Object.keys(delta)) {
+    if (!["format", "version", "operations"].includes(key)) {
+      envelope[key] = delta[key];
+    }
+  }
+  return envelope;
+}
+function applyDelta(obj, delta) {
+  const validation = validateDelta(delta);
+  if (!validation.valid) {
+    throw new Error(`Invalid delta: ${validation.errors.join(", ")}`);
+  }
+  let result = obj;
+  for (const op of delta.operations) {
+    if (op.path === "$") {
+      result = applyRootOp(result, op);
+    } else {
+      const atomicChange = deltaOpToAtomicChange(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 deltaOpToAtomicChange(op) {
+  const atomicPath = deltaPathToAtomicPath(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 revertDelta(obj, delta) {
+  const inverse = invertDelta(delta);
+  return applyDelta(obj, inverse);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompareOperation,
   Operation,
   applyChangelist,
   applyChangeset,
+  applyDelta,
   atomizeChangeset,
+  buildDeltaPath,
   compare,
   createContainer,
   createValue,
   diff,
+  diffDelta,
   enrich,
+  formatFilterLiteral,
+  fromDelta,
   getTypeOfObj,
+  invertDelta,
+  parseDeltaPath,
+  parseFilterLiteral,
   revertChangeset,
-  unatomizeChangeset
+  revertDelta,
+  toDelta,
+  unatomizeChangeset,
+  validateDelta
 });
 //# sourceMappingURL=index.cjs.map