@hocuspocus/provider 2.0.1 → 2.0.2

package/dist/hocuspocus-provider.esm.js

@@ -16,7 +16,7 @@ import { retry } from '@lifeomic/attempt';
  *
  * @function
  */
-const create$1 = () => new Map();
+const create$2 = () => new Map();
 
 /**
  * Get map property. Create T if property is undefined and set T on map.
@@ -27,11 +27,12 @@ const create$1 = () => new Map();
  * ```
  *
  * @function
- * @template T,K
- * @param {Map<K, T>} map
+ * @template V,K
+ * @template {Map<K,V>} MAP
+ * @param {MAP} map
  * @param {K} key
- * @param {function():T} createT
- * @return {T}
+ * @param {function():V} createT
+ * @return {V}
  */
 const setIfUndefined = (map, key, createT) => {
   let set = map.get(key);
@@ -41,6 +42,14 @@ const setIfUndefined = (map, key, createT) => {
   return set
 };
 
+/**
+ * Utility module to work with sets.
+ *
+ * @module set
+ */
+
+const create$1 = () => new Set();
+
 /**
  * Utility module to work with strings.
  *
@@ -72,20 +81,47 @@ const fromCamelCaseRegex = /([A-Z])/g;
  */
 const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
 
-/* istanbul ignore next */
-/** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Polyfill = str => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+  }
+  return buf
+};
+
+/* c8 ignore next */
+const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
 
-/* istanbul ignore next */
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+/* c8 ignore next */
+const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+
+/* c8 ignore next */
 let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 
-/* istanbul ignore next */
+/* c8 ignore start */
 if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
   // Safari doesn't handle BOM correctly.
   // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
   // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
   // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
   // Another issue is that from then on no BOM chars are recognized anymore
-  /* istanbul ignore next */
+  /* c8 ignore next */
   utf8TextDecoder = null;
 }
 
@@ -100,10 +136,10 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
  * @param {T|null|undefined} v
  * @return {T|null}
  */
-/* istanbul ignore next */
+/* c8 ignore next */
 const undefinedToNull = v => v === undefined ? null : v;
 
-/* global localStorage, addEventListener */
+/* eslint-env browser */
 
 /**
  * Isomorphic variable storage.
@@ -113,7 +149,7 @@ const undefinedToNull = v => v === undefined ? null : v;
  * @module storage
  */
 
-/* istanbul ignore next */
+/* c8 ignore start */
 class VarStoragePolyfill {
   constructor () {
     this.map = new Map();
@@ -134,65 +170,242 @@ class VarStoragePolyfill {
     return this.map.get(key)
   }
 }
+/* c8 ignore stop */
 
-/* istanbul ignore next */
 /**
  * @type {any}
  */
 let _localStorage = new VarStoragePolyfill();
 let usePolyfill = true;
 
+/* c8 ignore start */
 try {
   // if the same-origin rule is violated, accessing localStorage might thrown an error
-  /* istanbul ignore next */
   if (typeof localStorage !== 'undefined') {
     _localStorage = localStorage;
     usePolyfill = false;
   }
 } catch (e) { }
+/* c8 ignore stop */
 
-/* istanbul ignore next */
 /**
  * This is basically localStorage in browser, or a polyfill in nodejs
  */
+/* c8 ignore next */
 const varStorage = _localStorage;
 
-/* istanbul ignore next */
 /**
  * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
  *
  * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
  * @function
  */
+/* c8 ignore next */
 const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler));
 
