@dabble/patches 0.5.2 → 0.5.4

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

@@ -1,8 +1,9 @@
 import { PatchesSnapshot, ChangeMutator, Change } from '../../types.js';
+import { SizeCalculator } from '../shared/changeBatching.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
 
-declare function makeChange<T = any>(snapshot: PatchesSnapshot<T>, mutator: ChangeMutator<T>, changeMetadata?: Record<string, any>, maxPayloadBytes?: number): Change[];
+declare function makeChange<T = any>(snapshot: PatchesSnapshot<T>, mutator: ChangeMutator<T>, changeMetadata?: Record<string, any>, maxStorageBytes?: number, sizeCalculator?: SizeCalculator): Change[];
 
 export { makeChange };

package/dist/algorithms/client/makeChange.js

@@ -1,9 +1,9 @@
 import "../../chunk-IZ2YBCUP.js";
 import { createChange } from "../../data/change.js";
 import { createJSONPatch } from "../../json-patch/createJSONPatch.js";
-import { breakChange } from "./breakChange.js";
+import { breakChanges } from "../shared/changeBatching.js";
 import { createStateFromSnapshot } from "./createStateFromSnapshot.js";
-function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
+function makeChange(snapshot, mutator, changeMetadata, maxStorageBytes, sizeCalculator) {
   const pendingChanges = snapshot.changes;
   const pendingRev = pendingChanges[pendingChanges.length - 1]?.rev ?? snapshot.rev;
   const state = createStateFromSnapshot(snapshot);
@@ -19,8 +19,8 @@ function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
     console.error("Failed to apply change to state during makeChange:", error);
     throw new Error(`Failed to apply change to state during makeChange: ${error}`);
   }
-  if (maxPayloadBytes) {
-    newChangesArray = breakChange(newChangesArray[0], maxPayloadBytes);
+  if (maxStorageBytes) {
+    newChangesArray = breakChanges(newChangesArray, maxStorageBytes, sizeCalculator);
   }
   return newChangesArray;
 }

package/dist/algorithms/server/commitChanges.d.ts

@@ -1,5 +1,5 @@
 import { PatchesStoreBackend } from '../../server/types.js';
-import { ChangeInput, Change } from '../../types.js';
+import { ChangeInput, CommitChangesOptions, Change } from '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
@@ -9,10 +9,11 @@ import '../../json-patch/types.js';
  * @param docId - The ID of the document.
  * @param changes - The changes to commit.
  * @param originClientId - The ID of the client that initiated the commit.
+ * @param options - Optional commit settings.
  * @returns A tuple of [committedChanges, transformedChanges] where:
  *   - committedChanges: Changes that were already committed to the server after the client's base revision
  *   - transformedChanges: The client's changes after being transformed against concurrent changes
  */
-declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: ChangeInput[], sessionTimeoutMillis: number): Promise<[Change[], Change[]]>;
+declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: ChangeInput[], sessionTimeoutMillis: number, options?: CommitChangesOptions, maxStorageBytes?: number): Promise<[Change[], Change[]]>;
 
-export { commitChanges };
+export { CommitChangesOptions, commitChanges };

package/dist/algorithms/server/commitChanges.js

@@ -6,7 +6,7 @@ import { getSnapshotAtRevision } from "./getSnapshotAtRevision.js";
 import { getStateAtRevision } from "./getStateAtRevision.js";
 import { handleOfflineSessionsAndBatches } from "./handleOfflineSessionsAndBatches.js";
 import { transformIncomingChanges } from "./transformIncomingChanges.js";
-async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
+async function commitChanges(store, docId, changes, sessionTimeoutMillis, options, maxStorageBytes) {
   if (changes.length === 0) {
     return [[], []];
   }
@@ -24,8 +24,10 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
     }
     if (c.rev == null) c.rev = rev++;
     else rev = c.rev + 1;
-    c.committedAt = serverNow;
-    c.createdAt = clampTimestamp(c.createdAt, serverNow);
+    if (!options?.historicalImport || !c.committedAt) {
+      c.committedAt = serverNow;
+    }
+    c.createdAt = c.createdAt ? clampTimestamp(c.createdAt, serverNow) : serverNow;
   });
   if (baseRev > currentRev) {
     throw new Error(
@@ -39,7 +41,8 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
     );
   }
   const lastChange = currentChanges[currentChanges.length - 1];
