kritzel-stencil 0.4.4 → 0.4.6

package/dist/stencil/index.esm.js

@@ -1 +1,1172 @@
-import{H as a,a as T}from"./p-uC7_X6yr.js";export{O as APP_STATE_MIGRATIONS,A as AssetNotFoundError,Q as CURRENT_APP_STATE_SCHEMA_VERSION,R as CURRENT_WORKSPACE_SCHEMA_VERSION,C as DEFAULT_ASSET_STORAGE_CONFIG,D as DEFAULT_BRUSH_CONFIG,B as DEFAULT_LINE_TOOL_CONFIG,z as DEFAULT_TEXT_CONFIG,J as DE_LOCALE,G as EN_LOCALE,L as FR_LOCALE,I as IndexedDBAssetProvider,M as KritzelAlignment,t as KritzelAnchorManager,r as KritzelAssetResolver,K as KritzelBaseObject,i as KritzelBaseTool,j as KritzelBrushTool,p as KritzelCursorHelper,h as KritzelCustomElement,x as KritzelCustomElementRendererRegistry,l as KritzelEraserTool,y as KritzelFontRegistry,f as KritzelGroup,d as KritzelImage,m as KritzelImageTool,w as KritzelLicenseManager,e as KritzelLine,k as KritzelLineTool,v as KritzelLocalizationManager,c as KritzelPath,q as KritzelSelectionTool,g as KritzelShape,o as KritzelShapeTool,b as KritzelText,n as KritzelTextTool,u as KritzelThemeManager,s as KritzelWorkspace,S as ShapeType,W as WORKSPACE_EXPORT_VERSION,P as WORKSPACE_MIGRATIONS,F as darkTheme,E as lightTheme,N as runMigrations}from"./p-uC7_X6yr.js";import*as $ from"yjs";import{IndexeddbPersistence as _}from"y-indexeddb";import{WebsocketProvider as U}from"y-websocket";const H=Math.floor,X=127,V=Number.MAX_SAFE_INTEGER;class Y{constructor(){this.cpos=0,this.cbuf=new Uint8Array(100),this.bufs=[]}}const Z=()=>new Y,tt=t=>{const e=new Uint8Array((t=>{let e=t.cpos;for(let s=0;s<t.bufs.length;s++)e+=t.bufs[s].length;return e})(t));let s=0;for(let i=0;i<t.bufs.length;i++){const n=t.bufs[i];e.set(n,s),s+=n.length}return e.set(new Uint8Array(t.cbuf.buffer,0,t.cpos),s),e},et=(t,e)=>{const s=t.cbuf.length;t.cpos===s&&(t.bufs.push(t.cbuf),t.cbuf=new Uint8Array(2*s),t.cpos=0),t.cbuf[t.cpos++]=e},st=(t,e)=>{for(;e>X;)et(t,128|X&e),e=H(e/128);et(t,X&e)},it=(t,e)=>{st(t,e.byteLength),((t,e)=>{const s=t.cbuf.length,i=t.cpos,n=((t,e)=>t<e?t:e)(s-i,e.length),o=e.length-n;t.cbuf.set(e.subarray(0,n),i),t.cpos+=n,o>0&&(t.bufs.push(t.cbuf),t.cbuf=new Uint8Array(((t,e)=>t>e?t:e)(2*s,o)),t.cbuf.set(e.subarray(n)),t.cpos=o)})(t,e)},nt=t=>new Error(t),ot=nt("Unexpected end of array"),rt=nt("Integer out of Range");class ct{constructor(t){this.arr=t,this.pos=0}}const at=t=>((t,e)=>{const s=new Uint8Array(t.arr.buffer,t.pos+t.arr.byteOffset,e);return t.pos+=e,s})(t,ht(t)),ht=t=>{let e=0,s=1;const i=t.arr.length;for(;t.pos<i;){const i=t.arr[t.pos++];if(e+=(i&X)*s,s*=128,i<128)return e;if(e>V)throw rt}throw ot};class lt{type="local";doc;channel;_synced=!1;constructor(t,e,s){this.doc=e,this.channel=new BroadcastChannel(t),this.channel.onmessage=t=>{this.handleMessage(t.data)},this.doc.on("update",this.handleDocUpdate),this.broadcastSync(),setTimeout((()=>{this._synced=!0}),100),s?.quiet||console.info(`BroadcastChannel Provider initialized: ${t}`)}handleDocUpdate=(t,e)=>{if(e!==this){const e=Z();st(e,0),it(e,t),this.channel.postMessage(tt(e))}};handleMessage(t){const e=(s=new Uint8Array(t),new ct(s));var s;switch(ht(e)){case 0:const t=at(e);$.applyUpdate(this.doc,t,this);break;case 1:this.broadcastSync();break;case 2:const s=at(e),i=$.encodeStateAsUpdate(this.doc,s);if(i.length>0){const t=Z();st(t,0),it(t,i),this.channel.postMessage(tt(t))}}}broadcastSync(){const t=Z();st(t,2),it(t,$.encodeStateVector(this.doc)),this.channel.postMessage(tt(t))}async connect(){if(!this._synced)return new Promise((t=>{const e=()=>{this._synced?t():setTimeout(e,50)};e()}))}disconnect(){}async reconnect(){return this.disconnect(),this.connect()}destroy(){this.doc.off("update",this.handleDocUpdate),this.channel.close()}}const dt=new Map;class ut{type="local";doc;cacheKey;isConnected=!1;constructor(t,e,s){this.doc=e,this.cacheKey=s?.name??t}handleUpdate=(t,e)=>{e!==this&&dt.set(this.cacheKey,$.encodeStateAsUpdate(this.doc))};async connect(){if(this.isConnected)return;const t=dt.get(this.cacheKey);t&&$.applyUpdate(this.doc,t,this),this.doc.on("update",this.handleUpdate),this.isConnected=!0}disconnect(){this.isConnected=!1}async reconnect(){return this.disconnect(),this.connect()}destroy(){this.doc.off("update",this.handleUpdate),this.isConnected=!1}static clear(t){void 0!==t?dt.delete(t):dt.clear()}}class yt{type="local";provider;isConnected=!1;constructor(t,e,s){this.provider=new _(s?.name||t,e)}async connect(){if(!this.isConnected)return new Promise((t=>{this.provider.on("synced",(()=>{this.isConnected=!0,t()}))}))}disconnect(){this.isConnected=!1}async reconnect(){return this.disconnect(),this.connect()}destroy(){this.provider&&this.provider.destroy(),this.isConnected=!1}}class wt{type="network";provider;isConnected=!1;_quiet=!1;get awareness(){return this.provider.awareness}constructor(t,e,s){const i=s?.url||"ws://localhost:1234",n=s?.roomName||t;this.provider=new U(i,n,e,{params:s?.params,protocols:s?.protocols,WebSocketPolyfill:s?.WebSocketPolyfill,awareness:s?.awareness,maxBackoffTime:s?.maxBackoffTime,disableBc:!0}),this._quiet=s?.quiet??!1,this.setupEventListeners(),this._quiet||console.info(`WebSocket Provider initialized: ${i}/${n}`)}static with(t){return{create:(e,s,i)=>{const n=i?{...t,...i}:t;return new wt(e,s,n)}}}setupEventListeners(){this.provider.on("status",(({status:t})=>{"connected"===t?(this.isConnected=!0,this._quiet||console.info("WebSocket connected")):"disconnected"===t&&(this.isConnected=!1,this._quiet||console.info("WebSocket disconnected"))})),this.provider.on("sync",(t=>{t&&!this._quiet&&console.info("WebSocket synced")}))}async connect(){if(!this.isConnected)return new Promise(((t,e)=>{const s=setTimeout((()=>{e(new Error("WebSocket connection timeout"))}),1e4),i=({status:e})=>{"connected"===e&&(clearTimeout(s),this.provider.off("status",i),this.isConnected=!0,t())};this.provider.on("status",i),this.provider.wsconnected&&(clearTimeout(s),this.provider.off("status",i),this.isConnected=!0,t())}))}disconnect(){this.provider&&this.provider.disconnect(),this.isConnected=!1}async reconnect(){return this.disconnect(),this.connect()}destroy(){this.provider&&this.provider.destroy(),this.isConnected=!1}}class pt{type="network";provider;isConnected=!1;isSynced=!1;usesSharedSocket=!1;isDestroyed=!1;connectTimeout=null;pendingConnectReject=null;connectionTimeoutMs;_connectionStatus="disconnected";visibilityHandler=null;onlineHandler=null;get awareness(){return this.provider.awareness}get connectionStatus(){return this._connectionStatus}static sharedWebSocketProvider=null;constructor(t,e,s){const i=s?.name||t,n=s?.url||"ws://localhost:1234";this.connectionTimeoutMs=s?.connectionTimeout??1e4;const o=s?.websocketProvider||pt.sharedWebSocketProvider,r={};void 0!==s?.delay&&(r.delay=s.delay),void 0!==s?.factor&&(r.factor=s.factor),void 0!==s?.maxAttempts&&(r.maxAttempts=s.maxAttempts),void 0!==s?.minDelay&&(r.minDelay=s.minDelay),void 0!==s?.maxDelay&&(r.maxDelay=s.maxDelay);const c=()=>{this.isDestroyed||(this.isConnected=!0,this._connectionStatus="connected",s?.quiet||console.info(`Hocuspocus connected: ${i}`),s?.onConnect&&s.onConnect())},h=()=>{this.isDestroyed||(this.isConnected=!1,this.isSynced=!1,this._connectionStatus="disconnected",s?.quiet||console.info(`Hocuspocus disconnected: ${i}`),s?.onDisconnect&&s.onDisconnect())},l=()=>{this.isDestroyed||(this.isSynced=!0,this._connectionStatus="synced",s?.quiet||console.info(`Hocuspocus synced: ${i}`),s?.onSynced&&s.onSynced())},d=t=>{this.isDestroyed||("connecting"===t.status&&(this._connectionStatus="connecting"),s?.onStatus&&s.onStatus(t))};if(o){this.usesSharedSocket=!0;const t={websocketProvider:o,name:i,document:e,token:s?.token||null,onStatus:d,onConnect:c,onDisconnect:h,onSynced:l,...r};void 0!==s?.forceSyncInterval&&(t.forceSyncInterval=s.forceSyncInterval),s?.onAuthenticationFailed&&(t.onAuthenticationFailed=s.onAuthenticationFailed),this.provider=new a(t),this.provider.attach(),s?.quiet||console.info(`Hocuspocus Provider initialized (multiplexed): ${i}`)}else{this.usesSharedSocket=!1;const t={url:n,name:i,document:e,token:s?.token||null,autoConnect:!1,onStatus:d,onConnect:c,onDisconnect:h,onSynced:l,...r};void 0!==s?.forceSyncInterval&&(t.forceSyncInterval=s.forceSyncInterval),s?.onAuthenticationFailed&&(t.onAuthenticationFailed=s.onAuthenticationFailed),s?.WebSocketPolyfill&&(t.WebSocketPolyfill=s.WebSocketPolyfill),this.provider=new a(t),s?.quiet||console.info(`Hocuspocus Provider initialized: ${n}/${i}`)}this.setupBrowserEventListeners()}setupBrowserEventListeners(){"undefined"!=typeof document&&(this.visibilityHandler=()=>{"visible"!==document.visibilityState||this.isConnected||this.isDestroyed||this.provider.connect()},document.addEventListener("visibilitychange",this.visibilityHandler)),"undefined"!=typeof window&&(this.onlineHandler=()=>{this.isConnected||this.isDestroyed||this.provider.connect()},window.addEventListener("online",this.onlineHandler))}removeBrowserEventListeners(){this.visibilityHandler&&"undefined"!=typeof document&&(document.removeEventListener("visibilitychange",this.visibilityHandler),this.visibilityHandler=null),this.onlineHandler&&"undefined"!=typeof window&&(window.removeEventListener("online",this.onlineHandler),this.onlineHandler=null)}static createSharedWebSocket(t){if(pt.sharedWebSocketProvider)return console.warn("Shared WebSocket already exists. Returning existing instance."),pt.sharedWebSocketProvider;const e={url:t.url};return t.WebSocketPolyfill&&(e.WebSocketPolyfill=t.WebSocketPolyfill),t.onConnect&&(e.onConnect=t.onConnect),t.onDisconnect&&(e.onDisconnect=t.onDisconnect),t.onStatus&&(e.onStatus=t.onStatus),pt.sharedWebSocketProvider=new T(e),console.info(`Shared Hocuspocus WebSocket created: ${t.url}`),pt.sharedWebSocketProvider}static destroySharedWebSocket(){pt.sharedWebSocketProvider&&(pt.sharedWebSocketProvider.destroy(),pt.sharedWebSocketProvider=null,console.info("Shared Hocuspocus WebSocket destroyed"))}static getSharedWebSocket(){return pt.sharedWebSocketProvider}static with(t){return{create:(e,s,i)=>{const n=i?{...t,...i}:t;return new pt(e,s,n)}}}async connect(){if(!this.isSynced&&!this.isDestroyed)return this._connectionStatus="connecting",new Promise(((t,e)=>{this.pendingConnectReject=e,this.connectTimeout=setTimeout((()=>{this.pendingConnectReject=null,this.connectTimeout=null,e(new Error("Hocuspocus connection timeout"))}),this.connectionTimeoutMs);const s=()=>{this.connectTimeout&&(clearTimeout(this.connectTimeout),this.connectTimeout=null),this.pendingConnectReject=null,this.provider.off("synced",s),this.isDestroyed||t()};if(this.provider.on("synced",s),this.provider.isSynced)return this.connectTimeout&&(clearTimeout(this.connectTimeout),this.connectTimeout=null),this.pendingConnectReject=null,this.provider.off("synced",s),void t();this.isConnected||this.usesSharedSocket||this.provider.connect()}))}async reconnect(){return this.disconnect(),this.connect()}disconnect(){this.connectTimeout&&(clearTimeout(this.connectTimeout),this.connectTimeout=null),this.pendingConnectReject&&(this.pendingConnectReject=null),this.provider&&(this.usesSharedSocket?this.provider.detach():this.provider.disconnect()),this.isConnected=!1,this.isSynced=!1,this._connectionStatus="disconnected"}destroy(){this.isDestroyed=!0,this.connectTimeout&&(clearTimeout(this.connectTimeout),this.connectTimeout=null),this.pendingConnectReject&&(this.pendingConnectReject=null),this.removeBrowserEventListeners(),this.provider&&this.provider.destroy(),this.isConnected=!1,this.isSynced=!1,this._connectionStatus="disconnected"}}class mt{type="remote";name="HttpAssetProvider";_options;constructor(t){this._options=t}static with(t){return{create:()=>new mt(t)}}async init(){this._options.quiet||console.info("HttpAssetProvider initialized")}destroy(){}canResolve(t){return!0}async put(t,e){const s=e.id??this.generateUuid(),i={...e,id:s},n=await(this._options.headers?.())??{},o=await this._options.uploadUrl(i),r=this._options.upload??this.defaultUpload;return{id:(await r(o,t,i,n)).id??s,kind:e.kind??"file",mimeType:e.mimeType,size:t.size,createdAt:Date.now(),width:e.width,height:e.height,durationMs:e.durationMs,originalFilename:e.originalFilename}}async resolve(t){return this._options.resolveUrl(t)}async fetch(t){const e=await this._options.resolveUrl(t),s=await(this._options.headers?.())??{},i=await fetch(e,{headers:s});if(!i.ok)throw new Error(`[HttpAssetProvider] Failed to fetch asset ${t}: ${i.status} ${i.statusText}`);return i.blob()}async delete(t){if(!this._options.deleteUrl)return;const e=await this._options.deleteUrl(t),s=await(this._options.headers?.())??{},i=await fetch(e,{method:"DELETE",headers:s});if(!i.ok)throw new Error(`[HttpAssetProvider] Failed to delete asset ${t}: ${i.status} ${i.statusText}`);this._options.quiet||console.info(`HttpAssetProvider: deleted asset ${t}`)}defaultUpload=async(t,e,s,i)=>{const n=new FormData;n.append("metadata",JSON.stringify(s)),n.append("file",e,s.originalFilename||`${s.id}.${this.extensionFromMime(s.mimeType)}`);const o=await fetch(t,{method:"POST",headers:i,body:n});if(!o.ok)throw new Error(`[HttpAssetProvider] Upload failed: ${o.status} ${o.statusText}`);return(o.headers.get("content-type")||"").includes("application/json")?await o.json():{}};extensionFromMime(t){const e=t.indexOf("/");return e>=0?t.slice(e+1):"bin"}generateUuid(){if("undefined"!=typeof crypto&&"function"==typeof crypto.randomUUID)return crypto.randomUUID();const t=crypto.getRandomValues(new Uint8Array(16));t[6]=15&t[6]|64,t[8]=63&t[8]|128;const e=Array.from(t,(t=>t.toString(16).padStart(2,"0"))).join("");return`${e.slice(0,8)}-${e.slice(8,12)}-${e.slice(12,16)}-${e.slice(16,20)}-${e.slice(20)}`}}class ft{type="remote";name="PresignedAssetProvider";_options;constructor(t){this._options=t}static with(t){return{create:()=>new ft(t)}}async init(){this._options.quiet||console.info("PresignedAssetProvider initialized")}destroy(){}canResolve(t){return!0}async put(t,e){const s=await this._options.getUploadDescriptor(e),i=s.method??"PUT",n={...s.headers??{}};let o;if(n["Content-Type"]||n["content-type"]||(n["Content-Type"]=e.mimeType),"POST"===i&&s.fields){const e=new FormData;for(const[t,i]of Object.entries(s.fields))e.append(t,i);e.append("file",t),o=e,delete n["Content-Type"],delete n["content-type"]}else o=t;const r=await fetch(s.url,{method:i,headers:n,body:o});if(!r.ok)throw new Error(`[PresignedAssetProvider] Upload failed: ${r.status} ${r.statusText}`);return{id:s.id,kind:e.kind??"file",mimeType:e.mimeType,size:t.size,createdAt:Date.now(),width:e.width,height:e.height,durationMs:e.durationMs,originalFilename:e.originalFilename}}async resolve(t){return this._options.getDownloadUrl(t)}async fetch(t){const e=await this._options.getDownloadUrl(t),s=await fetch(e);if(!s.ok)throw new Error(`[PresignedAssetProvider] Failed to fetch asset ${t}: ${s.status} ${s.statusText}`);return s.blob()}async delete(t){this._options.deleteAsset&&(await this._options.deleteAsset(t),this._options.quiet||console.info(`PresignedAssetProvider: deleted asset ${t}`))}}export{lt as BroadcastSyncProvider,pt as HocuspocusSyncProvider,mt as HttpAssetProvider,ut as InMemorySyncProvider,yt as IndexedDBSyncProvider,ft as PresignedAssetProvider,wt as WebSocketSyncProvider}
+import { H as HocuspocusProvider, a as HocuspocusProviderWebsocket } from './p-uC7_X6yr.js';
+export { O as APP_STATE_MIGRATIONS, A as AssetNotFoundError, Q as CURRENT_APP_STATE_SCHEMA_VERSION, R as CURRENT_WORKSPACE_SCHEMA_VERSION, C as DEFAULT_ASSET_STORAGE_CONFIG, D as DEFAULT_BRUSH_CONFIG, B as DEFAULT_LINE_TOOL_CONFIG, z as DEFAULT_TEXT_CONFIG, J as DE_LOCALE, G as EN_LOCALE, L as FR_LOCALE, I as IndexedDBAssetProvider, M as KritzelAlignment, t as KritzelAnchorManager, r as KritzelAssetResolver, K as KritzelBaseObject, i as KritzelBaseTool, j as KritzelBrushTool, p as KritzelCursorHelper, h as KritzelCustomElement, x as KritzelCustomElementRendererRegistry, l as KritzelEraserTool, y as KritzelFontRegistry, f as KritzelGroup, d as KritzelImage, m as KritzelImageTool, w as KritzelLicenseManager, e as KritzelLine, k as KritzelLineTool, v as KritzelLocalizationManager, c as KritzelPath, q as KritzelSelectionTool, g as KritzelShape, o as KritzelShapeTool, b as KritzelText, n as KritzelTextTool, u as KritzelThemeManager, s as KritzelWorkspace, S as ShapeType, W as WORKSPACE_EXPORT_VERSION, P as WORKSPACE_MIGRATIONS, F as darkTheme, E as lightTheme, N as runMigrations } from './p-uC7_X6yr.js';
+import * as Y from 'yjs';
+import { IndexeddbPersistence } from 'y-indexeddb';
+import { WebsocketProvider } from 'y-websocket';
+
+/**
+ * Common Math expressions.
+ *
+ * @module math
+ */
+
+const floor = Math.floor;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
+ */
+const max = (a, b) => a > b ? a : b;
+
+/* eslint-env browser */
+
+const BIT8 = 128;
+const BITS7 = 127;
+
+/**
+ * Utility helpers for working with numbers.
+ *
+ * @module number
+ */
+
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+/**
+ * Efficient schema-less binary encoding with support for variable length encoding.
+ *
+ * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module encoding
+ */
+
+
+/**
+ * A BinaryEncoder handles the encoding to an Uint8Array.
+ */
+class Encoder {
+  constructor () {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    /**
+     * @type {Array<Uint8Array>}
+     */
+    this.bufs = [];
+  }
+}
+
+/**
+ * @function
+ * @return {Encoder}
+ */
+const createEncoder = () => new Encoder();
+
+/**
+ * The current length of the encoded data.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {number}
+ */
+const length = encoder => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len
+};
+
+/**
+ * Transform to Uint8Array.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
+ */
+const toUint8Array = encoder => {
+  const uint8arr = new Uint8Array(length(encoder));
+  let curPos = 0;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    const d = encoder.bufs[i];
+    uint8arr.set(d, curPos);
+    curPos += d.length;
+  }
+  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+  return uint8arr
+};
+
+/**
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
+ */
+const write = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+
+/**
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
+ */
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | (BITS7 & num));
+    num = floor(num / 128); // shift >>> 7
+  }
+  write(encoder, BITS7 & num);
+};
+
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    // Still something to write, write right half..
+    // Append new buffer
+    encoder.bufs.push(encoder.cbuf);
+    // must have at least size of remaining buffer
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+
+/**
+ * Append an Uint8Array to Encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
+const create = s => new Error(s);
+
+/**
+ * Efficient schema-less binary decoding with support for variable length encoding.
+ *
+ * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ *
+ * @module decoding
+ */
+
+
+const errorUnexpectedEndOfArray = create('Unexpected end of array');
+const errorIntegerOutOfRange = create('Integer out of Range');
+
+/**
+ * A Decoder handles the decoding of an Uint8Array.
+ * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
+ */
+class Decoder {
+  /**
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   */
+  constructor (uint8Array) {
+    /**
+     * Decoding target.
+     *
+     * @type {Uint8Array<Buf>}
+     */
+    this.arr = uint8Array;
+    /**
+     * Current decoding position.
+     *
+     * @type {number}
+     */
+    this.pos = 0;
+  }
+}
+
+/**
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Uint8Array<Buf>} uint8Array
+ * @return {Decoder<Buf>}
+ */
+const createDecoder = uint8Array => new Decoder(uint8Array);
+
+/**
+ * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder The decoder instance
+ * @param {number} len The length of bytes to read
+ * @return {Uint8Array<Buf>}
+ */
+const readUint8Array = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view
+};
+
+/**
+ * Read variable length Uint8Array.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder
+ * @return {Uint8Array<Buf>}
+ */
+const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
+
+/**
+ * Read unsigned integer (32bit) with variable length.
+ * 1/8th of the storage is used as encoding overhead.
+ *  * numbers < 2^7 is stored in one bytlength
+ *  * numbers < 2^14 is stored in two bylength
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {number} An unsigned integer.length
+ */
+const readVarUint = decoder => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r = decoder.arr[decoder.pos++];
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
+    mult *= 128; // next iteration, shift 7 "more" to the left
+    if (r < BIT8) {
+      return num
+    }
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange
+    }
+    /* c8 ignore stop */
+  }
+  throw errorUnexpectedEndOfArray
+};
+
+/**
+ * BroadcastChannel sync provider for cross-tab synchronization
+ * This is a lightweight alternative to y-webrtc for browser-tab-only sync
+ */
+class BroadcastSyncProvider {
+    type = 'local';
+    doc;
+    channel;
+    _synced = false;
+    constructor(docName, doc, _options) {
+        this.doc = doc;
+        this.channel = new BroadcastChannel(docName);
+        // Handle incoming messages from other tabs
+        this.channel.onmessage = (event) => {
+            this.handleMessage(event.data);
+        };
+        // Listen to document updates and broadcast them
+        this.doc.on('update', this.handleDocUpdate);
+        // Send initial sync request
+        this.broadcastSync();
+        // Mark as synced after a short delay (to receive any pending updates)
+        setTimeout(() => {
+            this._synced = true;
+        }, 100);
+        if (!_options?.quiet) {
+            console.info(`BroadcastChannel Provider initialized: ${docName}`);
+        }
+    }
+    handleDocUpdate = (update, origin) => {
+        // Don't broadcast updates that came from other tabs (to prevent loops)
+        if (origin !== this) {
+            const encoder = createEncoder();
+            writeVarUint(encoder, 0); // Message type: sync update
+            writeVarUint8Array(encoder, update);
+            this.channel.postMessage(toUint8Array(encoder));
+        }
+    };
+    handleMessage(message) {
+        const decoder = createDecoder(new Uint8Array(message));
+        const messageType = readVarUint(decoder);
+        switch (messageType) {
+            case 0: // Sync update
+                const update = readVarUint8Array(decoder);
+                Y.applyUpdate(this.doc, update, this);
+                break;
+            case 1: // Sync request
+                this.broadcastSync();
+                break;
+            case 2: // Sync response
+                const stateVector = readVarUint8Array(decoder);
+                const updateResponse = Y.encodeStateAsUpdate(this.doc, stateVector);
+                if (updateResponse.length > 0) {
+                    const encoder = createEncoder();
+                    writeVarUint(encoder, 0); // Send as regular update
+                    writeVarUint8Array(encoder, updateResponse);
+                    this.channel.postMessage(toUint8Array(encoder));
+                }
+                break;
+        }
+    }
+    broadcastSync() {
+        // Broadcast our current state vector to request missing updates
+        const encoder = createEncoder();
+        writeVarUint(encoder, 2); // Message type: sync response
+        writeVarUint8Array(encoder, Y.encodeStateVector(this.doc));
+        this.channel.postMessage(toUint8Array(encoder));
+    }
+    async connect() {
+        // Wait for initial sync to complete
+        if (this._synced) {
+            return;
+        }
+        return new Promise((resolve) => {
+            const checkSync = () => {
+                if (this._synced) {
+                    resolve();
+                }
+                else {
+                    setTimeout(checkSync, 50);
+                }
+            };
+            checkSync();
+        });
+    }
+    disconnect() {
+        // BroadcastChannel doesn't have explicit disconnect
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        this.doc.off('update', this.handleDocUpdate);
+        this.channel.close();
+    }
+}
+
+/**
+ * Module-scoped cache that survives component removal and remounting
+ * within the same JS runtime. Cleared on page reload.
+ */
+const sessionCache = new Map();
+/**
+ * In-memory sync provider for session-scoped persistence.
+ *
+ * State survives the component being removed from the DOM and later
+ * re-added within the same page session, but is lost on page reload.
+ * Intended for documentation demos where durable IndexedDB persistence
+ * is not desired.
+ */
+class InMemorySyncProvider {
+    type = 'local';
+    doc;
+    cacheKey;
+    isConnected = false;
+    constructor(docName, doc, options) {
+        this.doc = doc;
+        this.cacheKey = options?.name ?? docName;
+    }
+    handleUpdate = (_update, origin) => {
+        // Skip updates that originated from connect() rehydration to avoid a
+        // redundant re-encode of the state we just applied.
+        if (origin === this) {
+            return;
+        }
+        sessionCache.set(this.cacheKey, Y.encodeStateAsUpdate(this.doc));
+    };
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        const cached = sessionCache.get(this.cacheKey);
+        if (cached) {
+            Y.applyUpdate(this.doc, cached, this);
+        }
+        this.doc.on('update', this.handleUpdate);
+        this.isConnected = true;
+    }
+    disconnect() {
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        this.doc.off('update', this.handleUpdate);
+        this.isConnected = false;
+    }
+    /**
+     * Clears the in-memory cache.
+     *
+     * @param name - If provided, only the entry with this cache key is removed.
+     *               If omitted, all entries are cleared.
+     */
+    static clear(name) {
+        if (name !== undefined) {
+            sessionCache.delete(name);
+        }
+        else {
+            sessionCache.clear();
+        }
+    }
+}
+
+/**
+ * IndexedDB sync provider for local persistence
+ */
+class IndexedDBSyncProvider {
+    type = 'local';
+    provider;
+    isConnected = false;
+    constructor(docName, doc, options) {
+        const dbName = options?.name || docName;
+        this.provider = new IndexeddbPersistence(dbName, doc);
+    }
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.provider.on('synced', () => {
+                this.isConnected = true;
+                resolve();
+            });
+        });
+    }
+    disconnect() {
+        // IndexedDB doesn't need explicit disconnect
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+    }
+}
+
+/**
+ * WebSocket sync provider for real-time collaboration
+ */
+class WebSocketSyncProvider {
+    type = 'network';
+    provider;
+    isConnected = false;
+    _quiet = false;
+    get awareness() {
+        return this.provider.awareness;
+    }
+    constructor(docName, doc, options) {
+        const url = options?.url || 'ws://localhost:1234';
+        const roomName = options?.roomName || docName;
+        this.provider = new WebsocketProvider(url, roomName, doc, {
+            params: options?.params,
+            protocols: options?.protocols,
+            WebSocketPolyfill: options?.WebSocketPolyfill,
+            awareness: options?.awareness,
+            maxBackoffTime: options?.maxBackoffTime,
+            disableBc: true,
+        });
+        this._quiet = options?.quiet ?? false;
+        this.setupEventListeners();
+        if (!this._quiet) {
+            console.info(`WebSocket Provider initialized: ${url}/${roomName}`);
+        }
+    }
+    /**
+     * Static factory method for creating WebSocketSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options) {
+        return {
+            create: (docName, doc, runtimeOptions) => {
+                const mergedOptions = runtimeOptions ? { ...options, ...runtimeOptions } : options;
+                return new WebSocketSyncProvider(docName, doc, mergedOptions);
+            },
+        };
+    }
+    setupEventListeners() {
+        this.provider.on('status', ({ status }) => {
+            if (status === 'connected') {
+                this.isConnected = true;
+                if (!this._quiet) {
+                    console.info('WebSocket connected');
+                }
+            }
+            else if (status === 'disconnected') {
+                this.isConnected = false;
+                if (!this._quiet) {
+                    console.info('WebSocket disconnected');
+                }
+            }
+        });
+        this.provider.on('sync', (synced) => {
+            if (synced && !this._quiet) {
+                console.info('WebSocket synced');
+            }
+        });
+    }
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('WebSocket connection timeout'));
+            }, 10000); // 10 second timeout
+            const statusHandler = ({ status }) => {
+                if (status === 'connected') {
+                    clearTimeout(timeout);
+                    this.provider.off('status', statusHandler);
+                    this.isConnected = true;
+                    resolve();
+                }
+            };
+            this.provider.on('status', statusHandler);
+            // If already connected, resolve immediately
+            if (this.provider.wsconnected) {
+                clearTimeout(timeout);
+                this.provider.off('status', statusHandler);
+                this.isConnected = true;
+                resolve();
+            }
+        });
+    }
+    disconnect() {
+        if (this.provider) {
+            this.provider.disconnect();
+        }
+        this.isConnected = false;
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    destroy() {
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+    }
+}
+
+/**
+ * Hocuspocus sync provider for real-time collaboration
+ * Supports multiplexing - multiple documents can share the same WebSocket connection
+ */
+class HocuspocusSyncProvider {
+    type = 'network';
+    provider;
+    isConnected = false;
+    isSynced = false;
+    usesSharedSocket = false;
+    isDestroyed = false;
+    connectTimeout = null;
+    pendingConnectReject = null;
+    connectionTimeoutMs;
+    _connectionStatus = 'disconnected';
+    visibilityHandler = null;
+    onlineHandler = null;
+    get awareness() {
+        return this.provider.awareness;
+    }
+    get connectionStatus() {
+        return this._connectionStatus;
+    }
+    // Static shared WebSocket instance for multiplexing
+    static sharedWebSocketProvider = null;
+    constructor(docName, doc, options) {
+        const name = options?.name || docName;
+        const url = options?.url || 'ws://localhost:1234';
+        this.connectionTimeoutMs = options?.connectionTimeout ?? 10000;
+        // Use provided websocketProvider or the static shared one
+        const websocketProvider = options?.websocketProvider || HocuspocusSyncProvider.sharedWebSocketProvider;
+        // Build reconnect config from options
+        const reconnectConfig = {};
+        if (options?.delay !== undefined)
+            reconnectConfig.delay = options.delay;
+        if (options?.factor !== undefined)
+            reconnectConfig.factor = options.factor;
+        if (options?.maxAttempts !== undefined)
+            reconnectConfig.maxAttempts = options.maxAttempts;
+        if (options?.minDelay !== undefined)
+            reconnectConfig.minDelay = options.minDelay;
+        if (options?.maxDelay !== undefined)
+            reconnectConfig.maxDelay = options.maxDelay;
+        const onConnect = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isConnected = true;
+            this._connectionStatus = 'connected';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus connected: ${name}`);
+            }
+            if (options?.onConnect) {
+                options.onConnect();
+            }
+        };
+        const onDisconnect = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isConnected = false;
+            this.isSynced = false;
+            this._connectionStatus = 'disconnected';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus disconnected: ${name}`);
+            }
+            if (options?.onDisconnect) {
+                options.onDisconnect();
+            }
+        };
+        const onSynced = () => {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.isSynced = true;
+            this._connectionStatus = 'synced';
+            if (!options?.quiet) {
+                console.info(`Hocuspocus synced: ${name}`);
+            }
+            if (options?.onSynced) {
+                options.onSynced();
+            }
+        };
+        const onStatus = (data) => {
+            if (this.isDestroyed) {
+                return;
+            }
+            if (data.status === 'connecting') {
+                this._connectionStatus = 'connecting';
+            }
+            if (options?.onStatus) {
+                options.onStatus(data);
+            }
+        };
+        if (websocketProvider) {
+            // Multiplexing mode - use shared WebSocket connection
+            this.usesSharedSocket = true;
+            const config = {
+                websocketProvider,
+                name,
+                document: doc,
+                token: options?.token || null,
+                onStatus,
+                onConnect,
+                onDisconnect,
+                onSynced,
+                ...reconnectConfig,
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            this.provider = new HocuspocusProvider(config);
+            // Must call attach() explicitly when using shared socket
+            this.provider.attach();
+            if (!options?.quiet) {
+                console.info(`Hocuspocus Provider initialized (multiplexed): ${name}`);
+            }
+        }
+        else {
+            // Standalone mode - create own WebSocket connection
+            this.usesSharedSocket = false;
+            const config = {
+                url,
+                name,
+                document: doc,
+                token: options?.token || null,
+                autoConnect: false,
+                onStatus,
+                onConnect,
+                onDisconnect,
+                onSynced,
+                ...reconnectConfig,
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            if (options?.WebSocketPolyfill) {
+                config.WebSocketPolyfill = options.WebSocketPolyfill;
+            }
+            this.provider = new HocuspocusProvider(config);
+            if (!options?.quiet) {
+                console.info(`Hocuspocus Provider initialized: ${url}/${name}`);
+            }
+        }
+        this.setupBrowserEventListeners();
+    }
+    setupBrowserEventListeners() {
+        if (typeof document !== 'undefined') {
+            this.visibilityHandler = () => {
+                if (document.visibilityState === 'visible' && !this.isConnected && !this.isDestroyed) {
+                    this.provider.connect();
+                }
+            };
+            document.addEventListener('visibilitychange', this.visibilityHandler);
+        }
+        if (typeof window !== 'undefined') {
+            this.onlineHandler = () => {
+                if (!this.isConnected && !this.isDestroyed) {
+                    this.provider.connect();
+                }
+            };
+            window.addEventListener('online', this.onlineHandler);
+        }
+    }
+    removeBrowserEventListeners() {
+        if (this.visibilityHandler && typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.visibilityHandler);
+            this.visibilityHandler = null;
+        }
+        if (this.onlineHandler && typeof window !== 'undefined') {
+            window.removeEventListener('online', this.onlineHandler);
+            this.onlineHandler = null;
+        }
+    }
+    /**
+     * Create a shared WebSocket connection for multiplexing
+     * Call this once to create a shared connection that multiple providers can use
+     */
+    static createSharedWebSocket(options) {
+        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
+            console.warn('Shared WebSocket already exists. Returning existing instance.');
+            return HocuspocusSyncProvider.sharedWebSocketProvider;
+        }
+        const config = {
+            url: options.url,
+        };
+        if (options.WebSocketPolyfill) {
+            config.WebSocketPolyfill = options.WebSocketPolyfill;
+        }
+        if (options.onConnect) {
+            config.onConnect = options.onConnect;
+        }
+        if (options.onDisconnect) {
+            config.onDisconnect = options.onDisconnect;
+        }
+        if (options.onStatus) {
+            config.onStatus = options.onStatus;
+        }
+        HocuspocusSyncProvider.sharedWebSocketProvider = new HocuspocusProviderWebsocket(config);
+        console.info(`Shared Hocuspocus WebSocket created: ${options.url}`);
+        return HocuspocusSyncProvider.sharedWebSocketProvider;
+    }
+    /**
+     * Destroy the shared WebSocket connection
+     * Call this when you're done with all multiplexed providers
+     */
+    static destroySharedWebSocket() {
+        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
+            HocuspocusSyncProvider.sharedWebSocketProvider.destroy();
+            HocuspocusSyncProvider.sharedWebSocketProvider = null;
+            console.info('Shared Hocuspocus WebSocket destroyed');
+        }
+    }
+    /**
+     * Get the shared WebSocket provider instance (if it exists)
+     */
+    static getSharedWebSocket() {
+        return HocuspocusSyncProvider.sharedWebSocketProvider;
+    }
+    /**
+     * Static factory method for creating HocuspocusSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options) {
+        return {
+            create: (docName, doc, runtimeOptions) => {
+                const mergedOptions = runtimeOptions ? { ...options, ...runtimeOptions } : options;
+                return new HocuspocusSyncProvider(docName, doc, mergedOptions);
+            },
+        };
+    }
+    async connect() {
+        if (this.isSynced || this.isDestroyed) {
+            return;
+        }
+        this._connectionStatus = 'connecting';
+        return new Promise((resolve, reject) => {
+            // Store reject function so we can cancel the connection if destroyed
+            this.pendingConnectReject = reject;
+            this.connectTimeout = setTimeout(() => {
+                this.pendingConnectReject = null;
+                this.connectTimeout = null;
+                reject(new Error('Hocuspocus connection timeout'));
+            }, this.connectionTimeoutMs);
+            const syncHandler = () => {
+                if (this.connectTimeout) {
+                    clearTimeout(this.connectTimeout);
+                    this.connectTimeout = null;
+                }
+                this.pendingConnectReject = null;
+                this.provider.off('synced', syncHandler);
+                if (!this.isDestroyed) {
+                    resolve();
+                }
+            };
+            this.provider.on('synced', syncHandler);
+            // If already synced, resolve immediately
+            if (this.provider.isSynced) {
+                if (this.connectTimeout) {
+                    clearTimeout(this.connectTimeout);
+                    this.connectTimeout = null;
+                }
+                this.pendingConnectReject = null;
+                this.provider.off('synced', syncHandler);
+                resolve();
+                return;
+            }
+            // Connect if not already connected (standalone mode only)
+            if (!this.isConnected && !this.usesSharedSocket) {
+                this.provider.connect();
+            }
+        });
+    }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
+    disconnect() {
+        // Cancel any pending connection attempt
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = null;
+        }
+        if (this.pendingConnectReject) {
+            this.pendingConnectReject = null; // Don't reject, just abandon the promise
+        }
+        if (this.provider) {
+            if (this.usesSharedSocket) {
+                // Detach from shared socket instead of disconnecting
+                this.provider.detach();
+            }
+            else {
+                this.provider.disconnect();
+            }
+        }
+        this.isConnected = false;
+        this.isSynced = false;
+        this._connectionStatus = 'disconnected';
+    }
+    destroy() {
+        // Mark as destroyed first to prevent any callbacks from doing work
+        this.isDestroyed = true;
+        // Cancel any pending connection attempt
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = null;
+        }
+        if (this.pendingConnectReject) {
+            this.pendingConnectReject = null; // Don't reject, just abandon the promise
+        }
+        this.removeBrowserEventListeners();
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+        this.isSynced = false;
+        this._connectionStatus = 'disconnected';
+    }
+}
+
+/**
+ * Remote asset storage provider backed by a plain HTTP endpoint.
+ *
+ * The host application is responsible for exposing a REST-ish backend
+ * that accepts a multipart upload and serves the stored asset at a
+ * stable URL. Authentication is injected via `headers`.
+ */
+class HttpAssetProvider {
+    type = 'remote';
+    name = 'HttpAssetProvider';
+    _options;
+    constructor(options) {
+        this._options = options;
+    }
+    /**
+     * Factory helper enabling use as `HttpAssetProvider.with({ ... })` inside
+     * a `KritzelAssetStorageConfig.providers` array.
+     */
+    static with(options) {
+        return { create: () => new HttpAssetProvider(options) };
+    }
+    async init() {
+        if (!this._options.quiet) {
+            console.info('HttpAssetProvider initialized');
+        }
+    }
+    destroy() {
+        // No-op; no resources to release.
+    }
+    canResolve(_id) {
+        // Remote providers don't know without a round-trip; assume yes.
+        return true;
+    }
+    async put(blob, metadata) {
+        const id = metadata.id ?? this.generateUuid();
+        const fullMetadata = { ...metadata, id };
+        const headers = (await this._options.headers?.()) ?? {};
+        const url = await this._options.uploadUrl(fullMetadata);
+        const uploader = this._options.upload ?? this.defaultUpload;
+        const response = await uploader(url, blob, fullMetadata, headers);
+        return {
+            id: response.id ?? id,
+            kind: metadata.kind ?? 'file',
+            mimeType: metadata.mimeType,
+            size: blob.size,
+            createdAt: Date.now(),
+            width: metadata.width,
+            height: metadata.height,
+            durationMs: metadata.durationMs,
+            originalFilename: metadata.originalFilename,
+        };
+    }
+    async resolve(id) {
+        return this._options.resolveUrl(id);
+    }
+    async fetch(id) {
+        const url = await this._options.resolveUrl(id);
+        const headers = (await this._options.headers?.()) ?? {};
+        const res = await fetch(url, { headers });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Failed to fetch asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        return res.blob();
+    }
+    async delete(id) {
+        if (!this._options.deleteUrl)
+            return;
+        const url = await this._options.deleteUrl(id);
+        const headers = (await this._options.headers?.()) ?? {};
+        const res = await fetch(url, { method: 'DELETE', headers });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Failed to delete asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        if (!this._options.quiet) {
+            console.info(`HttpAssetProvider: deleted asset ${id}`);
+        }
+    }
+    defaultUpload = async (url, blob, metadata, headers) => {
+        const form = new FormData();
+        form.append('metadata', JSON.stringify(metadata));
+        form.append('file', blob, metadata.originalFilename || `${metadata.id}.${this.extensionFromMime(metadata.mimeType)}`);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: form,
+        });
+        if (!res.ok) {
+            throw new Error(`[HttpAssetProvider] Upload failed: ${res.status} ${res.statusText}`);
+        }
+        // Try to parse a JSON response; tolerate empty/plain-text bodies.
+        const contentType = res.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            return (await res.json());
+        }
+        return {};
+    };
+    extensionFromMime(mime) {
+        const slash = mime.indexOf('/');
+        return slash >= 0 ? mime.slice(slash + 1) : 'bin';
+    }
+    generateUuid() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        const bytes = crypto.getRandomValues(new Uint8Array(16));
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+}
+
+/**
+ * Remote asset storage provider for pre-signed URL uploads (S3, GCS, ...).
+ *
+ * All auth and URL signing is performed by the host application via the
+ * callbacks in {@link PresignedAssetProviderOptions}. The library simply
+ * PUTs/POSTs bytes to the provided URL.
+ */
+class PresignedAssetProvider {
+    type = 'remote';
+    name = 'PresignedAssetProvider';
+    _options;
+    constructor(options) {
+        this._options = options;
+    }
+    static with(options) {
+        return { create: () => new PresignedAssetProvider(options) };
+    }
+    async init() {
+        if (!this._options.quiet) {
+            console.info('PresignedAssetProvider initialized');
+        }
+    }
+    destroy() {
+        // No-op.
+    }
+    canResolve(_id) {
+        return true;
+    }
+    async put(blob, metadata) {
+        const descriptor = await this._options.getUploadDescriptor(metadata);
+        const method = descriptor.method ?? 'PUT';
+        const headers = { ...(descriptor.headers ?? {}) };
+        if (!headers['Content-Type'] && !headers['content-type']) {
+            headers['Content-Type'] = metadata.mimeType;
+        }
+        let body;
+        if (method === 'POST' && descriptor.fields) {
+            const form = new FormData();
+            for (const [key, value] of Object.entries(descriptor.fields)) {
+                form.append(key, value);
+            }
+            form.append('file', blob);
+            body = form;
+            // Browser sets multipart boundary; avoid forcing content-type.
+            delete headers['Content-Type'];
+            delete headers['content-type'];
+        }
+        else {
+            body = blob;
+        }
+        const res = await fetch(descriptor.url, { method, headers, body });
+        if (!res.ok) {
+            throw new Error(`[PresignedAssetProvider] Upload failed: ${res.status} ${res.statusText}`);
+        }
+        return {
+            id: descriptor.id,
+            kind: metadata.kind ?? 'file',
+            mimeType: metadata.mimeType,
+            size: blob.size,
+            createdAt: Date.now(),
+            width: metadata.width,
+            height: metadata.height,
+            durationMs: metadata.durationMs,
+            originalFilename: metadata.originalFilename,
+        };
+    }
+    async resolve(id) {
+        return this._options.getDownloadUrl(id);
+    }
+    async fetch(id) {
+        const url = await this._options.getDownloadUrl(id);
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`[PresignedAssetProvider] Failed to fetch asset ${id}: ${res.status} ${res.statusText}`);
+        }
+        return res.blob();
+    }
+    async delete(id) {
+        if (!this._options.deleteAsset)
+            return;
+        await this._options.deleteAsset(id);
+        if (!this._options.quiet) {
+            console.info(`PresignedAssetProvider: deleted asset ${id}`);
+        }
+    }
+}
+
+export { BroadcastSyncProvider, HocuspocusSyncProvider, HttpAssetProvider, InMemorySyncProvider, IndexedDBSyncProvider, PresignedAssetProvider, WebSocketSyncProvider };