+/**
+ * A polyfill for `removeEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ *
+ * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
+ * @function
+ */
+/* c8 ignore next */
+const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler));
+
+/**
+ * Utility module to work with Arrays.
+ *
+ * @module array
+ */
+
+/**
+ * Transforms something array-like to an actual Array.
+ *
+ * @function
+ * @template T
+ * @param {ArrayLike<T>|Iterable<T>} arraylike
+ * @return {T}
+ */
+const from = Array.from;
+
+/**
+ * Utility functions for working with EcmaScript objects.
+ *
+ * @module object
+ */
+
+/**
+ * @param {Object<string,any>} obj
+ */
+const keys = Object.keys;
+
+/**
+ * @todo implement mapToArray & map
+ *
+ * @template R
+ * @param {Object<string,any>} obj
+ * @param {function(any,string):R} f
+ * @return {Array<R>}
+ */
+const map = (obj, f) => {
+  const results = [];
+  for (const key in obj) {
+    results.push(f(obj[key], key));
+  }
+  return results
+};
+
+/**
+ * @param {Object<string,any>} obj
+ * @return {number}
+ */
+const length$1 = obj => keys(obj).length;
+
+/**
+ * Calls `Object.prototype.hasOwnProperty`.
+ *
+ * @param {any} obj
+ * @param {string|symbol} key
+ * @return {boolean}
+ */
+const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+/**
+ * Common functions and function call helpers.
+ *
+ * @module function
+ */
+
+/**
+ * @template T
+ *
+ * @param {T} a
+ * @param {T} b
+ * @return {boolean}
+ */
+const equalityStrict = (a, b) => a === b;
+
+/* c8 ignore start */
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const equalityDeep = (a, b) => {
+  if (a == null || b == null) {
+    return equalityStrict(a, b)
+  }
+  if (a.constructor !== b.constructor) {
+    return false
+  }
+  if (a === b) {
+    return true
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false
+        }
+      }
+      break
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false
+        }
+      }
+      break
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const key of a.keys()) {
+        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+          return false
+        }
+      }
+      break
+    }
+    case Object:
+      if (length$1(a) !== length$1(b)) {
+        return false
+      }
+      for (const key in a) {
+        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+          return false
+        }
+      }
+      break
+    case Array:
+      if (a.length !== b.length) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false
+        }
+      }
+      break
+    default:
+      return false
+  }
+  return true
+};
+
+/**
+ * @template V
+ * @template {V} OPTS
+ *
+ * @param {V} value
+ * @param {Array<OPTS>} options
+ */
+// @ts-ignore
+const isOneOf = (value, options) => options.includes(value);
+/* c8 ignore stop */
+
 /**
  * Isomorphic module to work access the environment (query params, env variables).
  *
  * @module map
  */
 
-/* istanbul ignore next */
+/* c8 ignore next */
 // @ts-ignore
-const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name);
-/* istanbul ignore next */
-const isBrowser = typeof window !== 'undefined' && !isNode;
-/* istanbul ignore next */
-typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
+const isNode = typeof process !== 'undefined' && process.release &&
+  /node|io\.js/.test(process.release.name);
+/* c8 ignore next */
+const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode;
+/* c8 ignore next 3 */
+typeof navigator !== 'undefined'
+  ? /Mac/.test(navigator.platform)
+  : false;
 
 /**
  * @type {Map<string,string>}
  */
 let params;
 
