@dabble/patches 0.4.4 → 0.4.6

package/dist/algorithms/client/applyCommittedChanges.d.ts

@@ -1,8 +1,14 @@
-import type { Change, PatchesSnapshot } from '../../types.js';
+import { PatchesSnapshot, Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Applies incoming changes from the server that were *not* initiated by this client.
  * @param snapshot The current state of the document (the state without pending changes applied) and the pending changes.
  * @param committedChangesFromServer An array of sequential changes from the server.
  * @returns The new committed state, the new committed revision, and the new/rebased pending changes.
  */
-export declare function applyCommittedChanges(snapshot: PatchesSnapshot, committedChangesFromServer: Change[]): PatchesSnapshot;
+declare function applyCommittedChanges(snapshot: PatchesSnapshot, committedChangesFromServer: Change[]): PatchesSnapshot;
+
+export { applyCommittedChanges };

package/dist/algorithms/client/applyCommittedChanges.js

@@ -1,40 +1,32 @@
-import { applyChanges } from '../shared/applyChanges.js';
-import { rebaseChanges } from '../shared/rebaseChanges.js';
-/**
- * Applies incoming changes from the server that were *not* initiated by this client.
- * @param snapshot The current state of the document (the state without pending changes applied) and the pending changes.
- * @param committedChangesFromServer An array of sequential changes from the server.
- * @returns The new committed state, the new committed revision, and the new/rebased pending changes.
- */
-export function applyCommittedChanges(snapshot, committedChangesFromServer) {
-    let { state, rev, changes } = snapshot;
-    // Filter out any server changes that are already reflected in the current snapshot's revision.
-    // Server changes should always have a rev.
-    const newServerChanges = committedChangesFromServer.filter(change => change.rev > rev);
-    if (newServerChanges.length === 0) {
-        // No new changes to apply, return the snapshot as is.
-        return { state, rev, changes };
-    }
-    const firstChange = newServerChanges[0];
-    const lastChange = newServerChanges[newServerChanges.length - 1];
-    // Ensure the new server changes are sequential to the current snapshot's revision.
-    if (firstChange.rev !== rev + 1) {
-        throw new Error(`Missing changes from the server. Expected rev ${rev + 1}, got ${firstChange.rev}. Request changes since ${rev}.`);
-    }
-    // 1. Apply to committed state
-    try {
-        state = applyChanges(state, newServerChanges);
-    }
-    catch (error) {
-        console.error('Failed to apply server changes to committed state:', error);
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Critical sync error applying server changes: ${errorMessage}`);
-    }
-    // 2. Update committed revision to the latest one from the applied server changes.
-    rev = lastChange.rev;
-    // 3. Rebase pending local changes against the newly applied server changes.
-    if (changes && changes.length > 0) {
-        changes = rebaseChanges(newServerChanges, changes);
-    }
+import "../../chunk-IZ2YBCUP.js";
+import { applyChanges } from "../shared/applyChanges.js";
+import { rebaseChanges } from "../shared/rebaseChanges.js";
+function applyCommittedChanges(snapshot, committedChangesFromServer) {
+  let { state, rev, changes } = snapshot;
+  const newServerChanges = committedChangesFromServer.filter((change) => change.rev > rev);
+  if (newServerChanges.length === 0) {
     return { state, rev, changes };
+  }
+  const firstChange = newServerChanges[0];
+  const lastChange = newServerChanges[newServerChanges.length - 1];
+  if (firstChange.rev !== rev + 1) {
+    throw new Error(
+      `Missing changes from the server. Expected rev ${rev + 1}, got ${firstChange.rev}. Request changes since ${rev}.`
+    );
+  }
+  try {
+    state = applyChanges(state, newServerChanges);
+  } catch (error) {
+    console.error("Failed to apply server changes to committed state:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Critical sync error applying server changes: ${errorMessage}`);
+  }
+  rev = lastChange.rev;
+  if (changes && changes.length > 0) {
+    changes = rebaseChanges(newServerChanges, changes);
+  }
+  return { state, rev, changes };
 }