-  if (lastChange && timestampDiff(serverNow, lastChange.createdAt) > sessionTimeoutMillis) {
+  const compareTime = options?.historicalImport ? changes[0].createdAt : serverNow;
+  if (lastChange && timestampDiff(compareTime, lastChange.createdAt) > sessionTimeoutMillis) {
     await createVersion(store, docId, currentState, currentChanges);
   }
   const committedChanges = await store.listChanges(docId, {
@@ -53,17 +56,33 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
   }
   const isOfflineTimestamp = timestampDiff(serverNow, incomingChanges[0].createdAt) > sessionTimeoutMillis;
   if (isOfflineTimestamp || batchId) {
+    const canFastForward = committedChanges.length === 0;
+    const origin = options?.historicalImport ? "main" : canFastForward ? "main" : "offline-branch";
     incomingChanges = await handleOfflineSessionsAndBatches(
       store,
       sessionTimeoutMillis,
       docId,
       incomingChanges,
       baseRev,
-      batchId
+      batchId,
+      origin,
+      true,
+      // isOffline
+      maxStorageBytes
     );
+    if (canFastForward) {
+      await store.saveChanges(docId, incomingChanges);
+      return [[], incomingChanges];
+    }
   }
   const stateAtBaseRev = (await getStateAtRevision(store, docId, baseRev)).state;
-  const transformedChanges = transformIncomingChanges(incomingChanges, stateAtBaseRev, committedChanges, currentRev);
+  const transformedChanges = transformIncomingChanges(
+    incomingChanges,
+    stateAtBaseRev,
+    committedChanges,
+    currentRev,
+    options?.forceCommit
+  );
   if (transformedChanges.length > 0) {
     await store.saveChanges(docId, transformedChanges);
   }

package/dist/algorithms/server/handleOfflineSessionsAndBatches.d.ts

@@ -11,8 +11,11 @@ import '../../json-patch/types.js';
  * @param changes The incoming changes (all with the same batchId)
  * @param baseRev The base revision for the batch
  * @param batchId The batch identifier
- * @returns The collapsed changes for transformation
+ * @param origin The origin to use for created versions (default: 'offline-branch')
+ * @param isOffline Whether these changes were created offline (metadata flag)
+ * @param maxStorageBytes If set, break collapsed changes that exceed this size
+ * @returns The changes (collapsed into one if divergent, unchanged if fast-forward)
  */
-declare function handleOfflineSessionsAndBatches(store: PatchesStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string): Promise<Change[]>;
+declare function handleOfflineSessionsAndBatches(store: PatchesStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string, origin?: 'main' | 'offline-branch', isOffline?: boolean, maxStorageBytes?: number): Promise<Change[]>;
 
 export { handleOfflineSessionsAndBatches };

package/dist/algorithms/server/handleOfflineSessionsAndBatches.js

@@ -3,8 +3,9 @@ import { createSortableId } from "crypto-id";
 import { createVersionMetadata } from "../../data/version.js";
 import { getISO, timestampDiff } from "../../utils/dates.js";
 import { applyChanges } from "../shared/applyChanges.js";
+import { breakChanges } from "../shared/changeBatching.js";
 import { getStateAtRevision } from "./getStateAtRevision.js";
-async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId) {
+async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId, origin = "offline-branch", isOffline = true, maxStorageBytes) {
   const groupId = batchId ?? createSortableId();
   const [lastVersion] = await store.listVersions(docId, {
     groupId,
@@ -30,8 +31,9 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
         const isContinuation = !!lastVersion && timestampDiff(sessionChanges[0].createdAt, lastVersion.endedAt) <= sessionTimeoutMillis;
         if (isContinuation) {
           const mergedState = applyChanges(offlineBaseState, sessionChanges);
-          await store.saveChanges(docId, sessionChanges);
-          await store.updateVersion(docId, lastVersion.id, {});
+          const newEndedAt = getISO(sessionChanges[sessionChanges.length - 1].createdAt);
+          const newRev = sessionChanges[sessionChanges.length - 1].rev;
+          await store.appendVersionChanges(docId, lastVersion.id, sessionChanges, newEndedAt, newRev, mergedState);
           offlineBaseState = mergedState;
           parentId = lastVersion.parentId;
         } else {
@@ -39,7 +41,8 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
           const sessionMetadata = createVersionMetadata({
             parentId,
             groupId,
-            origin: "offline",
+            origin,
+            isOffline,
             // Convert client timestamps to UTC for version metadata (enables lexicographic sorting)
             startedAt: getISO(sessionChanges[0].createdAt),
             endedAt: getISO(sessionChanges[sessionChanges.length - 1].createdAt),
@@ -53,12 +56,17 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
       }
     }
   }
-  return [
-    changes.reduce((firstChange, nextChange) => {
+  if (origin === "offline-branch") {
+    const collapsed = changes.reduce((firstChange, nextChange) => {
       firstChange.ops = [...firstChange.ops, ...nextChange.ops];
       return firstChange;
-    })
-  ];
+    });
+    if (maxStorageBytes) {
+      return breakChanges([collapsed], maxStorageBytes);
+    }
+    return [collapsed];
+  }
+  return changes;
 }
 export {
   handleOfflineSessionsAndBatches

package/dist/algorithms/server/transformIncomingChanges.d.ts

@@ -10,8 +10,9 @@ import '../../json-patch/types.js';
  * @param stateAtBaseRev The server state *at the client's baseRev*.
  * @param committedChanges The committed changes that happened *after* the client's baseRev.
  * @param currentRev The current/latest revision number (these changes will have their `rev` set > `currentRev`).
+ * @param forceCommit If true, skip filtering of no-op changes (useful for migrations).
  * @returns The transformed changes.
  */
-declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number): Change[];
+declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number, forceCommit?: boolean): Change[];
 
 export { transformIncomingChanges };

package/dist/algorithms/server/transformIncomingChanges.js

@@ -1,24 +1,26 @@
 import "../../chunk-IZ2YBCUP.js";
 import { applyPatch } from "../../json-patch/applyPatch.js";
 import { transformPatch } from "../../json-patch/transformPatch.js";
-function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev) {
+function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev, forceCommit = false) {
   const committedOps = committedChanges.flatMap((c) => c.ops);
   let state = stateAtBaseRev;
   let rev = currentRev + 1;
   return changes.map((change) => {
     const transformedOps = transformPatch(stateAtBaseRev, committedOps, change.ops);
-    if (transformedOps.length === 0) {
+    if (transformedOps.length === 0 && !forceCommit) {
       return null;
     }
-    try {
-      const previous = state;
-      state = applyPatch(state, transformedOps, { strict: true });
-      if (previous === state) {
+    if (transformedOps.length > 0) {
+      try {
+        const previous = state;
+        state = applyPatch(state, transformedOps, { strict: true });
+        if (previous === state && !forceCommit) {
+          return null;
+        }
+      } catch (error) {
+        console.error(`Error applying change ${change.id} to state:`, error);
         return null;
       }
-    } catch (error) {
-      console.error(`Error applying change ${change.id} to state:`, error);
-      return null;
     }
     return { ...change, rev: rev++, ops: transformedOps };
   }).filter(Boolean);

package/dist/algorithms/shared/changeBatching.d.ts

@@ -0,0 +1,57 @@
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+/**
+ * Function that calculates the storage size of data.
+ * Used by change batching to determine if changes need to be split.
+ *
+ * Import pre-built calculators from '@dabble/patches/compression':
+ * - `compressedSizeBase64` - Uses actual LZ compression + base64
+ * - `compressedSizeUint8` - Uses actual LZ compression to binary
+ *
+ * Or provide your own (e.g., ratio estimate):
+ * ```typescript
+ * const ratioEstimate = (data) => getJSONByteSize(data) * 0.5;
+ * ```
+ */
+type SizeCalculator = (data: unknown) => number;
+/** Estimate JSON string byte size. */
+declare function getJSONByteSize(data: unknown): number;
+/**
+ * Break changes into smaller changes so that each change's storage 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
+ *
+ * @param changes - The changes to break apart
+ * @param maxBytes - Maximum storage size in bytes per change
+ * @param sizeCalculator - Custom size calculator (e.g., for compressed size)
+ */
+declare function breakChanges(changes: Change[], maxBytes: number, sizeCalculator?: SizeCalculator): Change[];
+/**
+ * Options for breaking changes into batches.
+ */
+interface BreakChangesIntoBatchesOptions {
+    /** Batch limit for wire (uncompressed JSON). Defaults to 1MB. */
+    maxPayloadBytes?: number;
+    /** Per-change storage limit. If exceeded, individual changes are split. */
+    maxStorageBytes?: number;
+    /** Custom size calculator for storage limit (e.g., compressed size). */
+    sizeCalculator?: SizeCalculator;
+}
+/**
+ * Break changes into batches for network transmission.
+ *
+ * Two distinct limits:
+ * - `maxPayloadBytes`: Controls batch size for wire transmission (uses uncompressed JSON size)
+ * - `maxStorageBytes`: Controls per-change splitting for backend storage (uses sizeCalculator if provided)
+ *
+ * @param changes - The changes to batch
+ * @param options - Batching options (or just maxPayloadBytes for backward compatibility)
+ */
+declare function breakChangesIntoBatches(changes: Change[], options?: BreakChangesIntoBatchesOptions | number): Change[][];
+
+export { type BreakChangesIntoBatchesOptions, type SizeCalculator, breakChanges, breakChangesIntoBatches, getJSONByteSize };

package/dist/algorithms/{client/breakChange.js → shared/changeBatching.js}

@@ -1,8 +1,73 @@
 import "../../chunk-IZ2YBCUP.js";
+import { createId } from "crypto-id";
 import { createChange } from "../../data/change.js";
-import { getJSONByteSize } from "./getJSONByteSize.js";
-function breakChange(orig, maxBytes) {
-  if (getJSONByteSize(orig) <= maxBytes) return [orig];
+function getJSONByteSize(data) {
+  try {
+    const stringified = JSON.stringify(data);
+    return stringified ? new TextEncoder().encode(stringified).length : 0;
+  } catch (e) {
+    console.error("Error calculating JSON size:", e);
+    throw new Error("Error calculating JSON size: " + e);
+  }
+}
+function breakChanges(changes, maxBytes, sizeCalculator) {
+  const results = [];
+  for (const change of changes) {
+    results.push(...breakSingleChange(change, maxBytes, sizeCalculator));
+  }
+  return results;
+}
+const DEFAULT_MAX_PAYLOAD_BYTES = 1e6;
+function breakChangesIntoBatches(changes, options) {
+  const opts = typeof options === "number" ? { maxPayloadBytes: options } : options ?? {};
+  const maxPayloadBytes = opts.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES;
+  const { maxStorageBytes, sizeCalculator } = opts;
+  let processedChanges = changes;
+  if (maxStorageBytes) {
+    processedChanges = breakChanges(changes, maxStorageBytes, sizeCalculator);
+  }
+  if (getJSONByteSize(processedChanges) < maxPayloadBytes) {
+    return [processedChanges];
+  }
+  const batchId = createId(12);
+  const batches = [];
+  let currentBatch = [];
+  let currentSize = 2;
+  for (const change of processedChanges) {
+    const changeWithBatchId = { ...change, batchId };
+    const individualActualSize = getJSONByteSize(changeWithBatchId);
+    let itemsToProcess;
+    if (individualActualSize > maxPayloadBytes) {
+      itemsToProcess = breakSingleChange(changeWithBatchId, maxPayloadBytes).map((c) => ({ ...c, batchId }));
+    } 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) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+function getSizeForStorage(data, sizeCalculator) {
+  if (sizeCalculator) {
+    return sizeCalculator(data);
+  }
+  return getJSONByteSize(data);
+}
+function breakSingleChange(orig, maxBytes, sizeCalculator) {
+  if (getSizeForStorage(orig, sizeCalculator) <= maxBytes) return [orig];
   const byOps = [];
   let group = [];
   let rev = orig.rev;
@@ -13,17 +78,17 @@ function breakChange(orig, maxBytes) {
   };
   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 (getSizeForStorage({ ...orig, ops: tentative }, sizeCalculator) > maxBytes) flush();
+    if (group.length === 0 && getSizeForStorage({ ...orig, ops: [op] }, sizeCalculator) > maxBytes) {
       if (op.op === "@txt" && op.value) {
-        const pieces = breakTextOp(orig, op, maxBytes, rev);
+        const pieces = breakTextOp(orig, op, maxBytes, rev, sizeCalculator);
         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);
+        const pieces = breakLargeValueOp(orig, op, maxBytes, rev, sizeCalculator);
         byOps.push(...pieces);
         if (pieces.length > 0) {
           rev = pieces[pieces.length - 1].rev + 1;
@@ -40,10 +105,10 @@ function breakChange(orig, maxBytes) {
   flush();
   return byOps;
 }
-function breakTextOp(origChange, textOp, maxBytes, startRev) {
+function breakTextOp(origChange, textOp, maxBytes, startRev, sizeCalculator) {
   const results = [];
   let rev = startRev;
-  const baseSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: "" }] });
+  const baseSize = getSizeForStorage({ ...origChange, ops: [{ ...textOp, value: "" }] }, sizeCalculator);
   const budget = maxBytes - baseSize;
   const buffer = 20;
   const maxLength = Math.max(1, budget - buffer);
@@ -77,12 +142,15 @@ function breakTextOp(origChange, textOp, maxBytes, startRev) {
       testBatchOps.push({ retain: retainToPrefixCurrentPiece });
     }
     testBatchOps.push(op);
-    const testBatchSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: testBatchOps }] });
+    const testBatchSize = getSizeForStorage({ ...origChange, ops: [{ ...textOp, value: testBatchOps }] }, sizeCalculator);
     if (currentOpsForNextChangePiece.length > 0 && testBatchSize > maxBytes) {
       flushCurrentChangePiece();
     }
     const opStandaloneOps = retainToPrefixCurrentPiece > 0 ? [{ retain: retainToPrefixCurrentPiece }, op] : [op];
-    const opStandaloneSize = getJSONByteSize({ ...origChange, ops: [{ ...textOp, value: opStandaloneOps }] });
+    const opStandaloneSize = getSizeForStorage(
+      { ...origChange, ops: [{ ...textOp, value: opStandaloneOps }] },
+      sizeCalculator
+    );
     if (currentOpsForNextChangePiece.length === 0 && opStandaloneSize > maxBytes) {
       if (op.insert && typeof op.insert === "string") {
         const insertChunks = splitLargeInsertText(op.insert, maxLength, op.attributes);
@@ -127,11 +195,11 @@ function splitLargeInsertText(text, maxChunkLength, attributes) {
   }
   return results;
 }
-function breakLargeValueOp(origChange, op, maxBytes, startRev) {
+function breakLargeValueOp(origChange, op, maxBytes, startRev, sizeCalculator) {
   const results = [];
   let rev = startRev;
-  const baseOpSize = getJSONByteSize({ ...op, value: "" });
-  const baseChangeSize = getJSONByteSize({ ...origChange, ops: [{ ...op, value: "" }] }) - baseOpSize;
+  const baseOpSize = getSizeForStorage({ ...op, value: "" }, sizeCalculator);
+  const baseChangeSize = getSizeForStorage({ ...origChange, ops: [{ ...op, value: "" }] }, sizeCalculator) - baseOpSize;
   const valueBudget = maxBytes - baseChangeSize - 50;
   if (typeof op.value === "string" && op.value.length > 100) {
     const text = op.value;
@@ -161,7 +229,7 @@ function breakLargeValueOp(origChange, op, maxBytes, startRev) {
       const item = originalArray[i];
       const tentativeChunk = [...currentChunk, item];
       const tentativeOp = { ...op, value: tentativeChunk };
-      const tentativeChangeSize = getJSONByteSize({ ...origChange, ops: [tentativeOp] });
+      const tentativeChangeSize = getSizeForStorage({ ...origChange, ops: [tentativeOp] }, sizeCalculator);
       if (currentChunk.length > 0 && tentativeChangeSize > maxBytes) {
         const chunkOp = {};
         if (chunkStartIndex === 0) {
@@ -205,5 +273,7 @@ function deriveNewChange(origChange, rev, ops) {
   return createChange(origChange.baseRev, rev, ops, metadata);
 }
 export {
-  breakChange
+  breakChanges,
+  breakChangesIntoBatches,
+  getJSONByteSize
 };

package/dist/algorithms/shared/lz.d.ts

@@ -0,0 +1,12 @@
+declare function compress(uncompressed: string | null): string;
+declare function decompress(compressed: string | null): string | null;
+declare function compressToBase64(input: string | null): string;
+declare function decompressFromBase64(input: string | null): string | null;
+declare function compressToUTF16(input: string | null): string;
+declare function decompressFromUTF16(compressed: string | null): string | null;
+declare function compressToUint8Array(uncompressed: string | null): Uint8Array;
+declare function decompressFromUint8Array(compressed: Uint8Array | null): string | null;
+declare function compressToEncodedURIComponent(input: string | null): string;
+declare function decompressFromEncodedURIComponent(input: string | null): string | null;
+
+export { compress, compressToBase64, compressToEncodedURIComponent, compressToUTF16, compressToUint8Array, decompress, decompressFromBase64, decompressFromEncodedURIComponent, decompressFromUTF16, decompressFromUint8Array };