ooxml-core 0.2.0

package/dist/collab/index.mjs

@@ -0,0 +1,1225 @@
+import * as Y from 'yjs';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import { Awareness } from 'y-protocols/awareness';
+import * as decoding from 'lib0/decoding';
+import * as encoding from 'lib0/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.encodeStateAsUpdate(doc);
+}
+function encodeDiff(doc, peerStateVector) {
+  return Y.encodeStateAsUpdate(doc, peerStateVector);
+}
+function encodeStateVector2(doc) {
+  return Y.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.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.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.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.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.Doc();
+  const awareness = new 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.toUint8Array(encoder));
+  };
+  const sendStep1 = () => {
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding.writeVarUint(encoder, SYNC_STEP1);
+    encoding.writeVarUint8Array(encoder, Y.encodeStateVector(doc));
+    send(encoder);
+  };
+  const sendAwareness = (clients) => {
+    if (clients.length === 0) return;
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, MESSAGE_AWARENESS);
+    encoding.writeVarUint8Array(
+      encoder,
+      awarenessProtocol.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.createEncoder();
+    encoding.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding.writeVarUint(encoder, SYNC_UPDATE);
+    encoding.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.readVarUint(decoder);
+    const payload = decoding.readVarUint8Array(decoder);
+    if (kind === SYNC_STEP1) {
+      const encoder = encoding.createEncoder();
+      encoding.writeVarUint(encoder, MESSAGE_SYNC);
+      encoding.writeVarUint(encoder, SYNC_STEP2);
+      let diff;
+      try {
+        diff = Y.encodeStateAsUpdate(doc, payload);
+      } catch {
+        return fail("malformed state vector");
+      }
+      encoding.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.createDecoder(data);
+      const type = decoding.readVarUint(decoder);
+      if (type === MESSAGE_SYNC) readSync(decoder);
+      else if (type === MESSAGE_AWARENESS)
+        awarenessProtocol.applyAwarenessUpdate(
+          awareness,
+          decoding.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.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");
+      }
+    }
+  };
+}
+
+export { BROADCAST_THROTTLE_MS, BoundedMap, COLLABORATION_ROLES, COLLAB_LEAVE_MESSAGE, CONNECTION_TIMEOUT_MS, CURSOR_PALETTE, DEFAULT_COLOR, DEPARTURE_CHANNEL, Emitter, INITIAL_SYNC_GRACE_MS, IdempotencyCache, LEGACY_PPTX_DEPARTURE_CHANNEL, LEGACY_PPTX_LEAVE_MESSAGE, LOCAL_ORIGIN, MAX_LABEL_CHARS, MAX_UPDATE_BYTES, MESSAGE_AWARENESS, MESSAGE_QUERY_AWARENESS, MESSAGE_SYNC, PRESENCE_FIELD, PRESENCE_HEARTBEAT_MS, STALE_PRESENCE_MS, SequenceTracker, adaptYjsProvider, applyUpdateSafe, asSelectionIds, assignUserColor, bindDocument, borrowAwareness, buildRoster, canWrite, clampCoordinate, classifyVersion, clearLocalAwareness, createAssetSync, createClientId, createCollabSession, createDepartureChannel, createIdGenerator, createMemoryHub, createPresencePublisher, createSyncGate, createTransportProvider, createWebSocketTransport, deriveCanvasPresence, derivePresence, encodeDiff, encodeSnapshot, encodeStateVector2 as encodeStateVector, formatCursorLabel, freezeDeep, fromBase64, getUserInitials, isMixedContentBlocked, isNonNegativeSafeInteger, isPresenceFresh, isValidId, isValidRoomId, mergeUpdates2 as mergeUpdates, observeExternalSession, presenceToCursors, registerTeardown, removeAwarenessStatesLocally, restoreSnapshot, roomUrl, sanitizeAvatarUrl, sanitizeCanvasPayload, sanitizeColor, sanitizeIdentity, sanitizeIndex, sanitizeRole, sanitizeUserName, shouldAutoFollowBroadcaster, shouldRoomReplaceLoad, stripHtmlTags, toBase64, transportProvider, validateDisplayName, validateRoomId, validateUpdate };