+export {
+  applyCommittedChanges
+};

package/dist/algorithms/client/batching.d.ts

@@ -1,3 +1,9 @@
-import type { Change } from '../../types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /** Break changes into batches based on maxPayloadBytes. */
-export declare function breakIntoBatches(changes: Change[], maxPayloadBytes?: number): Change[][];
+declare function breakIntoBatches(changes: Change[], maxPayloadBytes?: number): Change[][];
+
+export { breakIntoBatches };

package/dist/algorithms/client/batching.js

@@ -1,41 +1,42 @@
-import { createId } from 'crypto-id';
-import { breakChange } from './breakChange.js';
-import { getJSONByteSize } from './getJSONByteSize.js';
-/** Break changes into batches based on maxPayloadBytes. */
-export function breakIntoBatches(changes, maxPayloadBytes) {
-    if (!maxPayloadBytes || getJSONByteSize(changes) < maxPayloadBytes) {
-        return [changes];
+import "../../chunk-IZ2YBCUP.js";
+import { createId } from "crypto-id";
+import { breakChange } from "./breakChange.js";
+import { getJSONByteSize } from "./getJSONByteSize.js";
+function breakIntoBatches(changes, maxPayloadBytes) {
+  if (!maxPayloadBytes || getJSONByteSize(changes) < maxPayloadBytes) {
+    return [changes];
+  }
+  const batchId = createId(12);
+  const batches = [];
+  let currentBatch = [];
+  let currentSize = 2;
+  for (const change of changes) {
+    const changeWithBatchId = { ...change, batchId };
+    const individualActualSize = getJSONByteSize(changeWithBatchId);
+    let itemsToProcess;
+    if (individualActualSize > maxPayloadBytes) {
+      itemsToProcess = breakChange(changeWithBatchId, maxPayloadBytes);
+    } else {
+      itemsToProcess = [changeWithBatchId];
     }
-    const batchId = createId(12);
-    const batches = [];
-    let currentBatch = [];
-    let currentSize = 2; // Account for [] wrapper
-    for (const change of changes) {
-        // Add batchId if breaking up
-        const changeWithBatchId = { ...change, batchId };
-        const individualActualSize = getJSONByteSize(changeWithBatchId);
-        let itemsToProcess;
-        if (individualActualSize > maxPayloadBytes) {
-            itemsToProcess = breakChange(changeWithBatchId, maxPayloadBytes);
-        }
-        else {
-            itemsToProcess = [changeWithBatchId];
-        }
-        for (const item of itemsToProcess) {
-            const itemActualSize = getJSONByteSize(item);
-            const itemSizeForBatching = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
-            if (currentBatch.length > 0 && currentSize + itemSizeForBatching > maxPayloadBytes) {
-                batches.push(currentBatch);
-                currentBatch = [];
-                currentSize = 2;
-            }
-            const actualItemContribution = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
-            currentBatch.push(item);
-            currentSize += actualItemContribution;
-        }
-    }
-    if (currentBatch.length > 0) {
+    for (const item of itemsToProcess) {
+      const itemActualSize = getJSONByteSize(item);
+      const itemSizeForBatching = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
+      if (currentBatch.length > 0 && currentSize + itemSizeForBatching > maxPayloadBytes) {
         batches.push(currentBatch);
+        currentBatch = [];
+        currentSize = 2;
+      }
+      const actualItemContribution = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
+      currentBatch.push(item);
+      currentSize += actualItemContribution;
     }
-    return batches;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
 }
+export {
+  breakIntoBatches
+};

package/dist/algorithms/client/breakChange.d.ts

@@ -1,4 +1,8 @@
-import type { Change } from '../../types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Break a single Change into multiple Changes so that the JSON string size never exceeds `maxBytes`.
  *
@@ -6,4 +10,6 @@ import type { Change } from '../../types.js';
  * - If an individual op is still too big and is a "@txt" op,
  *   split its Delta payload into smaller Deltas
  */
-export declare function breakChange(orig: Change, maxBytes: number): Change[];
+declare function breakChange(orig: Change, maxBytes: number): Change[];
+
+export { breakChange };

package/dist/algorithms/client/breakChange.js

@@ -1,258 +1,209 @@
-import { createChange } from '../../data/change.js';
-import { getJSONByteSize } from './getJSONByteSize.js';
-/**
- * Break a single Change into multiple Changes so that the JSON string size never exceeds `maxBytes`.
- *
- * - Splits first by JSON-Patch *ops*
- * - If an individual op is still too big and is a "@txt" op,
- *   split its Delta payload into smaller Deltas
- */
-export function breakChange(orig, maxBytes) {
-    if (getJSONByteSize(orig) <= maxBytes)
-        return [orig];
-    // First pass: split by ops
-    const byOps = [];
-    let group = [];
-    let rev = orig.rev;
-    const flush = () => {
-        if (!group.length)
-            return;
-        byOps.push(deriveNewChange(orig, rev++, group));
-        group = [];
-    };
-    for (const op of orig.ops) {
-        const tentative = group.concat(op);
-        if (getJSONByteSize({ ...orig, ops: tentative }) > maxBytes)
-            flush();
-        // Handle the case where a single op is too large
-        if (group.length === 0 && getJSONByteSize({ ...orig, ops: [op] }) > maxBytes) {
-            // We have a single op that's too big - can only be @txt op with large delta
-            if (op.op === '@txt' && op.value) {
-                const pieces = breakTextOp(orig, op, maxBytes, rev);
-                byOps.push(...pieces);
-                // Only update rev if we got results from breakTextOp
-                if (pieces.length > 0) {
-                    rev = pieces[pieces.length - 1].rev + 1; // Update rev for next changes
-                }
-                continue;
-            }
-            else if (op.op === 'replace' || op.op === 'add') {
-                // For replace/add operations with large value payloads, try to split the value if it's a string or array
-                const pieces = breakLargeValueOp(orig, op, maxBytes, rev);
-                byOps.push(...pieces);
-                if (pieces.length > 0) {
-                    rev = pieces[pieces.length - 1].rev + 1;
-                }
-                continue;
-            }
-            else {
-                // Non-splittable op that's too large, include it anyway with a warning
-                console.warn(`Warning: Single operation of type ${op.op} exceeds maxBytes. Including it anyway.`);
-                group.push(op);
-                continue;
-            }
+import "../../chunk-IZ2YBCUP.js";
+import { createChange } from "../../data/change.js";
+import { getJSONByteSize } from "./getJSONByteSize.js";
+function breakChange(orig, maxBytes) {
+  if (getJSONByteSize(orig) <= maxBytes) return [orig];
+  const byOps = [];
+  let group = [];
+  let rev = orig.rev;
+  const flush = () => {
+    if (!group.length) return;
+    byOps.push(deriveNewChange(orig, rev++, group));
+    group = [];
+  };
+  for (const op of orig.ops) {
+    const tentative = group.concat(op);
+    if (getJSONByteSize({ ...orig, ops: tentative }) > maxBytes) flush();
+    if (group.length === 0 && getJSONByteSize({ ...orig, ops: [op] }) > maxBytes) {
+      if (op.op === "@txt" && op.value) {
+        const pieces = breakTextOp(orig, op, maxBytes, rev);
+        byOps.push(...pieces);
+        if (pieces.length > 0) {
+          rev = pieces[pieces.length - 1].rev + 1;
         }
+        continue;
+      } else if (op.op === "replace" || op.op === "add") {
+        const pieces = breakLargeValueOp(orig, op, maxBytes, rev);
+        byOps.push(...pieces);
+        if (pieces.length > 0) {
+          rev = pieces[pieces.length - 1].rev + 1;
+        }
+        continue;
+      } else {
+        console.warn(`Warning: Single operation of type ${op.op} exceeds maxBytes. Including it anyway.`);
         group.push(op);
+        continue;
+      }
     }
-    flush();
-    return byOps;
+    group.push(op);
+  }
+  flush();
+  return byOps;
 }
-/**
- * Break a large @txt operation into multiple smaller operations
- */
 function breakTextOp(origChange, textOp, maxBytes, startRev) {
-    const results = [];
-    let rev = startRev;
-    const baseSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: '' }] });
-    const budget = maxBytes - baseSize;
-    const buffer = 20;
-    const maxLength = Math.max(1, budget - buffer);
-    let deltaOps = [];
-    if (textOp.value) {
-        if (Array.isArray(textOp.value)) {
-            deltaOps = textOp.value;
-        }
-        else if (textOp.value.ops && Array.isArray(textOp.value.ops)) {
-            deltaOps = textOp.value.ops;
-        }
-        else if (typeof textOp.value === 'object') {
-            deltaOps = [textOp.value];
-        }
+  const results = [];
+  let rev = startRev;
+  const baseSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: "" }] });
+  const budget = maxBytes - baseSize;
+  const buffer = 20;
+  const maxLength = Math.max(1, budget - buffer);
+  let deltaOps = [];
+  if (textOp.value) {
+    if (Array.isArray(textOp.value)) {
+      deltaOps = textOp.value;
+    } else if (textOp.value.ops && Array.isArray(textOp.value.ops)) {
+      deltaOps = textOp.value.ops;
+    } else if (typeof textOp.value === "object") {
+      deltaOps = [textOp.value];
     }
-    let currentOpsForNextChangePiece = [];
-    let retainToPrefixCurrentPiece = 0; // Retain that should prefix the ops in currentOpsForNextChangePiece
-    const flushCurrentChangePiece = () => {
-        if (!currentOpsForNextChangePiece.length)
-            return;
-        const opsToFlush = [...currentOpsForNextChangePiece];
-        if (retainToPrefixCurrentPiece > 0) {
-            if (!opsToFlush[0]?.retain) {
-                // Only add if not already starting with a retain
-                opsToFlush.unshift({ retain: retainToPrefixCurrentPiece });
-            }
-            else {
-                // If it starts with retain, assume it's the intended one from deltaOps.
-                // This might need adjustment if a small retain op is batched after a large retain prefix.
-                // For now, this prioritizes an existing retain op at the start of the batch.
-            }
-        }
-        results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opsToFlush }]));
-        currentOpsForNextChangePiece = [];
-        // retainToPrefixCurrentPiece is NOT reset here, it carries over for the start of the next piece IF it's non-zero from a previous retain op.
-    };
-    for (const op of deltaOps) {
-        // Try adding current op (with its necessary prefix) to the current batch
-        const testBatchOps = [...currentOpsForNextChangePiece];
-        if (retainToPrefixCurrentPiece > 0 && testBatchOps.length === 0) {
-            // If batch is empty, it needs the prefix
-            testBatchOps.push({ retain: retainToPrefixCurrentPiece });
-        }
-        testBatchOps.push(op);
-        const testBatchSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: testBatchOps }] });
-        if (currentOpsForNextChangePiece.length > 0 && testBatchSize > maxBytes) {
-            flushCurrentChangePiece();
-            // After flush, retainToPrefixCurrentPiece still holds the value for the *start* of the new piece (current op)
-        }
-        // Check if the op itself (with its prefix) is too large for a new piece
-        const opStandaloneOps = retainToPrefixCurrentPiece > 0 ? [{ retain: retainToPrefixCurrentPiece }, op] : [op];
-        const opStandaloneSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: opStandaloneOps }] });
-        if (currentOpsForNextChangePiece.length === 0 && opStandaloneSize > maxBytes) {
-            if (op.insert && typeof op.insert === 'string') {
-                const insertChunks = splitLargeInsertText(op.insert, maxLength, op.attributes);
-                for (let i = 0; i < insertChunks.length; i++) {
-                    const chunkOp = insertChunks[i];
-                    const opsForThisChunk = [];
-                    if (i === 0 && retainToPrefixCurrentPiece > 0) {
-                        // Prefix only the first chunk
-                        opsForThisChunk.push({ retain: retainToPrefixCurrentPiece });
-                    }
-                    opsForThisChunk.push(chunkOp);
-                    results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opsForThisChunk }]));
-                }
-                retainToPrefixCurrentPiece = 0; // An insert consumes the preceding retain for the next original op
-            }
-            else {
-                // Non-splittable large op (e.g., large retain)
-                console.warn(`Warning: Single delta op too large, including with prefix: ${JSON.stringify(op)}`);
-                results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opStandaloneOps }]));
-                retainToPrefixCurrentPiece = op.retain || 0;
-            }
-        }
-        else {
-            // Op fits into current batch (or starts a new one that fits)
-            currentOpsForNextChangePiece.push(op);
-            if (op.retain) {
-                retainToPrefixCurrentPiece += op.retain; // Accumulate retain for the next op or flush
-            }
-            else {
-                // Insert or delete
-                retainToPrefixCurrentPiece = 0; // Consumes retain for the next op
-            }
-        }
+  }
+  let currentOpsForNextChangePiece = [];
+  let retainToPrefixCurrentPiece = 0;
+  const flushCurrentChangePiece = () => {
+    if (!currentOpsForNextChangePiece.length) return;
+    const opsToFlush = [...currentOpsForNextChangePiece];
+    if (retainToPrefixCurrentPiece > 0) {
+      if (!opsToFlush[0]?.retain) {
+        opsToFlush.unshift({ retain: retainToPrefixCurrentPiece });
+      } else {
+      }
     }
-    if (currentOpsForNextChangePiece.length > 0) {
-        flushCurrentChangePiece();
+    results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opsToFlush }]));
+    currentOpsForNextChangePiece = [];
+  };
+  for (const op of deltaOps) {
+    const testBatchOps = [...currentOpsForNextChangePiece];
+    if (retainToPrefixCurrentPiece > 0 && testBatchOps.length === 0) {
+      testBatchOps.push({ retain: retainToPrefixCurrentPiece });
     }
-    return results;
-}
-/**
- * Split a large insert string into multiple delta insert operations.
- * Each operation will have the original attributes.
- */
-function splitLargeInsertText(text, maxChunkLength, attributes) {
-    const results = [];
-    if (maxChunkLength <= 0) {
-        console.warn('splitLargeInsertText: maxChunkLength is invalid, returning original text as one chunk.');
-        return [{ insert: text, attributes }];
+    testBatchOps.push(op);
+    const testBatchSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: testBatchOps }] });
+    if (currentOpsForNextChangePiece.length > 0 && testBatchSize > maxBytes) {
+      flushCurrentChangePiece();
     }
