@hocuspocus/provider 1.0.0-alpha.26 → 1.0.0-alpha.30

package/dist/hocuspocus-provider.esm.js

@@ -1,5 +1,6 @@
 import * as Y from 'yjs';
 import { retry } from '@lifeomic/attempt';
+import { readAuthMessage, writeAuthentication, Unauthorized, Forbidden } from '@hocuspocus/common';
 
 /**
  * Utility module to work with key-value stores.
@@ -277,8 +278,8 @@ const min = (a, b) => a < b ? a : b;
 const max = (a, b) => a > b ? a : b;
 
 /* eslint-env browser */
-const BIT8$1 = 128;
-const BITS7$1 = 127;
+const BIT8 = 128;
+const BITS7 = 127;
 
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
@@ -369,7 +370,7 @@ const toUint8Array = encoder => {
  * @param {Encoder} encoder
  * @param {number} num The byte that is to be encoded.
  */
-const write$1 = (encoder, num) => {
+const write = (encoder, num) => {
   const bufferLen = encoder.cbuf.length;
   if (encoder.cpos === bufferLen) {
     encoder.bufs.push(encoder.cbuf);
@@ -388,12 +389,12 @@ const write$1 = (encoder, num) => {
  * @param {Encoder} encoder
  * @param {number} num The number that is to be encoded.
  */
-const writeVarUint$1 = (encoder, num) => {
-  while (num > BITS7$1) {
-    write$1(encoder, BIT8$1 | (BITS7$1 & num));
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | (BITS7 & num));
     num >>>= 7;
   }
-  write$1(encoder, BITS7$1 & num);
+  write(encoder, BITS7 & num);
 };
 
 /**
@@ -403,12 +404,12 @@ const writeVarUint$1 = (encoder, num) => {
  * @param {Encoder} encoder
  * @param {String} str The string that is to be encoded.
  */
-const writeVarString$1 = (encoder, str) => {
+const writeVarString = (encoder, str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
-  writeVarUint$1(encoder, len);
+  writeVarUint(encoder, len);
   for (let i = 0; i < len; i++) {
-    write$1(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
   }
 };
 
@@ -446,7 +447,7 @@ const writeUint8Array = (encoder, uint8Array) => {
  * @param {Uint8Array} uint8Array
  */
 const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint$1(encoder, uint8Array.byteLength);
+  writeVarUint(encoder, uint8Array.byteLength);
   writeUint8Array(encoder, uint8Array);
 };
 
@@ -535,7 +536,7 @@ const readUint8Array = (decoder, len) => {
  * @param {Decoder} decoder
  * @return {Uint8Array}
  */
-const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint$1(decoder));
+const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
 
 /**
  * Read one byte as unsigned integer.
@@ -543,7 +544,7 @@ const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint$1(decod
  * @param {Decoder} decoder The decoder instance
  * @return {number} Unsigned 8-bit integer
  */
-const readUint8$1 = decoder => decoder.arr[decoder.pos++];
+const readUint8 = decoder => decoder.arr[decoder.pos++];
 
 /**
  * Read unsigned integer (32bit) with variable length.
@@ -555,14 +556,14 @@ const readUint8$1 = decoder => decoder.arr[decoder.pos++];
  * @param {Decoder} decoder
  * @return {number} An unsigned integer.length
  */
-const readVarUint$1 = decoder => {
+const readVarUint = decoder => {
   let num = 0;
   let len = 0;
   while (true) {
     const r = decoder.arr[decoder.pos++];
-    num = num | ((r & BITS7$1) << len);
+    num = num | ((r & BITS7) << len);
     len += 7;
-    if (r < BIT8$1) {
+    if (r < BIT8) {
       return num >>> 0 // return unsigned number!
     }
     /* istanbul ignore if */
@@ -585,15 +586,15 @@ const readVarUint$1 = decoder => {
  * @param {Decoder} decoder
  * @return {String} The read String.
  */
-const readVarString$1 = decoder => {
-  let remainingLen = readVarUint$1(decoder);
+const readVarString = decoder => {
+  let remainingLen = readVarUint(decoder);
   if (remainingLen === 0) {
     return ''
   } else {
-    let encodedString = String.fromCodePoint(readUint8$1(decoder)); // remember to decrease remainingLen
+    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
     if (--remainingLen < 100) { // do not create a Uint8Array for small strings
       while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8$1(decoder));
+        encodedString += String.fromCodePoint(readUint8(decoder));
       }
     } else {
       while (remainingLen > 0) {
@@ -1206,14 +1207,14 @@ const removeAwarenessStates = (awareness, clients, origin) => {
 const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
   const len = clients.length;
   const encoder = createEncoder();
-  writeVarUint$1(encoder, len);
+  writeVarUint(encoder, len);
   for (let i = 0; i < len; i++) {
     const clientID = clients[i];
     const state = states.get(clientID) || null;
     const clock = /** @type {MetaClientState} */ (awareness.meta.get(clientID)).clock;
-    writeVarUint$1(encoder, clientID);
-    writeVarUint$1(encoder, clock);
-    writeVarString$1(encoder, JSON.stringify(state));
+    writeVarUint(encoder, clientID);
+    writeVarUint(encoder, clock);
+    writeVarString(encoder, JSON.stringify(state));
   }
   return toUint8Array(encoder)
 };
@@ -1230,11 +1231,11 @@ const applyAwarenessUpdate = (awareness, update, origin) => {
   const updated = [];
   const filteredUpdated = [];
   const removed = [];
-  const len = readVarUint$1(decoder);
+  const len = readVarUint(decoder);
   for (let i = 0; i < len; i++) {
-    const clientID = readVarUint$1(decoder);
-    let clock = readVarUint$1(decoder);
-    const state = JSON.parse(readVarString$1(decoder));
+    const clientID = readVarUint(decoder);
+    let clock = readVarUint(decoder);
+    const state = JSON.parse(readVarString(decoder));
     const clientMeta = awareness.meta.get(clientID);
     const prevState = awareness.states.get(clientID);
     const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
@@ -1378,13 +1379,13 @@ class IncomingMessage {
         this.decoder = createDecoder(new Uint8Array(this.data));
     }
     readVarUint() {
-        return readVarUint$1(this.decoder);
+        return readVarUint(this.decoder);
     }
     readVarUint8Array() {
         return readVarUint8Array(this.decoder);
     }
     writeVarUint(type) {
-        return writeVarUint$1(this.encoder, type);
+        return writeVarUint(this.encoder, type);
     }
     writeVarUint8Array(data) {
         return writeVarUint8Array(this.encoder, data);
@@ -1438,7 +1439,7 @@ const messageYjsUpdate = 2;
  * @param {Y.Doc} doc
  */
 const writeSyncStep1 = (encoder, doc) => {
-  writeVarUint$1(encoder, messageYjsSyncStep1);
+  writeVarUint(encoder, messageYjsSyncStep1);
   const sv = Y.encodeStateVector(doc);
   writeVarUint8Array(encoder, sv);
 };
@@ -1449,7 +1450,7 @@ const writeSyncStep1 = (encoder, doc) => {
  * @param {Uint8Array} [encodedStateVector]
  */
 const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
-  writeVarUint$1(encoder, messageYjsSyncStep2);
+  writeVarUint(encoder, messageYjsSyncStep2);
   writeVarUint8Array(encoder, Y.encodeStateAsUpdate(doc, encodedStateVector));
 };
 
@@ -1484,7 +1485,7 @@ const readSyncStep2 = (decoder, doc, transactionOrigin) => {
  * @param {Uint8Array} update
  */
 const writeUpdate = (encoder, update) => {
-  writeVarUint$1(encoder, messageYjsUpdate);
+  writeVarUint(encoder, messageYjsUpdate);
   writeVarUint8Array(encoder, update);
 };
 
@@ -1504,7 +1505,7 @@ const readUpdate = readSyncStep2;
  * @param {any} transactionOrigin
  */
 const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
-  const messageType = readVarUint$1(decoder);
+  const messageType = readVarUint(decoder);
   switch (messageType) {
     case messageYjsSyncStep1:
       readSyncStep1(decoder, encoder, doc);
@@ -1521,239 +1522,6 @@ const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
   return messageType
 };
 
-/* eslint-env browser */
-const BIT8 = 128;
-const BITS7 = 127;
-/**
- * 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 = new encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = new decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module decoding
- */
-
-/**
- * Read one byte as unsigned integer.
- * @function
- * @param {Decoder} decoder The decoder instance
- * @return {number} Unsigned 8-bit integer
- */
-
-const readUint8 = decoder => decoder.arr[decoder.pos++];
-/**
- * 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 len = 0;
-
-  while (true) {
-    const r = decoder.arr[decoder.pos++];
-    num = num | (r & BITS7) << len;
-    len += 7;
-
-    if (r < BIT8) {
-      return num >>> 0; // return unsigned number!
-    }
-    /* istanbul ignore if */
-
-
-    if (len > 35) {
-      throw new Error('Integer out of range!');
-    }
-  }
-};
-/**
- * Read string of variable length
- * * varUint is used to store the length of the string
- *
- * Transforming utf8 to a string is pretty expensive. The code performs 10x better
- * when String.fromCodePoint is fed with all characters as arguments.
- * But most environments have a maximum number of arguments per functions.
- * For effiency reasons we apply a maximum of 10000 characters at once.
- *
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String.
- */
-
-
-const readVarString = decoder => {
-  let remainingLen = readVarUint(decoder);
-
-  if (remainingLen === 0) {
-    return '';
-  } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
-
-    if (--remainingLen < 100) {
-      // do not create a Uint8Array for small strings
-      while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8(decoder));
-      }
-    } else {
-      while (remainingLen > 0) {
-        const nextLen = remainingLen < 10000 ? remainingLen : 10000; // this is dangerous, we create a fresh array view from the existing buffer
-
-        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
-        decoder.pos += nextLen; // Starting with ES5.1 we can supply a generic array-like object as arguments
-
-        encodedString += String.fromCodePoint.apply(null,
-        /** @type {any} */
-        bytes);
-        remainingLen -= nextLen;
-      }
-    }
-
-    return decodeURIComponent(escape(encodedString));
-  }
-};
-/**
- * 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 = new encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = new decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module encoding
- */
-
-/**
- * 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.
- *
- * Encodes integers in the range from [0, 4294967295] / [0, 0xffffffff]. (max 32 bit unsigned integer)
- *
- * @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 >>>= 7;
-  }
-
-  write(encoder, BITS7 & num);
-};
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-
-
-const writeVarString = (encoder, str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  writeVarUint(encoder, len);
-
-  for (let i = 0; i < len; i++) {
-    write(encoder,
-    /** @type {number} */
-    encodedString.codePointAt(i));
-  }
-};
-
-var AuthMessageType;
-
-(function (AuthMessageType) {
-  AuthMessageType[AuthMessageType["Token"] = 0] = "Token";
-  AuthMessageType[AuthMessageType["PermissionDenied"] = 1] = "PermissionDenied";
-  AuthMessageType[AuthMessageType["Authenticated"] = 2] = "Authenticated";
-})(AuthMessageType || (AuthMessageType = {}));
-
-const writeAuthentication = (encoder, auth) => {
-  writeVarUint(encoder, AuthMessageType.Token);
-  writeVarString(encoder, auth);
-};
-
-const readAuthMessage = (decoder, permissionDeniedHandler, authenticatedHandler) => {
-  switch (readVarUint(decoder)) {
-    case AuthMessageType.PermissionDenied:
-      {
-        permissionDeniedHandler(readVarString(decoder));
-        break;
-      }
-
-    case AuthMessageType.Authenticated:
-      {
-        authenticatedHandler();
-        break;
-      }
-  }
-};
-
 var MessageType;
 (function (MessageType) {
     MessageType[MessageType["Sync"] = 0] = "Sync";
@@ -1867,7 +1635,7 @@ class SyncStepOneMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step one message requires document as an argument');
         }
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         writeSyncStep1(this.encoder, args.document);
         return this.encoder;
     }
@@ -1883,7 +1651,7 @@ class SyncStepTwoMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step two message requires document as an argument');
         }
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         writeSyncStep2(this.encoder, args.document);
         return this.encoder;
     }
@@ -1896,7 +1664,7 @@ class QueryAwarenessMessage extends OutgoingMessage {
         this.description = 'Queries awareness states';
     }
     get(args) {
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         return this.encoder;
     }
 }
@@ -1911,7 +1679,7 @@ class AuthenticationMessage extends OutgoingMessage {
         if (typeof args.token === 'undefined') {
             throw new Error('The authentication message requires `token` as an argument.');
         }
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         writeAuthentication(this.encoder, args.token);
         return this.encoder;
     }
@@ -1930,7 +1698,7 @@ class AwarenessMessage extends OutgoingMessage {
         if (typeof args.clients === 'undefined') {
             throw new Error('The awareness message requires clients as an argument');
         }
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         let awarenessUpdate;
         if (args.states === undefined) {
             awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
@@ -1950,7 +1718,7 @@ class UpdateMessage extends OutgoingMessage {
         this.description = 'A document update';
     }
     get(args) {
-        writeVarUint$1(this.encoder, this.type);
+        writeVarUint(this.encoder, this.type);
         writeUpdate(this.encoder, args.update);
         return this.encoder;
     }
@@ -1972,16 +1740,16 @@ var WebSocketStatus;
     WebSocketStatus["Disconnected"] = "disconnected";
 })(WebSocketStatus || (WebSocketStatus = {}));
 class HocuspocusProvider extends EventEmitter {
-    constructor(options = {}) {
+    constructor(configuration) {
         super();
-        this.options = {
+        this.configuration = {
+            name: '',
+            url: '',
             // @ts-ignore
             document: undefined,
             // @ts-ignore
             awareness: undefined,
             WebSocketPolyfill: undefined,
-            url: '',
-            name: '',
             token: null,
             parameters: {},
             connect: true,
@@ -2018,6 +1786,7 @@ class HocuspocusProvider extends EventEmitter {
             onDestroy: () => null,
             onAwarenessUpdate: () => null,
             onAwarenessChange: () => null,
+            quiet: false,
         };
         this.subscribedToBroadcastChannel = false;
         this.webSocket = null;
@@ -2032,22 +1801,23 @@ class HocuspocusProvider extends EventEmitter {
             connectionChecker: null,
         };
         this.connectionAttempt = null;
-        this.setOptions(options);
-        this.options.awareness = options.awareness ? options.awareness : new Awareness(this.document);
-        this.options.WebSocketPolyfill = options.WebSocketPolyfill ? options.WebSocketPolyfill : WebSocket;
-        this.on('open', this.options.onOpen);
-        this.on('authenticated', this.options.onAuthenticated);
-        this.on('authenticationFailed', this.options.onAuthenticationFailed);
-        this.on('connect', this.options.onConnect);
-        this.on('message', this.options.onMessage);
-        this.on('outgoingMessage', this.options.onOutgoingMessage);
-        this.on('synced', this.options.onSynced);
-        this.on('status', this.options.onStatus);
-        this.on('disconnect', this.options.onDisconnect);
-        this.on('close', this.options.onClose);
-        this.on('destroy', this.options.onDestroy);
-        this.on('awarenessUpdate', this.options.onAwarenessUpdate);
-        this.on('awarenessChange', this.options.onAwarenessChange);
+        this.setConfiguration(configuration);
+        this.configuration.document = configuration.document ? configuration.document : new Y.Doc();
+        this.configuration.awareness = configuration.awareness ? configuration.awareness : new Awareness(this.document);
+        this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket;
+        this.on('open', this.configuration.onOpen);
+        this.on('authenticated', this.configuration.onAuthenticated);
+        this.on('authenticationFailed', this.configuration.onAuthenticationFailed);
+        this.on('connect', this.configuration.onConnect);
+        this.on('message', this.configuration.onMessage);
+        this.on('outgoingMessage', this.configuration.onOutgoingMessage);
+        this.on('synced', this.configuration.onSynced);
+        this.on('status', this.configuration.onStatus);
+        this.on('disconnect', this.configuration.onDisconnect);
+        this.on('close', this.configuration.onClose);
+        this.on('destroy', this.configuration.onDestroy);
+        this.on('awarenessUpdate', this.configuration.onAwarenessUpdate);
+        this.on('awarenessChange', this.configuration.onAwarenessChange);
         this.awareness.on('update', () => {
             this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) });
         });
@@ -2056,21 +1826,21 @@ class HocuspocusProvider extends EventEmitter {
         });
         this.document.on('update', this.documentUpdateHandler.bind(this));
         this.awareness.on('update', this.awarenessUpdateHandler.bind(this));
-        this.registerBeforeUnloadEventListener();
-        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.options.messageReconnectTimeout / 10);
-        if (this.options.forceSyncInterval) {
-            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.options.forceSyncInterval);
+        this.registerEventListeners();
+        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+        if (this.configuration.forceSyncInterval) {
+            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
         }
-        if (typeof options.connect !== 'undefined') {
-            this.shouldConnect = options.connect;
+        if (typeof configuration.connect !== 'undefined') {
+            this.shouldConnect = configuration.connect;
         }
         if (!this.shouldConnect) {
             return;
         }
         this.connect();
     }
-    setOptions(options = {}) {
-        this.options = { ...this.options, ...options };
+    setConfiguration(configuration = {}) {
+        this.configuration = { ...this.configuration, ...configuration };
     }
     async connect() {
         if (this.status === WebSocketStatus.Connected) {
@@ -2080,14 +1850,14 @@ class HocuspocusProvider extends EventEmitter {
         this.subscribeToBroadcastChannel();
         try {
             await retry(this.createWebSocketConnection.bind(this), {
-                delay: this.options.delay,
-                initialDelay: this.options.initialDelay,
-                factor: this.options.factor,
-                maxAttempts: this.options.maxAttempts,
-                minDelay: this.options.minDelay,
-                maxDelay: this.options.maxDelay,
-                jitter: this.options.jitter,
-                timeout: this.options.timeout,
+                delay: this.configuration.delay,
+                initialDelay: this.configuration.initialDelay,
+                factor: this.configuration.factor,
+                maxAttempts: this.configuration.maxAttempts,
+                minDelay: this.configuration.minDelay,
+                maxDelay: this.configuration.maxDelay,
+                jitter: this.configuration.jitter,
+                timeout: this.configuration.timeout,
                 beforeAttempt: context => {
                     if (!this.shouldConnect) {
                         context.abort();
@@ -2106,7 +1876,7 @@ class HocuspocusProvider extends EventEmitter {
     createWebSocketConnection() {
         return new Promise((resolve, reject) => {
             // Init the WebSocket connection
-            const ws = new this.options.WebSocketPolyfill(this.url);
+            const ws = new this.configuration.WebSocketPolyfill(this.url);
             ws.binaryType = 'arraybuffer';
             ws.onmessage = this.onMessage.bind(this);
             ws.onclose = this.onClose.bind(this);
@@ -2137,10 +1907,10 @@ class HocuspocusProvider extends EventEmitter {
         this.connectionAttempt = null;
     }
     get document() {
-        return this.options.document;
+        return this.configuration.document;
     }
     get awareness() {
-        return this.options.awareness;
+        return this.configuration.awareness;
     }
     checkConnection() {
         var _a;
@@ -2153,7 +1923,7 @@ class HocuspocusProvider extends EventEmitter {
             return;
         }
         // Don’t close the connection when a message was received recently
-        if (this.options.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) {
+        if (this.configuration.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) {
             return;
         }
         // No message received in a long time, not even your own
@@ -2166,10 +1936,11 @@ class HocuspocusProvider extends EventEmitter {
         }
         this.send(SyncStepOneMessage, { document: this.document });
     }
-    registerBeforeUnloadEventListener() {
+    registerEventListeners() {
         if (typeof window === 'undefined') {
             return;
         }
+        window.addEventListener('online', this.connect.bind(this));
         window.addEventListener('beforeunload', () => {
             removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
         });
@@ -2199,14 +1970,14 @@ class HocuspocusProvider extends EventEmitter {
     }
     // Ensure that the URL always ends with /
     get serverUrl() {
-        while (this.options.url[this.options.url.length - 1] === '/') {
-            return this.options.url.slice(0, this.options.url.length - 1);
+        while (this.configuration.url[this.configuration.url.length - 1] === '/') {
+            return this.configuration.url.slice(0, this.configuration.url.length - 1);
         }
-        return this.options.url;
+        return this.configuration.url;
     }
     get url() {
-        const encodedParams = encodeQueryParams(this.options.parameters);
-        return `${this.serverUrl}/${this.options.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
+        const encodedParams = encodeQueryParams(this.configuration.parameters);
+        return `${this.serverUrl}/${this.configuration.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
     }
     get synced() {
         return this.isSynced;
@@ -2220,7 +1991,7 @@ class HocuspocusProvider extends EventEmitter {
         this.emit('sync', { state });
     }
     get isAuthenticationRequired() {
-        return !!this.options.token && !this.isAuthenticated;
+        return !!this.configuration.token && !this.isAuthenticated;
     }
     disconnect() {
         this.shouldConnect = false;
@@ -2242,11 +2013,11 @@ class HocuspocusProvider extends EventEmitter {
         }
     }
     async getToken() {
-        if (typeof this.options.token === 'function') {
-            const token = await this.options.token();
+        if (typeof this.configuration.token === 'function') {
+            const token = await this.configuration.token();
             return token;
         }
-        return this.options.token;
+        return this.configuration.token;
     }
     async webSocketConnectionEstablished() {
         this.status = WebSocketStatus.Connected;
@@ -2298,15 +2069,26 @@ class HocuspocusProvider extends EventEmitter {
             this.emit('status', { status: 'disconnected' });
             this.emit('disconnect', { event });
         }
+        if (event.code === Unauthorized.code) {
+            if (!this.configuration.quiet) {
+                console.warn('[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.');
+            }
+            this.shouldConnect = false;
+        }
+        if (event.code === Forbidden.code) {
+            if (!this.configuration.quiet) {
+                console.warn('[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.');
+            }
+        }
         if (this.connectionAttempt) {
-            // Okay, that connection attempt failed …
+            // That connection attempt failed.
             this.rejectConnectionAttempt();
         }
         else if (this.shouldConnect) {
-            // The connection was closed by the server, so let’s just try again.
+            // The connection was closed by the server. Let’s just try again.
             this.connect();
         }
-        // If we’ll reconnect anyway, we’re done for now.
+        // If we’ll reconnect, we’re done for now.
         if (this.shouldConnect) {
             return;
         }
@@ -2334,9 +2116,13 @@ class HocuspocusProvider extends EventEmitter {
         this.awareness.off('update', this.awarenessUpdateHandler);
         this.document.off('update', this.documentUpdateHandler);
         this.removeAllListeners();
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.removeEventListener('online', this.connect.bind(this));
     }
     get broadcastChannel() {
-        return `${this.serverUrl}/${this.options.name}`;
+        return `${this.serverUrl}/${this.configuration.name}`;
     }
     broadcastChannelSubscriber(data) {
         this.mux(() => {
@@ -2371,7 +2157,7 @@ class HocuspocusProvider extends EventEmitter {
         }
     }
     broadcast(Message, args) {
-        if (!this.options.broadcast) {
+        if (!this.configuration.broadcast) {
             return;
         }
         if (!this.subscribedToBroadcastChannel) {
@@ -2384,5 +2170,20 @@ class HocuspocusProvider extends EventEmitter {
     }
 }
 
-export { HocuspocusProvider, MessageType, WebSocketStatus, awarenessStatesToArray };
+class HocuspocusCloudProvider extends HocuspocusProvider {
+    constructor(configuration) {
+        if (!configuration.url) {
+            configuration.url = 'wss://connect.hocuspocus.cloud';
+        }
+        if (configuration.key) {
+            if (!configuration.parameters) {
+                configuration.parameters = {};
+            }
+            configuration.parameters.key = configuration.key;
+        }
+        super(configuration);
+    }
+}
+
+export { HocuspocusCloudProvider, HocuspocusProvider, MessageType, WebSocketStatus, awarenessStatesToArray };
 //# sourceMappingURL=hocuspocus-provider.esm.js.map