ooxml-core 0.2.0

package/dist/collab/index.cjs

@@ -0,0 +1,1328 @@
+'use strict';
+
+var Y = require('yjs');
+var awarenessProtocol = require('y-protocols/awareness');
+var decoding = require('lib0/decoding');
+var encoding = require('lib0/encoding');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+var awarenessProtocol__namespace = /*#__PURE__*/_interopNamespace(awarenessProtocol);
+var decoding__namespace = /*#__PURE__*/_interopNamespace(decoding);
+var encoding__namespace = /*#__PURE__*/_interopNamespace(encoding);
+
+// src/collab/assets.ts
+var isPayload = (value) => typeof value === "string" && value.length > 0;
+function createAssetSync(spec) {
+  const suffix = spec.versionSuffix ?? "__v";
+  const fieldNames = Object.keys(spec.fields);
+  const refToField = new Map(Object.entries(spec.fields).map(([field, ref]) => [ref, field]));
+  const assetKey = (ownerId, field) => `${ownerId}:${field}`;
+  const versionKey = (field) => `${field}${suffix}`;
+  const refOf = (field) => spec.fields[field];
+  return {
+    spec,
+    isAssetField: (field) => field in spec.fields,
+    isRefKey: (key) => refToField.has(key),
+    isVersionKey: (key) => key.endsWith(suffix) && key.slice(0, -suffix.length) in spec.fields,
+    assetKey,
+    getMap: (doc) => doc.getMap(spec.mapName),
+    write(ownerId, record, owner, assets) {
+      for (const field of fieldNames) {
+        const value = record[field];
+        if (!isPayload(value)) continue;
+        const key = assetKey(ownerId, field);
+        if (assets.get(key) !== value) assets.set(key, value);
+        owner.set(refOf(field), key);
+      }
+    },
+    reconcile(ownerId, record, owner, assets) {
+      for (const field of fieldNames) {
+        const refKey = refOf(field);
+        const value = record[field];
+        if (isPayload(value)) {
+          const key = assetKey(ownerId, field);
+          if (assets.get(key) !== value) {
+            assets.set(key, value);
+            const current = owner.get(versionKey(field));
+            owner.set(versionKey(field), (typeof current === "number" ? current : 0) + 1);
+          }
+          if (owner.get(refKey) !== key) owner.set(refKey, key);
+        } else {
+          const existing = owner.get(refKey);
+          if (typeof existing === "string") {
+            owner.delete(refKey);
+            assets.delete(existing);
+          }
+        }
+      }
+    },
+    read(owner, assets, target) {
+      for (const [refKey, field] of refToField) {
+        const ref = owner.get(refKey);
+        if (typeof ref !== "string") continue;
+        const value = assets.get(ref);
+        if (typeof value === "string") target[field] = value;
+      }
+    }
+  };
+}
+
+// src/collab/validation.ts
+var DEFAULT_COLOR = "#4c8bf5";
+var ROOM_ID_REGEX = /^[a-zA-Z0-9_-]{1,128}$/u;
+var HEX_COLOR_REGEX = /^#[0-9a-fA-F]{6}$/u;
+var CONTROL_CHARS = /[\u0000-\u001f\u007f]/u;
+function isValidRoomId(roomId) {
+  return typeof roomId === "string" && ROOM_ID_REGEX.test(roomId);
+}
+function validateRoomId(roomId) {
+  if (!isValidRoomId(roomId)) {
+    throw new Error(
+      `Invalid collaboration room ID: "${String(roomId)}". Must be 1-128 alphanumeric characters, hyphens, or underscores.`
+    );
+  }
+  return roomId;
+}
+function isValidId(value, max = 160) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function stripHtmlTags(text) {
+  let result = "";
+  let insideTag = false;
+  for (const char of text) {
+    if (char === "<") insideTag = true;
+    else if (char === ">") insideTag = false;
+    else if (!insideTag) result += char;
+  }
+  return result;
+}
+function sanitizeUserName(name, fallback = "Anonymous") {
+  if (typeof name !== "string") return fallback;
+  const trimmed = stripHtmlTags(name).trim().slice(0, 64);
+  return trimmed || fallback;
+}
+function validateDisplayName(name) {
+  const trimmed = name.trim();
+  if (!trimmed || trimmed.length > 80 || CONTROL_CHARS.test(trimmed))
+    throw new Error("Display name must contain 1 to 80 printable characters");
+  return trimmed;
+}
+function sanitizeColor(color, fallback = DEFAULT_COLOR) {
+  return typeof color === "string" && HEX_COLOR_REGEX.test(color) ? color : fallback;
+}
+function sanitizeAvatarUrl(url) {
+  if (typeof url !== "string") return void 0;
+  try {
+    const { protocol } = new URL(url);
+    if (protocol === "https:" || protocol === "http:" || protocol === "data:") return url;
+  } catch {
+  }
+  return void 0;
+}
+function sanitizeIndex(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+function clampCoordinate(value, min, max, margin = 20) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(min - margin, Math.min(max + margin, value));
+}
+var LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function isMixedContentBlocked(serverUrl, pageProtocol = globalThis.location?.protocol) {
+  if (pageProtocol !== "https:") return false;
+  let parsed;
+  try {
+    parsed = new URL(serverUrl);
+  } catch {
+    return false;
+  }
+  return parsed.protocol === "ws:" && !LOOPBACK_HOSTS.includes(parsed.hostname);
+}
+
+// src/collab/identity.ts
+var COLLABORATION_ROLES = [
+  "owner",
+  "collaborator",
+  "viewer"
+];
+function sanitizeRole(value) {
+  return COLLABORATION_ROLES.includes(value) ? value : void 0;
+}
+function canWrite(role) {
+  return role !== "viewer";
+}
+var CURSOR_PALETTE = [
+  "#ef4444",
+  "#f97316",
+  "#eab308",
+  "#22c55e",
+  "#06b6d4",
+  "#3b82f6",
+  "#8b5cf6",
+  "#ec4899"
+];
+var MAX_LABEL_CHARS = 20;
+function assignUserColor(seed, palette = CURSOR_PALETTE) {
+  if (palette.length === 0) return DEFAULT_COLOR;
+  let hash = 0;
+  const text = String(seed);
+  for (let i = 0; i < text.length; i++) hash = hash * 31 + text.charCodeAt(i) | 0;
+  return palette[Math.abs(hash) % palette.length] ?? DEFAULT_COLOR;
+}
+function formatCursorLabel(userName, maxChars = MAX_LABEL_CHARS) {
+  if (userName.length <= maxChars) return userName;
+  return `${userName.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function getUserInitials(name) {
+  const trimmed = name.trim();
+  const parts = trimmed.split(/\s+/u).filter(Boolean);
+  const first = parts[0];
+  const last = parts[parts.length - 1];
+  if (parts.length >= 2 && first && last) return (first[0] + last[0]).toUpperCase();
+  return trimmed.slice(0, 2).toUpperCase();
+}
+function createClientId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.randomUUID) return cryptoApi.randomUUID();
+  return `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function clientKey(clientId) {
+  if (!isValidId(clientId)) throw new Error("Invalid collaboration client ID");
+  return Array.from(clientId, (character) => character.codePointAt(0).toString(16)).join("_");
+}
+function createIdGenerator(clientId, prefix = "cid") {
+  const key = clientKey(clientId);
+  let counter = 0;
+  return (kind) => {
+    const safeKind = kind.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 24) || "item";
+    return `${prefix}-${safeKind}-${key}-${++counter}`;
+  };
+}
+function buildRoster(params) {
+  const customInitials = params.localUserInitials?.trim();
+  const local = {
+    id: "local",
+    name: params.localUserName,
+    initials: customInitials ? customInitials.slice(0, 2).toUpperCase() : getUserInitials(params.localUserName),
+    color: params.localUserColor ?? "#6366f1",
+    isLocal: true
+  };
+  const remote = params.remoteUsers.map((user) => {
+    const entry = {
+      id: String(user.clientId),
+      name: user.userName,
+      initials: getUserInitials(user.userName),
+      color: user.userColor,
+      isLocal: false
+    };
+    if (user.userAvatar) entry.avatarUrl = user.userAvatar;
+    return entry;
+  });
+  return [local, ...remote];
+}
+
+// src/collab/presence.ts
+var PRESENCE_FIELD = "presence";
+var STALE_PRESENCE_MS = 3e4;
+var PRESENCE_HEARTBEAT_MS = 1e4;
+var BROADCAST_THROTTLE_MS = 50;
+function sanitizeIdentity(raw) {
+  return {
+    userName: sanitizeUserName(raw.userName),
+    userColor: sanitizeColor(raw.userColor, DEFAULT_COLOR),
+    userAvatar: sanitizeAvatarUrl(raw.userAvatar),
+    role: sanitizeRole(raw.role)
+  };
+}
+function isPresenceFresh(lastUpdated, now = Date.now(), staleMs = STALE_PRESENCE_MS) {
+  const updatedAt = new Date(lastUpdated).getTime();
+  return !Number.isNaN(updatedAt) && now - updatedAt <= staleMs;
+}
+function derivePresence(states, localClientId, sanitizePayload, options = {}) {
+  const { now = Date.now(), staleMs = STALE_PRESENCE_MS } = options;
+  const users = [];
+  for (const [clientId, state] of states) {
+    if (clientId === localClientId) continue;
+    const raw = state?.[PRESENCE_FIELD];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw;
+    const payload = sanitizePayload(record);
+    if (!payload) continue;
+    const lastUpdated = typeof record.lastUpdated === "string" ? record.lastUpdated : "";
+    if (!isPresenceFresh(lastUpdated, now, staleMs)) continue;
+    users.push({ ...sanitizeIdentity(record), clientId, lastUpdated, ...payload });
+  }
+  return users;
+}
+function sanitizeCanvasPayload(raw, canvasWidth, canvasHeight) {
+  return {
+    activeSlideIndex: sanitizeIndex(raw.activeSlideIndex),
+    cursorX: clampCoordinate(raw.cursorX, 0, canvasWidth),
+    cursorY: clampCoordinate(raw.cursorY, 0, canvasHeight),
+    selectedElementId: typeof raw.selectedElementId === "string" ? raw.selectedElementId.slice(0, 128) : void 0
+  };
+}
+function deriveCanvasPresence(states, localClientId, canvasWidth, canvasHeight, options = {}) {
+  return derivePresence(
+    states,
+    localClientId,
+    (raw) => sanitizeCanvasPayload(raw, canvasWidth, canvasHeight),
+    options
+  );
+}
+function presenceToCursors(presence, activeSlideIndex) {
+  const cursors = [];
+  for (const user of presence) {
+    if (activeSlideIndex !== void 0 && user.activeSlideIndex !== activeSlideIndex) continue;
+    const cursor = {
+      clientId: user.clientId,
+      userName: user.userName,
+      color: user.userColor,
+      x: user.cursorX,
+      y: user.cursorY
+    };
+    if (user.selectedElementId) cursor.selectionIds = [user.selectedElementId];
+    cursors.push(cursor);
+  }
+  return cursors;
+}
+function asSelectionIds(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+
+// src/collab/awareness.ts
+function createPresencePublisher(awareness, identity, initial, options = {}) {
+  const throttleMs = options.throttleMs ?? BROADCAST_THROTTLE_MS;
+  const clock = options.now ?? Date.now;
+  const local = { ...initial };
+  let lastBroadcast = 0;
+  let pending = null;
+  const publish = () => {
+    lastBroadcast = clock();
+    awareness.setLocalStateField(PRESENCE_FIELD, {
+      ...identity,
+      ...local,
+      lastUpdated: new Date(clock()).toISOString()
+    });
+  };
+  const cancel = () => {
+    if (pending !== null) clearTimeout(pending);
+    pending = null;
+  };
+  const update = (patch) => {
+    const keys = Object.keys(patch);
+    if (!keys.some((key) => patch[key] !== local[key])) return;
+    Object.assign(local, patch);
+    const elapsed = clock() - lastBroadcast;
+    if (elapsed >= throttleMs) {
+      cancel();
+      publish();
+    } else if (pending === null) {
+      pending = setTimeout(() => {
+        pending = null;
+        publish();
+      }, throttleMs - elapsed);
+    }
+  };
+  publish();
+  lastBroadcast = 0;
+  return {
+    update,
+    flush: () => {
+      cancel();
+      publish();
+    },
+    dispose: cancel
+  };
+}
+function borrowAwareness(host) {
+  let disposed = false;
+  let ownsPresence = false;
+  let hadPresence = false;
+  let previousPresence;
+  let lastPresence;
+  const awareness = {
+    clientID: host.clientID,
+    getStates: () => host.getStates(),
+    on: (event, callback) => host.on(event, callback),
+    off: (event, callback) => host.off(event, callback),
+    setLocalStateField: (field, value) => {
+      if (disposed) return;
+      const state = host.getLocalState();
+      if (state === null) return;
+      if (field === PRESENCE_FIELD) {
+        if (!ownsPresence || state[PRESENCE_FIELD] !== lastPresence) {
+          hadPresence = Object.hasOwn(state, PRESENCE_FIELD);
+          previousPresence = state[PRESENCE_FIELD];
+        }
+        lastPresence = value;
+        ownsPresence = true;
+      }
+      host.setLocalStateField(field, value);
+    }
+  };
+  return {
+    awareness,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      const current = host.getLocalState();
+      if (!ownsPresence || current === null || current[PRESENCE_FIELD] !== lastPresence) return;
+      const restored = { ...current };
+      if (hadPresence) restored[PRESENCE_FIELD] = previousPresence;
+      else delete restored[PRESENCE_FIELD];
+      host.setLocalState(restored);
+    }
+  };
+}
+function clearLocalAwareness(awareness) {
+  awareness?.setLocalState?.(null);
+}
+function removeAwarenessStatesLocally(awareness, clients) {
+  const states = awareness?.states;
+  if (!awareness || !states) return [];
+  const removed = clients.filter((clientId) => states.delete(clientId));
+  if (removed.length > 0) {
+    const change = { added: [], updated: [], removed };
+    awareness.emit?.("change", [change, "peer-departed"]);
+    awareness.emit?.("update", [change, "peer-departed"]);
+  }
+  return removed;
+}
+
+// src/collab/policy.ts
+var INITIAL_SYNC_GRACE_MS = 3e3;
+function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
+  let opened = false;
+  let timer = null;
+  const clear = () => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+  };
+  const open = () => {
+    clear();
+    if (opened) return;
+    opened = true;
+    onOpen();
+  };
+  return {
+    isOpen: () => opened,
+    arm: () => {
+      clear();
+      if (!opened) timer = setTimeout(open, graceMs);
+    },
+    open,
+    reset: () => {
+      clear();
+      opened = false;
+    }
+  };
+}
+function shouldRoomReplaceLoad(origin, roomIsNonEmpty) {
+  return (origin ?? "user") === "bootstrap" && roomIsNonEmpty;
+}
+function shouldAutoFollowBroadcaster(input) {
+  return input.localRole === "viewer" && input.broadcasterRole === "owner";
+}
+
+// src/collab/binding.ts
+var LOCAL_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:collab:local");
+function bindDocument(session, adapter, options) {
+  let disposed = false;
+  const adoptRoom = () => options.onRemoteModel(adapter.read(session.doc));
+  const stopObserving = adapter.observe(session.doc, (origin) => {
+    if (disposed || origin === LOCAL_ORIGIN) return;
+    adoptRoom();
+  });
+  const settle = () => {
+    if (disposed) return;
+    if (adapter.isEmpty(session.doc)) {
+      if (session.canWrite()) adapter.write(session.doc, options.getLocalModel(), LOCAL_ORIGIN);
+    } else adoptRoom();
+  };
+  const stopReady = session.on("ready", settle);
+  if (session.canWrite()) settle();
+  return {
+    push: (model) => {
+      if (disposed || !session.canWrite()) return false;
+      adapter.write(session.doc, model, LOCAL_ORIGIN);
+      return true;
+    },
+    handleLoad: (origin, model) => {
+      if (disposed) return false;
+      if (shouldRoomReplaceLoad(origin, !adapter.isEmpty(session.doc))) {
+        adoptRoom();
+        return true;
+      }
+      if (session.canWrite()) adapter.write(session.doc, model, LOCAL_ORIGIN);
+      return false;
+    },
+    dispose: () => {
+      disposed = true;
+      stopObserving();
+      stopReady();
+    }
+  };
+}
+var MAX_UPDATE_BYTES = 32 * 1024 * 1024;
+function encodeSnapshot(doc) {
+  return Y__namespace.encodeStateAsUpdate(doc);
+}
+function encodeDiff(doc, peerStateVector) {
+  return Y__namespace.encodeStateAsUpdate(doc, peerStateVector);
+}
+function encodeStateVector2(doc) {
+  return Y__namespace.encodeStateVector(doc);
+}
+function validateUpdate(update, maxBytes = MAX_UPDATE_BYTES) {
+  if (!(update instanceof Uint8Array)) return { ok: false, reason: "update must be a Uint8Array" };
+  if (update.byteLength === 0) return { ok: false, reason: "update is empty" };
+  if (update.byteLength > maxBytes)
+    return { ok: false, reason: `update exceeds the ${maxBytes} byte limit` };
+  try {
+    Y__namespace.decodeUpdate(update);
+    return { ok: true };
+  } catch (cause) {
+    return {
+      ok: false,
+      reason: `malformed update: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+}
+function applyUpdateSafe(doc, update, origin, options = {}) {
+  const checked = options.validate === false ? update instanceof Uint8Array && update.byteLength <= (options.maxBytes ?? MAX_UPDATE_BYTES) ? { ok: true } : { ok: false, reason: "invalid or oversized update" } : validateUpdate(update, options.maxBytes);
+  if (!checked.ok) return checked;
+  try {
+    Y__namespace.applyUpdate(doc, update, origin);
+    return { ok: true };
+  } catch (cause) {
+    return {
+      ok: false,
+      reason: `could not apply update: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+}
+function restoreSnapshot(snapshot, options = {}) {
+  const doc = new Y__namespace.Doc();
+  const result = applyUpdateSafe(doc, snapshot, "snapshot", options);
+  if (!result.ok) {
+    doc.destroy();
+    throw new Error(result.reason);
+  }
+  return doc;
+}
+function mergeUpdates2(updates) {
+  return Y__namespace.mergeUpdates([...updates]);
+}
+var CHUNK = 32768;
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK)
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  return btoa(binary);
+}
+function fromBase64(text) {
+  try {
+    const binary = atob(text);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
+
+// src/collab/emitter.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) this.listeners.set(event, set = /* @__PURE__ */ new Set());
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    for (const listener of [...this.listeners.get(event) ?? []]) {
+      try {
+        listener(payload);
+      } catch (error) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/collab/external-provider.ts
+function adaptYjsProvider(provider) {
+  const events = new Emitter();
+  let status = provider.wsconnected || provider.connected ? "connected" : "disconnected";
+  let synced = Boolean(provider.synced);
+  const subscriptions = [];
+  const listen = (name, handler) => {
+    const wrapped = handler;
+    provider.on(name, wrapped);
+    subscriptions.push([name, wrapped]);
+  };
+  const setStatus = (next) => {
+    if (next === status) return;
+    status = next;
+    events.emit("status", next);
+  };
+  const setSynced = (next) => {
+    if (next === synced) return;
+    synced = next;
+    events.emit("synced", next);
+  };
+  listen("status", (payload) => {
+    if (typeof payload.connected === "boolean")
+      return setStatus(payload.connected ? "connected" : "disconnected");
+    if (payload.status === "connected" || payload.status === "connecting")
+      setStatus(payload.status);
+    else if (payload.status === "disconnected") {
+      setSynced(false);
+      setStatus("disconnected");
+    }
+  });
+  listen("sync", (value) => setSynced(Boolean(value)));
+  listen("synced", (value) => setSynced(Boolean(value.synced)));
+  listen("connection-error", (cause) => {
+    setStatus("error");
+    events.emit("error", cause instanceof Error ? cause : new Error("Provider connection error"));
+  });
+  return {
+    get status() {
+      return status;
+    },
+    get synced() {
+      return synced;
+    },
+    connect: () => {
+      setStatus("connecting");
+      provider.connect?.();
+    },
+    disconnect: () => provider.disconnect?.(),
+    destroy: () => {
+      for (const [name, handler] of subscriptions) provider.off?.(name, handler);
+      subscriptions.length = 0;
+      events.clear();
+      provider.destroy?.();
+    },
+    on: (event, listener) => events.on(event, listener)
+  };
+}
+function observeExternalSession(session, onSnapshot) {
+  let active = true;
+  let subscribing = true;
+  let previous;
+  let unsubscribe;
+  const notify = () => {
+    if (!active || subscribing) return;
+    const snapshot = session.getSnapshot();
+    if (previous?.status === snapshot.status && previous.synced === snapshot.synced) return;
+    previous = { status: snapshot.status, synced: snapshot.synced };
+    onSnapshot(previous);
+  };
+  const dispose = () => {
+    if (!active) return;
+    active = false;
+    unsubscribe?.();
+  };
+  try {
+    unsubscribe = session.subscribe(notify);
+    subscribing = false;
+    notify();
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  return dispose;
+}
+
+// src/collab/lifecycle.ts
+var COLLAB_LEAVE_MESSAGE = "ooxml-core:collab-leave";
+var DEPARTURE_CHANNEL = "ooxml-core:collab-departures";
+var LEGACY_PPTX_LEAVE_MESSAGE = "pptx-viewer:collab-leave";
+var LEGACY_PPTX_DEPARTURE_CHANNEL = "pptx-viewer:collab-departures";
+function isLeaveMessage(data, expected) {
+  if (typeof data === "string") return data === expected;
+  return typeof data === "object" && data !== null && data.type === expected;
+}
+function registerTeardown(options) {
+  const target = options.target ?? globalThis.window;
+  if (!target) return () => {
+  };
+  const { leave, rejoin } = options;
+  const leaveMessage = options.leaveMessage ?? COLLAB_LEAVE_MESSAGE;
+  let left = false;
+  const doLeave = () => {
+    if (left) return;
+    left = true;
+    leave();
+  };
+  const onPageHide = (event) => {
+    if (event.persisted === true && !rejoin) return;
+    doLeave();
+  };
+  const onBeforeUnload = () => {
+    const allowed = typeof options.leaveOnBeforeUnload === "function" ? options.leaveOnBeforeUnload() : options.leaveOnBeforeUnload !== false;
+    if (allowed) doLeave();
+  };
+  const onPageShow = (event) => {
+    if (event.persisted !== true || !left || !rejoin) return;
+    left = false;
+    rejoin();
+  };
+  const onMessage = (event) => {
+    if (isLeaveMessage(event.data, leaveMessage)) doLeave();
+  };
+  const listeners = {
+    pagehide: onPageHide,
+    beforeunload: onBeforeUnload,
+    pageshow: onPageShow,
+    message: onMessage
+  };
+  for (const [type, listener] of Object.entries(listeners)) target.addEventListener(type, listener);
+  return () => {
+    for (const [type, listener] of Object.entries(listeners))
+      target.removeEventListener(type, listener);
+  };
+}
+function defaultFactory(name) {
+  const scope = globalThis;
+  return scope.BroadcastChannel ? new scope.BroadcastChannel(name) : null;
+}
+function createDepartureChannel(roomId, awareness, factory, channelName = DEPARTURE_CHANNEL) {
+  const channel = factory ? factory(channelName) : defaultFactory(channelName);
+  if (!channel) return { announce: () => {
+  }, dispose: () => {
+  } };
+  const selfId = awareness.clientID;
+  channel.onmessage = (event) => {
+    const data = event.data;
+    if (typeof data !== "object" || data === null) return;
+    const notice = data;
+    if (notice.channel !== channelName || notice.roomId !== roomId) return;
+    if (typeof notice.clientId !== "number" || notice.clientId === selfId) return;
+    removeAwarenessStatesLocally(awareness, [notice.clientId]);
+  };
+  let closed = false;
+  return {
+    announce: () => {
+      if (closed || typeof selfId !== "number") return;
+      channel.postMessage({ channel: channelName, roomId, clientId: selfId });
+    },
+    dispose: () => {
+      if (closed) return;
+      closed = true;
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+
+// src/collab/memory-transport.ts
+function createMemoryHub(options = {}) {
+  const rooms = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  const deliver = (task) => {
+    if (options.async) queueMicrotask(task);
+    else task();
+  };
+  return {
+    size: (roomId) => rooms.get(roomId)?.size ?? 0,
+    createTransport(roomId) {
+      const id = nextId++;
+      let endpoint = null;
+      const peers = () => {
+        let room = rooms.get(roomId);
+        if (!room) rooms.set(roomId, room = /* @__PURE__ */ new Set());
+        return room;
+      };
+      return {
+        get connected() {
+          return endpoint !== null;
+        },
+        connect(handlers) {
+          if (endpoint) peers().delete(endpoint);
+          const self = { id, handlers };
+          const others = [...peers()];
+          peers().add(self);
+          endpoint = self;
+          deliver(() => {
+            if (endpoint !== self) return;
+            handlers.open();
+            for (const other of others) other.handlers.peer?.();
+          });
+        },
+        send(data) {
+          const self = endpoint;
+          if (!self || options.filter && !options.filter(data, id)) return;
+          for (const other of [...peers()])
+            if (other !== self) deliver(() => other.handlers.message(data.slice()));
+        },
+        disconnect() {
+          const self = endpoint;
+          if (!self) return;
+          endpoint = null;
+          peers().delete(self);
+          self.handlers.close("disconnected");
+        }
+      };
+    }
+  };
+}
+
+// src/collab/ordering.ts
+function classifyVersion(messageVersion, currentVersion) {
+  if (!isNonNegativeSafeInteger(messageVersion) || !isNonNegativeSafeInteger(currentVersion))
+    return "invalid";
+  if (messageVersion < currentVersion) return "stale";
+  return messageVersion > currentVersion ? "out-of-order" : "apply";
+}
+var BoundedMap = class {
+  constructor(limit) {
+    this.limit = limit;
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new Error("limit must be positive");
+  }
+  limit;
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    if (this.entries.size > this.limit) {
+      const oldest = this.entries.keys().next();
+      if (!oldest.done) this.entries.delete(oldest.value);
+    }
+  }
+  delete(key) {
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var IdempotencyCache = class {
+  seen;
+  constructor(limit = 5e3) {
+    this.seen = new BoundedMap(limit);
+  }
+  check(clientId, messageId, fingerprint) {
+    const prior = this.seen.get(`${clientId}\0${messageId}`);
+    if (!prior) return { status: "fresh" };
+    return prior.fingerprint === fingerprint ? { status: "duplicate", value: prior.value } : { status: "reused" };
+  }
+  remember(clientId, messageId, fingerprint, value) {
+    this.seen.set(`${clientId}\0${messageId}`, { fingerprint, value });
+  }
+};
+var SequenceTracker = class {
+  last;
+  constructor(limit = 200) {
+    this.last = new BoundedMap(limit);
+  }
+  /** Classify without recording; call {@link commit} once the message was actually applied. */
+  classify(peerId, sequence, fingerprint) {
+    if (!isNonNegativeSafeInteger(sequence) || sequence < 1) return "invalid";
+    const previous = this.last.get(peerId);
+    if (!previous || sequence > previous.sequence) return "apply";
+    if (sequence < previous.sequence) return "stale";
+    return previous.fingerprint === fingerprint ? "duplicate" : "invalid";
+  }
+  commit(peerId, sequence, fingerprint) {
+    this.last.set(peerId, { sequence, fingerprint });
+  }
+  forget(peerId) {
+    this.last.delete(peerId);
+  }
+};
+function freezeDeep(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freezeDeep(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// src/collab/provider.ts
+var CONNECTION_TIMEOUT_MS = 3e4;
+function createCollabSession(options) {
+  const roomId = validateRoomId(options.roomId);
+  const ownsDoc = !options.doc;
+  const doc = options.doc ?? new Y__namespace.Doc();
+  const awareness = new awarenessProtocol.Awareness(doc);
+  const events = new Emitter();
+  const role = options.user.role;
+  const identity = {
+    userName: sanitizeUserName(options.user.name),
+    userColor: sanitizeColor(options.user.color, assignUserColor(doc.clientID)),
+    userAvatar: options.user.avatar,
+    role
+  };
+  const sanitizePayload = options.sanitizePayload ?? (() => ({}));
+  const publisher = createPresencePublisher(
+    awareness,
+    identity,
+    options.initialPresence ?? {}
+  );
+  let destroyed = false;
+  let timeout = null;
+  const gate = createSyncGate(() => {
+    if (destroyed) return;
+    options.onReady?.({ synced: provider.synced });
+    events.emit("ready", void 0);
+  }, options.syncGraceMs ?? INITIAL_SYNC_GRACE_MS);
+  const peers = () => derivePresence(awareness.getStates(), doc.clientID, sanitizePayload);
+  const emitPeers = () => events.emit("peers", peers());
+  awareness.on("change", emitPeers);
+  const provider = options.provider({ doc, awareness, roomId });
+  const clearTimeoutTimer = () => {
+    if (timeout !== null) clearTimeout(timeout);
+    timeout = null;
+  };
+  provider.on("status", (status) => {
+    clearTimeoutTimer();
+    events.emit("status", status);
+    if (status === "connecting")
+      timeout = setTimeout(() => {
+        events.emit("error", new Error("Collaboration connection timed out"));
+        events.emit("status", "error");
+      }, options.connectionTimeoutMs ?? CONNECTION_TIMEOUT_MS);
+    if (status === "connected") gate.arm();
+  });
+  provider.on("synced", (synced) => {
+    events.emit("synced", synced);
+    if (synced) gate.open();
+  });
+  provider.on("error", (error) => events.emit("error", error));
+  const heartbeatMs = options.heartbeatMs ?? PRESENCE_HEARTBEAT_MS;
+  const heartbeat = heartbeatMs > 0 ? setInterval(() => {
+    publisher.flush();
+    emitPeers();
+  }, heartbeatMs) : null;
+  heartbeat?.unref?.();
+  const departure = createDepartureChannel(roomId, awareness);
+  const leave = () => {
+    departure.announce();
+    publisher.dispose();
+    awareness.setLocalState(null);
+    provider.disconnect();
+  };
+  const unregisterTeardown = options.teardown ? registerTeardown({
+    leave,
+    rejoin: () => {
+      publisher.flush();
+      provider.connect();
+    },
+    ...typeof options.teardown === "object" ? options.teardown : {}
+  }) : () => {
+  };
+  const session = {
+    roomId,
+    doc,
+    awareness,
+    clientId: doc.clientID,
+    role,
+    identity,
+    gate,
+    provider,
+    get status() {
+      return provider.status;
+    },
+    get synced() {
+      return provider.synced;
+    },
+    canWrite: () => !destroyed && gate.isOpen() && canWrite(role),
+    peers,
+    updatePresence: (patch) => publisher.update(patch),
+    on: (event, listener) => events.on(event, listener),
+    connect: () => {
+      if (!destroyed) provider.connect();
+    },
+    disconnect: () => {
+      clearTimeoutTimer();
+      gate.reset();
+      provider.disconnect();
+    },
+    destroy: () => {
+      if (destroyed) return;
+      departure.announce();
+      unregisterTeardown();
+      clearTimeoutTimer();
+      if (heartbeat !== null) clearInterval(heartbeat);
+      publisher.dispose();
+      gate.reset();
+      awareness.setLocalState(null);
+      provider.destroy();
+      departure.dispose();
+      awareness.off("change", emitPeers);
+      awareness.destroy();
+      destroyed = true;
+      events.clear();
+      if (ownsDoc) doc.destroy();
+    }
+  };
+  if (options.autoConnect !== false) provider.connect();
+  return session;
+}
+var MESSAGE_SYNC = 0;
+var MESSAGE_AWARENESS = 1;
+var MESSAGE_QUERY_AWARENESS = 3;
+var SYNC_STEP1 = 0;
+var SYNC_STEP2 = 1;
+var SYNC_UPDATE = 2;
+function transportProvider(options) {
+  return (context) => createTransportProvider(context, options);
+}
+function createTransportProvider({ doc, awareness }, { transport, maxMessageBytes = MAX_UPDATE_BYTES }) {
+  const events = new Emitter();
+  let status = "disconnected";
+  let synced = false;
+  let open = false;
+  let destroyed = false;
+  const origin = {};
+  const setStatus = (next) => {
+    if (status === next) return;
+    status = next;
+    events.emit("status", next);
+  };
+  const setSynced = (next) => {
+    if (synced === next) return;
+    synced = next;
+    events.emit("synced", next);
+  };
+  const fail = (reason) => events.emit("error", new Error(reason));
+  const send = (encoder) => {
+    if (open) transport.send(encoding__namespace.toUint8Array(encoder));
+  };
+  const sendStep1 = () => {
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding__namespace.writeVarUint(encoder, SYNC_STEP1);
+    encoding__namespace.writeVarUint8Array(encoder, Y__namespace.encodeStateVector(doc));
+    send(encoder);
+  };
+  const sendAwareness = (clients) => {
+    if (clients.length === 0) return;
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_AWARENESS);
+    encoding__namespace.writeVarUint8Array(
+      encoder,
+      awarenessProtocol__namespace.encodeAwarenessUpdate(awareness, clients)
+    );
+    send(encoder);
+  };
+  const handshake = () => {
+    sendStep1();
+    const local = awareness.getLocalState();
+    if (local !== null) awareness.setLocalState(local);
+  };
+  const onDocUpdate = (update, updateOrigin) => {
+    if (updateOrigin === origin || !open) return;
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding__namespace.writeVarUint(encoder, SYNC_UPDATE);
+    encoding__namespace.writeVarUint8Array(encoder, update);
+    send(encoder);
+  };
+  const onAwarenessUpdate = (change, updateOrigin) => {
+    if (updateOrigin === origin) return;
+    sendAwareness([...change.added, ...change.updated, ...change.removed]);
+  };
+  const readSync = (decoder) => {
+    const kind = decoding__namespace.readVarUint(decoder);
+    const payload = decoding__namespace.readVarUint8Array(decoder);
+    if (kind === SYNC_STEP1) {
+      const encoder = encoding__namespace.createEncoder();
+      encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+      encoding__namespace.writeVarUint(encoder, SYNC_STEP2);
+      let diff;
+      try {
+        diff = Y__namespace.encodeStateAsUpdate(doc, payload);
+      } catch {
+        return fail("malformed state vector");
+      }
+      encoding__namespace.writeVarUint8Array(encoder, diff);
+      return send(encoder);
+    }
+    if (kind !== SYNC_STEP2 && kind !== SYNC_UPDATE) return fail(`unknown sync message ${kind}`);
+    const result = applyUpdateSafe(doc, payload, origin, { maxBytes: maxMessageBytes });
+    if (!result.ok) return fail(result.reason);
+    if (kind === SYNC_STEP2) setSynced(true);
+  };
+  const onMessage = (data) => {
+    if (destroyed) return;
+    if (!(data instanceof Uint8Array) || data.byteLength === 0 || data.byteLength > maxMessageBytes)
+      return fail("message is empty, not binary, or too large");
+    try {
+      const decoder = decoding__namespace.createDecoder(data);
+      const type = decoding__namespace.readVarUint(decoder);
+      if (type === MESSAGE_SYNC) readSync(decoder);
+      else if (type === MESSAGE_AWARENESS)
+        awarenessProtocol__namespace.applyAwarenessUpdate(
+          awareness,
+          decoding__namespace.readVarUint8Array(decoder),
+          origin
+        );
+      else if (type === MESSAGE_QUERY_AWARENESS) sendAwareness([...awareness.getStates().keys()]);
+    } catch (cause) {
+      fail(`malformed message: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+  };
+  const dropRemotePeers = () => {
+    const remote = [...awareness.getStates().keys()].filter((id) => id !== doc.clientID);
+    if (remote.length > 0) awarenessProtocol__namespace.removeAwarenessStates(awareness, remote, origin);
+  };
+  const connect = () => {
+    if (destroyed) return;
+    setStatus("connecting");
+    transport.connect({
+      open: () => {
+        if (destroyed) return;
+        open = true;
+        setStatus("connected");
+        handshake();
+      },
+      close: () => {
+        open = false;
+        setSynced(false);
+        dropRemotePeers();
+        if (!destroyed) setStatus("disconnected");
+      },
+      message: onMessage,
+      error: (error) => {
+        events.emit("error", error);
+        if (!open) setStatus("error");
+      },
+      peer: () => {
+        if (open && !destroyed) handshake();
+      }
+    });
+  };
+  doc.on("update", onDocUpdate);
+  awareness.on("update", onAwarenessUpdate);
+  return {
+    get status() {
+      return status;
+    },
+    get synced() {
+      return synced;
+    },
+    connect,
+    disconnect: () => {
+      if (destroyed) return;
+      const local = awareness.getLocalState();
+      if (open && local !== null) awareness.setLocalState(null);
+      transport.disconnect();
+      open = false;
+      if (local !== null) awareness.setLocalState(local);
+      setSynced(false);
+      dropRemotePeers();
+      setStatus("disconnected");
+    },
+    destroy: () => {
+      if (destroyed) return;
+      if (open) awareness.setLocalState(null);
+      destroyed = true;
+      open = false;
+      doc.off("update", onDocUpdate);
+      awareness.off("update", onAwarenessUpdate);
+      transport.disconnect();
+      events.clear();
+    },
+    on: (event, listener) => events.on(event, listener)
+  };
+}
+
+// src/collab/websocket-transport.ts
+var OPEN = 1;
+function roomUrl(server, roomId) {
+  return `${server.replace(/\/+$/u, "")}/${encodeURIComponent(roomId)}`;
+}
+function createWebSocketTransport(options) {
+  const { baseDelayMs = 250, maxDelayMs = 1e4, maxRetries = Infinity } = options;
+  let socket = null;
+  let handlers = null;
+  let timer = null;
+  let failures = 0;
+  let stopped = true;
+  const open = () => {
+    if (stopped || !handlers) return;
+    const active = handlers;
+    const Impl = options.WebSocket ?? globalThis.WebSocket;
+    if (!Impl) return active.error(new Error("No WebSocket implementation available"));
+    if (isMixedContentBlocked(options.url, options.pageProtocol)) {
+      stopped = true;
+      return active.error(new Error("Insecure ws:// connection blocked from an https page"));
+    }
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      failures = 0;
+      active.open();
+    };
+    ws.onmessage = (event) => {
+      const data = event.data;
+      if (data instanceof ArrayBuffer) active.message(new Uint8Array(data));
+      else if (data instanceof Uint8Array) active.message(data);
+      else active.error(new Error("Received a non-binary WebSocket message"));
+    };
+    ws.onerror = () => active.error(new Error("WebSocket error"));
+    ws.onclose = (event) => {
+      if (socket !== ws) return;
+      socket = null;
+      active.close(event.reason);
+      if (stopped) return;
+      if (++failures > maxRetries) {
+        stopped = true;
+        return active.error(new Error("WebSocket reconnect attempts exhausted"));
+      }
+      timer = setTimeout(open, Math.min(maxDelayMs, baseDelayMs * 2 ** (failures - 1)));
+    };
+  };
+  return {
+    connect(next) {
+      handlers = next;
+      stopped = false;
+      failures = 0;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      if (socket) socket.close();
+      open();
+    },
+    send(data) {
+      if (socket && socket.readyState === OPEN) socket.send(data);
+    },
+    disconnect() {
+      stopped = true;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      const ws = socket;
+      socket = null;
+      if (ws) {
+        ws.onclose = null;
+        ws.close();
+        handlers?.close("disconnected");
+      }
+    }
+  };
+}
+
+exports.BROADCAST_THROTTLE_MS = BROADCAST_THROTTLE_MS;
+exports.BoundedMap = BoundedMap;
+exports.COLLABORATION_ROLES = COLLABORATION_ROLES;
+exports.COLLAB_LEAVE_MESSAGE = COLLAB_LEAVE_MESSAGE;
+exports.CONNECTION_TIMEOUT_MS = CONNECTION_TIMEOUT_MS;
+exports.CURSOR_PALETTE = CURSOR_PALETTE;
+exports.DEFAULT_COLOR = DEFAULT_COLOR;
+exports.DEPARTURE_CHANNEL = DEPARTURE_CHANNEL;
+exports.Emitter = Emitter;
+exports.INITIAL_SYNC_GRACE_MS = INITIAL_SYNC_GRACE_MS;
+exports.IdempotencyCache = IdempotencyCache;
+exports.LEGACY_PPTX_DEPARTURE_CHANNEL = LEGACY_PPTX_DEPARTURE_CHANNEL;
+exports.LEGACY_PPTX_LEAVE_MESSAGE = LEGACY_PPTX_LEAVE_MESSAGE;
+exports.LOCAL_ORIGIN = LOCAL_ORIGIN;
+exports.MAX_LABEL_CHARS = MAX_LABEL_CHARS;
+exports.MAX_UPDATE_BYTES = MAX_UPDATE_BYTES;
+exports.MESSAGE_AWARENESS = MESSAGE_AWARENESS;
+exports.MESSAGE_QUERY_AWARENESS = MESSAGE_QUERY_AWARENESS;
+exports.MESSAGE_SYNC = MESSAGE_SYNC;
+exports.PRESENCE_FIELD = PRESENCE_FIELD;
+exports.PRESENCE_HEARTBEAT_MS = PRESENCE_HEARTBEAT_MS;
+exports.STALE_PRESENCE_MS = STALE_PRESENCE_MS;
+exports.SequenceTracker = SequenceTracker;
+exports.adaptYjsProvider = adaptYjsProvider;
+exports.applyUpdateSafe = applyUpdateSafe;
+exports.asSelectionIds = asSelectionIds;
+exports.assignUserColor = assignUserColor;
+exports.bindDocument = bindDocument;
+exports.borrowAwareness = borrowAwareness;
+exports.buildRoster = buildRoster;
+exports.canWrite = canWrite;
+exports.clampCoordinate = clampCoordinate;
+exports.classifyVersion = classifyVersion;
+exports.clearLocalAwareness = clearLocalAwareness;
+exports.createAssetSync = createAssetSync;
+exports.createClientId = createClientId;
+exports.createCollabSession = createCollabSession;
+exports.createDepartureChannel = createDepartureChannel;
+exports.createIdGenerator = createIdGenerator;
+exports.createMemoryHub = createMemoryHub;
+exports.createPresencePublisher = createPresencePublisher;
+exports.createSyncGate = createSyncGate;
+exports.createTransportProvider = createTransportProvider;
+exports.createWebSocketTransport = createWebSocketTransport;
+exports.deriveCanvasPresence = deriveCanvasPresence;
+exports.derivePresence = derivePresence;
+exports.encodeDiff = encodeDiff;
+exports.encodeSnapshot = encodeSnapshot;
+exports.encodeStateVector = encodeStateVector2;
+exports.formatCursorLabel = formatCursorLabel;
+exports.freezeDeep = freezeDeep;
+exports.fromBase64 = fromBase64;
+exports.getUserInitials = getUserInitials;
+exports.isMixedContentBlocked = isMixedContentBlocked;
+exports.isNonNegativeSafeInteger = isNonNegativeSafeInteger;
+exports.isPresenceFresh = isPresenceFresh;
+exports.isValidId = isValidId;
+exports.isValidRoomId = isValidRoomId;
+exports.mergeUpdates = mergeUpdates2;
+exports.observeExternalSession = observeExternalSession;
+exports.presenceToCursors = presenceToCursors;
+exports.registerTeardown = registerTeardown;
+exports.removeAwarenessStatesLocally = removeAwarenessStatesLocally;
+exports.restoreSnapshot = restoreSnapshot;
+exports.roomUrl = roomUrl;
+exports.sanitizeAvatarUrl = sanitizeAvatarUrl;
+exports.sanitizeCanvasPayload = sanitizeCanvasPayload;
+exports.sanitizeColor = sanitizeColor;
+exports.sanitizeIdentity = sanitizeIdentity;
+exports.sanitizeIndex = sanitizeIndex;
+exports.sanitizeRole = sanitizeRole;
+exports.sanitizeUserName = sanitizeUserName;
+exports.shouldAutoFollowBroadcaster = shouldAutoFollowBroadcaster;
+exports.shouldRoomReplaceLoad = shouldRoomReplaceLoad;
+exports.stripHtmlTags = stripHtmlTags;
+exports.toBase64 = toBase64;
+exports.transportProvider = transportProvider;
+exports.validateDisplayName = validateDisplayName;
+exports.validateRoomId = validateRoomId;
+exports.validateUpdate = validateUpdate;