-    for (let i = 0; i < text.length; i += maxChunkLength) {
-        const chunkText = text.slice(i, i + maxChunkLength);
-        results.push({ insert: chunkText, attributes: attributes ? { ...attributes } : undefined });
+    const opStandaloneOps = retainToPrefixCurrentPiece > 0 ? [{ retain: retainToPrefixCurrentPiece }, op] : [op];
+    const opStandaloneSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: opStandaloneOps }] });
+    if (currentOpsForNextChangePiece.length === 0 && opStandaloneSize > maxBytes) {
+      if (op.insert && typeof op.insert === "string") {
+        const insertChunks = splitLargeInsertText(op.insert, maxLength, op.attributes);
+        for (let i = 0; i < insertChunks.length; i++) {
+          const chunkOp = insertChunks[i];
+          const opsForThisChunk = [];
+          if (i === 0 && retainToPrefixCurrentPiece > 0) {
+            opsForThisChunk.push({ retain: retainToPrefixCurrentPiece });
+          }
+          opsForThisChunk.push(chunkOp);
+          results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opsForThisChunk }]));
+        }
+        retainToPrefixCurrentPiece = 0;
+      } else {
+        console.warn(`Warning: Single delta op too large, including with prefix: ${JSON.stringify(op)}`);
+        results.push(deriveNewChange(origChange, rev++, [{ ...textOp, value: opStandaloneOps }]));
+        retainToPrefixCurrentPiece = op.retain || 0;
+      }
+    } else {
+      currentOpsForNextChangePiece.push(op);
+      if (op.retain) {
+        retainToPrefixCurrentPiece += op.retain;
+      } else {
+        retainToPrefixCurrentPiece = 0;
+      }
     }