-/* istanbul ignore next */
+/* c8 ignore start */
 const computeParams = () => {
   if (params === undefined) {
     if (isNode) {
-      params = create$1();
+      params = create$2();
       const pargs = process.argv;
       let currParamName = null;
-      /* istanbul ignore next */
       for (let i = 0; i < pargs.length; i++) {
         const parg = pargs[i];
         if (parg[0] === '-') {
@@ -210,11 +423,10 @@ const computeParams = () => {
       if (currParamName !== null) {
         params.set(currParamName, '');
       }
-    // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
+      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
     } else if (typeof location === 'object') {
-      params = create$1()
-      // eslint-disable-next-line no-undef
-      ;(location.search || '?').slice(1).split('&').forEach(kv => {
+      params = create$2(); // eslint-disable-next-line no-undef
+      (location.search || '?').slice(1).split('&').forEach((kv) => {
         if (kv.length !== 0) {
           const [key, value] = kv.split('=');
           params.set(`--${fromCamelCase(key, '-')}`, value);
@@ -222,37 +434,54 @@ const computeParams = () => {
         }
       });
     } else {
-      params = create$1();
+      params = create$2();
     }
   }
   return params
 };
+/* c8 ignore stop */
 
 /**
  * @param {string} name
  * @return {boolean}
  */
-/* istanbul ignore next */
-const hasParam = name => computeParams().has(name);
-// export const getArgs = name => computeParams() && args
+/* c8 ignore next */
+const hasParam = (name) => computeParams().has(name);
 
 /**
  * @param {string} name
  * @return {string|null}
  */
-/* istanbul ignore next */
-const getVariable = name => isNode ? undefinedToNull(process.env[name.toUpperCase()]) : undefinedToNull(varStorage.getItem(name));
+/* c8 ignore next 4 */
+const getVariable = (name) =>
+  isNode
+    ? undefinedToNull(process.env[name.toUpperCase()])
+    : undefinedToNull(varStorage.getItem(name));
 
 /**
  * @param {string} name
  * @return {boolean}
  */
-/* istanbul ignore next */
-const hasConf = name => hasParam('--' + name) || getVariable(name) !== null;
+/* c8 ignore next 2 */
+const hasConf = (name) =>
+  hasParam('--' + name) || getVariable(name) !== null;
 
-/* istanbul ignore next */
+/* c8 ignore next */
 hasConf('production');
 
+/* c8 ignore next 2 */
+const forceColor = isNode &&
+  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
+
+/* c8 ignore start */
+!hasParam('no-colors') &&
+  (!isNode || process.stdout.isTTY || forceColor) && (
+  !isNode || hasParam('color') || forceColor ||
+    getVariable('COLORTERM') !== null ||
+    (getVariable('TERM') || '').includes('color')
+);
+/* c8 ignore stop */
+
 /**
  * Common Math expressions.
  *
@@ -281,6 +510,14 @@ const max = (a, b) => a > b ? a : b;
 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.
  *
@@ -292,7 +529,7 @@ const BITS7 = 127;
  *
  * ```js
  * // encoding step
- * const encoder = new encoding.createEncoder()
+ * const encoder = encoding.createEncoder()
  * encoding.writeVarUint(encoder, 256)
  * encoding.writeVarString(encoder, 'Hello world!')
  * const buf = encoding.toUint8Array(encoder)
@@ -300,7 +537,7 @@ const BITS7 = 127;
  *
  * ```js
  * // decoding step
- * const decoder = new decoding.createDecoder(buf)
+ * const decoder = decoding.createDecoder(buf)
  * decoding.readVarUint(decoder) // => 256
  * decoding.readVarString(decoder) // => 'Hello world!'
  * decoding.hasContent(decoder) // => false - all data is read
@@ -336,7 +573,7 @@ const createEncoder = () => new Encoder();
  * @param {Encoder} encoder
  * @return {number}
  */
-const length$1 = encoder => {
+const length = encoder => {
   let len = encoder.cpos;
   for (let i = 0; i < encoder.bufs.length; i++) {
     len += encoder.bufs[i].length;
@@ -352,7 +589,7 @@ const length$1 = encoder => {
  * @return {Uint8Array} The created ArrayBuffer.
  */
 const toUint8Array = encoder => {
-  const uint8arr = new Uint8Array(length$1(encoder));
+  const uint8arr = new Uint8Array(length(encoder));
   let curPos = 0;
   for (let i = 0; i < encoder.bufs.length; i++) {
     const d = encoder.bufs[i];
@@ -381,9 +618,7 @@ const write = (encoder, num) => {
 };
 
 /**
- * Write a variable length unsigned integer.
- *
- * Encodes integers in the range from [0, 4294967295] / [0, 0xffffffff]. (max 32 bit unsigned integer)
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
  *
  * @function
  * @param {Encoder} encoder
@@ -392,11 +627,17 @@ const write = (encoder, num) => {
 const writeVarUint = (encoder, num) => {
   while (num > BITS7) {
     write(encoder, BIT8 | (BITS7 & num));
-    num >>>= 7;
+    num = floor(num / 128); // shift >>> 7
   }
   write(encoder, BITS7 & num);
 };
 
+/**
+ * A cache to store strings temporarily
+ */
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
+
 /**
  * Write a variable length string.
  *
@@ -404,7 +645,28 @@ const writeVarUint = (encoder, num) => {
  * @param {Encoder} encoder
  * @param {String} str The string that is to be encoded.
  */
-const writeVarString = (encoder, str) => {
+const _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    // We can encode the string into the existing buffer
+    /* c8 ignore next */
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
+    }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
+  }
+};
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringPolyfill = (encoder, str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
   writeVarUint(encoder, len);
@@ -413,6 +675,16 @@ const writeVarString = (encoder, str) => {
   }
 };
 
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+
 /**
  * Append fixed-length Uint8Array to the encoder.
  *
@@ -451,6 +723,19 @@ const writeVarUint8Array = (encoder, uint8Array) => {
   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.
  *
@@ -462,7 +747,7 @@ const writeVarUint8Array = (encoder, uint8Array) => {
  *
  * ```js
  * // encoding step
- * const encoder = new encoding.createEncoder()
+ * const encoder = encoding.createEncoder()
  * encoding.writeVarUint(encoder, 256)
  * encoding.writeVarString(encoder, 'Hello world!')
  * const buf = encoding.toUint8Array(encoder)
@@ -470,7 +755,7 @@ const writeVarUint8Array = (encoder, uint8Array) => {
  *
  * ```js
  * // decoding step
- * const decoder = new decoding.createDecoder(buf)
+ * const decoder = decoding.createDecoder(buf)
  * decoding.readVarUint(decoder) // => 256
  * decoding.readVarString(decoder) // => 'Hello world!'
  * decoding.hasContent(decoder) // => false - all data is read
@@ -479,6 +764,9 @@ const writeVarUint8Array = (encoder, uint8Array) => {
  * @module decoding
  */
 
+const errorUnexpectedEndOfArray = create('Unexpected end of array');
+const errorIntegerOutOfRange = create('Integer out of Range');
+
 /**
  * A Decoder handles the decoding of an Uint8Array.
  */
@@ -558,24 +846,28 @@ const readUint8 = decoder => decoder.arr[decoder.pos++];
  */
 const readVarUint = decoder => {
   let num = 0;
-  let len = 0;
-  while (true) {
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
     const r = decoder.arr[decoder.pos++];
-    num = num | ((r & BITS7) << len);
-    len += 7;
+    // 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 >>> 0 // return unsigned number!
+      return num
     }
-    /* istanbul ignore if */
-    if (len > 35) {
-      throw new Error('Integer out of range!')
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange
     }
+    /* c8 ignore stop */
   }
+  throw errorUnexpectedEndOfArray
 };
 
 /**
- * Read string of variable length
- * * varUint is used to store the length of the string
+ * We don't test this function anymore as we use native decoding/encoding by default now.
+ * Better not modify this anymore..
  *
  * Transforming utf8 to a string is pretty expensive. The code performs 10x better
  * when String.fromCodePoint is fed with all characters as arguments.
@@ -586,7 +878,8 @@ const readVarUint = decoder => {
  * @param {Decoder} decoder
  * @return {String} The read String.
  */
-const readVarString = decoder => {
+/* c8 ignore start */
+const _readVarStringPolyfill = decoder => {
   let remainingLen = readVarUint(decoder);
   if (remainingLen === 0) {
     return ''
@@ -610,6 +903,27 @@ const readVarString = decoder => {
     return decodeURIComponent(escape(encodedString))
   }
 };
+/* c8 ignore stop */
+
+/**
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ */
+const _readVarStringNative = decoder =>
+  /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
+
+/**
+ * Read string of variable length
+ * * varUint is used to store the length of the string
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ *
+ */
+/* c8 ignore next */
+const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
 
 /**
  * Utility functions to work with buffers (Uint8Array).
@@ -638,7 +952,7 @@ const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new
  */
 const createUint8ArrayFromArrayBuffer = buffer => new Uint8Array(buffer);
 
-/* istanbul ignore next */
+/* c8 ignore start */
 /**
  * @param {Uint8Array} bytes
  * @return {string}
@@ -651,6 +965,7 @@ const toBase64Browser = bytes => {
   // eslint-disable-next-line no-undef
   return btoa(s)
 };
+/* c8 ignore stop */
 
 /**
  * @param {Uint8Array} bytes
@@ -658,7 +973,7 @@ const toBase64Browser = bytes => {
  */
 const toBase64Node = bytes => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
 
-/* istanbul ignore next */
+/* c8 ignore start */
 /**
  * @param {string} s
  * @return {Uint8Array}
@@ -672,6 +987,7 @@ const fromBase64Browser = s => {
   }
   return bytes
 };
+/* c8 ignore stop */
 
 /**
  * @param {string} s
@@ -681,17 +997,17 @@ const fromBase64Node = s => {
   return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
 };
 
-/* istanbul ignore next */
+/* c8 ignore next */
 const toBase64 = isBrowser ? toBase64Browser : toBase64Node;
 
-/* istanbul ignore next */
+/* c8 ignore next */
 const fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
 
 /* eslint-env browser */
 
 /**
  * @typedef {Object} Channel
- * @property {Set<Function>} Channel.subs
+ * @property {Set<function(any, any):any>} Channel.subs
  * @property {any} Channel.bc
  */
 
@@ -700,6 +1016,7 @@ const fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
  */
 const channels = new Map();
 
+/* c8 ignore start */
 class LocalStoragePolyfill {
   /**
    * @param {string} room
@@ -710,7 +1027,11 @@ class LocalStoragePolyfill {
      * @type {null|function({data:ArrayBuffer}):void}
      */
     this.onmessage = null;
-    onChange(e => e.key === room && this.onmessage !== null && this.onmessage({ data: fromBase64(e.newValue || '') }));
+    /**
+     * @param {any} e
+     */
+    this._onChange = e => e.key === room && this.onmessage !== null && this.onmessage({ data: fromBase64(e.newValue || '') });
+    onChange(this._onChange);
   }
 
   /**
@@ -719,9 +1040,15 @@ class LocalStoragePolyfill {
   postMessage (buf) {
     varStorage.setItem(this.room, toBase64(createUint8ArrayFromArrayBuffer(buf)));
   }
+
+  close () {
+    offChange(this._onChange);
+  }
 }
+/* c8 ignore stop */
 
 // Use BroadcastChannel or Polyfill
+/* c8 ignore next */
 const BC = typeof BroadcastChannel === 'undefined' ? LocalStoragePolyfill : BroadcastChannel;
 
 /**
@@ -730,12 +1057,13 @@ const BC = typeof BroadcastChannel === 'undefined' ? LocalStoragePolyfill : Broa
  */
 const getChannel = room =>
   setIfUndefined(channels, room, () => {
-    const subs = new Set();
+    const subs = create$1();
     const bc = new BC(room);
     /**
      * @param {{data:ArrayBuffer}} e
      */
-    bc.onmessage = e => subs.forEach(sub => sub(e.data));
+    /* c8 ignore next */
+    bc.onmessage = e => subs.forEach(sub => sub(e.data, 'broadcastchannel'));
     return {
       bc, subs
     }
@@ -746,18 +1074,29 @@ const getChannel = room =>
  *
  * @function
  * @param {string} room
- * @param {function(any):any} f
+ * @param {function(any, any):any} f
  */
-const subscribe = (room, f) => getChannel(room).subs.add(f);
+const subscribe = (room, f) => {
+  getChannel(room).subs.add(f);
+  return f
+};
 
 /**
  * Unsubscribe from `publish` global events.
  *
  * @function
  * @param {string} room
- * @param {function(any):any} f
- */
-const unsubscribe = (room, f) => getChannel(room).subs.delete(f);
+ * @param {function(any, any):any} f
+ */
+const unsubscribe = (room, f) => {
+  const channel = getChannel(room);
+  const unsubscribed = channel.subs.delete(f);
+  if (unsubscribed && channel.subs.size === 0) {
+    channel.bc.close();
+    channels.delete(room);
+  }
+  return unsubscribed
+};
 
 /**
  * Publish data to all subscribers (including subscribers on this tab)
@@ -765,11 +1104,12 @@ const unsubscribe = (room, f) => getChannel(room).subs.delete(f);
  * @function
  * @param {string} room
  * @param {any} data
+ * @param {any} [origin]
  */
-const publish = (room, data) => {
+const publish = (room, data, origin = null) => {
   const c = getChannel(room);
   c.bc.postMessage(data);
-  c.subs.forEach(sub => sub(data));
+  c.subs.forEach(sub => sub(data, origin));
 };
 
 /**
@@ -785,30 +1125,6 @@ const publish = (room, data) => {
  */
 const getUnixTime = Date.now;
 
-/**
- * Utility module to work with sets.
- *
- * @module set
- */
-
-const create = () => new Set();
-
-/**
- * Utility module to work with Arrays.
- *
- * @module array
- */
-
-/**
- * Transforms something array-like to an actual Array.
- *
- * @function
- * @template T
- * @param {ArrayLike<T>|Iterable<T>} arraylike
- * @return {T}
- */
-const from = Array.from;
-
 /**
  * Observable class prototype.
  *
@@ -826,7 +1142,7 @@ class Observable {
      * Some desc.
      * @type {Map<N, any>}
      */
-    this._observers = create$1();
+    this._observers = create$2();
   }
 
   /**
@@ -834,7 +1150,7 @@ class Observable {
    * @param {function} f
    */
   on (name, f) {
-    setIfUndefined(this._observers, name, create).add(f);
+    setIfUndefined(this._observers, name, create$1).add(f);
   }
 
   /**
@@ -877,148 +1193,14 @@ class Observable {
    */
   emit (name, args) {
     // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
-    return from((this._observers.get(name) || create$1()).values()).forEach(f => f(...args))
+    return from((this._observers.get(name) || create$2()).values()).forEach(f => f(...args))
   }
 
   destroy () {
-    this._observers = create$1();
+    this._observers = create$2();
   }
 }
 
-/**
- * Utility functions for working with EcmaScript objects.
- *
- * @module object
- */
-
-/**
- * @param {Object<string,any>} obj
- */
-const keys = Object.keys;
-
-/**
- * @template R
- * @param {Object<string,any>} obj
- * @param {function(any,string):R} f
- * @return {Array<R>}
- */
-const map = (obj, f) => {
-  const results = [];
-  for (const key in obj) {
-    results.push(f(obj[key], key));
-  }
-  return results
-};
-
-/**
- * @param {Object<string,any>} obj
- * @return {number}
- */
-const length = obj => keys(obj).length;
-
-/**
- * Calls `Object.prototype.hasOwnProperty`.
- *
- * @param {any} obj
- * @param {string|symbol} key
- * @return {boolean}
- */
-const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-
-/**
- * Common functions and function call helpers.
- *
- * @module function
- */
-
-/**
- * @template T
- *
- * @param {T} a
- * @param {T} b
- * @return {boolean}
- */
-const equalityStrict = (a, b) => a === b;
-
-/**
- * @param {any} a
- * @param {any} b
- * @return {boolean}
- */
-const equalityDeep = (a, b) => {
-  if (a == null || b == null) {
-    return equalityStrict(a, b)
-  }
-  if (a.constructor !== b.constructor) {
-    return false
-  }
-  if (a === b) {
-    return true
-  }
-  switch (a.constructor) {
-    case ArrayBuffer:
-      a = new Uint8Array(a);
-      b = new Uint8Array(b);
-    // eslint-disable-next-line no-fallthrough
-    case Uint8Array: {
-      if (a.byteLength !== b.byteLength) {
-        return false
-      }
-      for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) {
-          return false
-        }
-      }
-      break
-    }
-    case Set: {
-      if (a.size !== b.size) {
-        return false
-      }
-      for (const value of a) {
-        if (!b.has(value)) {
-          return false
-        }
-      }
-      break
-    }
-    case Map: {
-      if (a.size !== b.size) {
-        return false
-      }
-      for (const key of a.keys()) {
-        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
-          return false
-        }
-      }
-      break
-    }
-    case Object:
-      if (length(a) !== length(b)) {
-        return false
-      }
-      for (const key in a) {
-        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
-          return false
-        }
-      }
-      break
-    case Array:
-      if (a.length !== b.length) {
-        return false
-      }
-      for (let i = 0; i < a.length; i++) {
-        if (!equalityDeep(a[i], b[i])) {
-          return false
-        }
-      }
-      break
-    default:
-      return false
-  }
-  return true
-};
-
 /**
  * @module awareness-protocol
  */
@@ -1384,7 +1566,7 @@ class IncomingMessage {
         return writeVarUint8Array(this.encoder, data);
     }
     length() {
-        return length$1(this.encoder);
+        return length(this.encoder);
     }
 }
 
@@ -2180,7 +2362,11 @@ class HocuspocusProvider extends EventEmitter {
     }
     setConfiguration(configuration = {}) {
         if (!configuration.websocketProvider && configuration.url) {
-            this.configuration.websocketProvider = new HocuspocusProviderWebsocket({ url: configuration.url });
+            const websocketProviderConfig = configuration;
+            this.configuration.websocketProvider = new HocuspocusProviderWebsocket({
+                url: websocketProviderConfig.url,
+                parameters: websocketProviderConfig.parameters,
+            });
         }
         this.configuration = { ...this.configuration, ...configuration };
     }