-    return results;
+  }
+  if (currentOpsForNextChangePiece.length > 0) {
+    flushCurrentChangePiece();
+  }
+  return results;
+}
+function splitLargeInsertText(text, maxChunkLength, attributes) {
+  const results = [];
+  if (maxChunkLength <= 0) {
+    console.warn("splitLargeInsertText: maxChunkLength is invalid, returning original text as one chunk.");
+    return [{ insert: text, attributes }];
+  }
+  for (let i = 0; i < text.length; i += maxChunkLength) {
+    const chunkText = text.slice(i, i + maxChunkLength);
+    results.push({ insert: chunkText, attributes: attributes ? { ...attributes } : void 0 });
+  }
+  return results;
 }
-/**
- * Attempt to break a large value in a replace/add operation
- */
 function breakLargeValueOp(origChange, op, maxBytes, startRev) {
-    const results = [];
-    let rev = startRev;
-    const baseOpSize = getJSONByteSize({ ...op, value: '' });
-    const baseChangeSize = getJSONByteSize({ ...origChange, ops: [{ ...op, value: '' }] }) - baseOpSize;
-    const valueBudget = maxBytes - baseChangeSize - 50;
-    if (typeof op.value === 'string' && op.value.length > 100) {
-        const text = op.value;
-        const targetChunkSize = Math.max(1, valueBudget);
-        const numChunks = Math.ceil(text.length / targetChunkSize);
-        const chunkSize = Math.ceil(text.length / numChunks);
-        for (let i = 0; i < text.length; i += chunkSize) {
-            const chunk = text.slice(i, i + chunkSize);
-            const newOp = { op: 'add' };
-            if (i === 0) {
-                newOp.op = op.op;
-                newOp.path = op.path;
-                newOp.value = chunk;
-            }
-            else {
-                newOp.op = 'patch';
-                newOp.path = op.path;
-                newOp.appendString = chunk;
-            }
-            results.push(deriveNewChange(origChange, rev++, [newOp]));
-        }
-        return results;
+  const results = [];
+  let rev = startRev;
+  const baseOpSize = getJSONByteSize({ ...op, value: "" });
+  const baseChangeSize = getJSONByteSize({ ...origChange, ops: [{ ...op, value: "" }] }) - baseOpSize;
+  const valueBudget = maxBytes - baseChangeSize - 50;
+  if (typeof op.value === "string" && op.value.length > 100) {
+    const text = op.value;
+    const targetChunkSize = Math.max(1, valueBudget);
+    const numChunks = Math.ceil(text.length / targetChunkSize);
+    const chunkSize = Math.ceil(text.length / numChunks);
+    for (let i = 0; i < text.length; i += chunkSize) {
+      const chunk = text.slice(i, i + chunkSize);
+      const newOp = { op: "add" };
+      if (i === 0) {
+        newOp.op = op.op;
+        newOp.path = op.path;
+        newOp.value = chunk;
+      } else {
+        newOp.op = "patch";
+        newOp.path = op.path;
+        newOp.appendString = chunk;
+      }
+      results.push(deriveNewChange(origChange, rev++, [newOp]));
     }
-    else if (Array.isArray(op.value) && op.value.length > 1) {
-        const originalArray = op.value;
-        let currentChunk = [];
-        let chunkStartIndex = 0;
-        for (let i = 0; i < originalArray.length; i++) {
-            const item = originalArray[i];
-            const tentativeChunk = [...currentChunk, item];
-            const tentativeOp = { ...op, value: tentativeChunk };
-            const tentativeChangeSize = getJSONByteSize({ ...origChange, ops: [tentativeOp] });
-            if (currentChunk.length > 0 && tentativeChangeSize > maxBytes) {
-                const chunkOp = {};
-                if (chunkStartIndex === 0) {
-                    chunkOp.op = op.op;
-                    chunkOp.path = op.path;
-                    chunkOp.value = currentChunk;
-                }
-                else {
-                    chunkOp.op = 'patch';
-                    chunkOp.path = op.path;
-                    chunkOp.appendArray = currentChunk;
-                }
-                results.push(deriveNewChange(origChange, rev++, [chunkOp]));
-                currentChunk = [item];
-                chunkStartIndex = i;
-            }
-            else {
-                currentChunk.push(item);
-            }
-        }
-        if (currentChunk.length > 0) {
-            const chunkOp = {};
-            if (chunkStartIndex === 0) {
-                chunkOp.op = op.op;
-                chunkOp.path = op.path;
-                chunkOp.value = currentChunk;
-            }
-            else {
-                chunkOp.op = 'patch';
-                chunkOp.path = op.path;
-                chunkOp.appendArray = currentChunk;
-            }
-            results.push(deriveNewChange(origChange, rev++, [chunkOp]));
+    return results;
+  } else if (Array.isArray(op.value) && op.value.length > 1) {
+    const originalArray = op.value;
+    let currentChunk = [];
+    let chunkStartIndex = 0;
+    for (let i = 0; i < originalArray.length; i++) {
+      const item = originalArray[i];
+      const tentativeChunk = [...currentChunk, item];
+      const tentativeOp = { ...op, value: tentativeChunk };
+      const tentativeChangeSize = getJSONByteSize({ ...origChange, ops: [tentativeOp] });
+      if (currentChunk.length > 0 && tentativeChangeSize > maxBytes) {
+        const chunkOp = {};
+        if (chunkStartIndex === 0) {
+          chunkOp.op = op.op;
+          chunkOp.path = op.path;
+          chunkOp.value = currentChunk;
+        } else {
+          chunkOp.op = "patch";
+          chunkOp.path = op.path;
+          chunkOp.appendArray = currentChunk;
         }
-        return results;
+        results.push(deriveNewChange(origChange, rev++, [chunkOp]));
+        currentChunk = [item];
+        chunkStartIndex = i;
+      } else {
+        currentChunk.push(item);
+      }
     }
-    console.warn(`Warning: Single operation of type ${op.op} (path: ${op.path}) could not be split further by breakLargeValueOp despite exceeding maxBytes. Including as is.`);
-    return [deriveNewChange(origChange, rev++, [op])]; // Return original op in a new change if not splittable by this func
+    if (currentChunk.length > 0) {
+      const chunkOp = {};
+      if (chunkStartIndex === 0) {
+        chunkOp.op = op.op;
+        chunkOp.path = op.path;
+        chunkOp.value = currentChunk;
+      } else {
+        chunkOp.op = "patch";
+        chunkOp.path = op.path;
+        chunkOp.appendArray = currentChunk;
+      }
+      results.push(deriveNewChange(origChange, rev++, [chunkOp]));
+    }
+    return results;
+  }
+  console.warn(
+    `Warning: Single operation of type ${op.op} (path: ${op.path}) could not be split further by breakLargeValueOp despite exceeding maxBytes. Including as is.`
+  );
+  return [deriveNewChange(origChange, rev++, [op])];
 }
 function deriveNewChange(origChange, rev, ops) {
-    // Filter out metadata that shouldn't be part of the new change object
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { id: _id, ops: _o, rev: _r, baseRev: _br, created: _c, batchId: _bi, ...metadata } = origChange;
-    return createChange(origChange.baseRev, rev, ops, metadata);
+  const { id: _id, ops: _o, rev: _r, baseRev: _br, created: _c, batchId: _bi, ...metadata } = origChange;
+  return createChange(origChange.baseRev, rev, ops, metadata);
 }
+export {
+  breakChange
+};