@hocuspocus/provider 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/hocuspocus-provider.cjs

@@ -301,8 +301,8 @@ const min = (a, b) => a < b ? a : b;
 const max = (a, b) => a > b ? a : b;
 
 /* eslint-env browser */
-const BIT8 = 128;
-const BITS7 = 127;
+const BIT8$1 = 128;
+const BITS7$1 = 127;
 
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
@@ -393,7 +393,7 @@ const toUint8Array = encoder => {
  * @param {Encoder} encoder
  * @param {number} num The byte that is to be encoded.
  */
-const write = (encoder, num) => {
+const write$1 = (encoder, num) => {
   const bufferLen = encoder.cbuf.length;
   if (encoder.cpos === bufferLen) {
     encoder.bufs.push(encoder.cbuf);
@@ -412,12 +412,12 @@ const write = (encoder, num) => {
  * @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));
+const writeVarUint$1 = (encoder, num) => {
+  while (num > BITS7$1) {
+    write$1(encoder, BIT8$1 | (BITS7$1 & num));
     num >>>= 7;
   }
-  write(encoder, BITS7 & num);
+  write$1(encoder, BITS7$1 & num);
 };
 
 /**
@@ -427,12 +427,12 @@ const writeVarUint = (encoder, num) => {
  * @param {Encoder} encoder
  * @param {String} str The string that is to be encoded.
  */
-const writeVarString = (encoder, str) => {
+const writeVarString$1 = (encoder, str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
-  writeVarUint(encoder, len);
+  writeVarUint$1(encoder, len);
   for (let i = 0; i < len; i++) {
-    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+    write$1(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
   }
 };
 
@@ -470,7 +470,7 @@ const writeUint8Array = (encoder, uint8Array) => {
  * @param {Uint8Array} uint8Array
  */
 const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
+  writeVarUint$1(encoder, uint8Array.byteLength);
   writeUint8Array(encoder, uint8Array);
 };
 
@@ -559,7 +559,7 @@ const readUint8Array = (decoder, len) => {
  * @param {Decoder} decoder
  * @return {Uint8Array}
  */
-const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
+const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint$1(decoder));
 
 /**
  * Read one byte as unsigned integer.
@@ -567,7 +567,7 @@ const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder
  * @param {Decoder} decoder The decoder instance
  * @return {number} Unsigned 8-bit integer
  */
-const readUint8 = decoder => decoder.arr[decoder.pos++];
+const readUint8$1 = decoder => decoder.arr[decoder.pos++];
 
 /**
  * Read unsigned integer (32bit) with variable length.
@@ -579,14 +579,14 @@ const readUint8 = decoder => decoder.arr[decoder.pos++];
  * @param {Decoder} decoder
  * @return {number} An unsigned integer.length
  */
-const readVarUint = decoder => {
+const readVarUint$1 = decoder => {
   let num = 0;
   let len = 0;
   while (true) {
     const r = decoder.arr[decoder.pos++];
-    num = num | ((r & BITS7) << len);
+    num = num | ((r & BITS7$1) << len);
     len += 7;
-    if (r < BIT8) {
+    if (r < BIT8$1) {
       return num >>> 0 // return unsigned number!
     }
     /* istanbul ignore if */
@@ -609,15 +609,15 @@ const readVarUint = decoder => {
  * @param {Decoder} decoder
  * @return {String} The read String.
  */
-const readVarString = decoder => {
-  let remainingLen = readVarUint(decoder);
+const readVarString$1 = decoder => {
+  let remainingLen = readVarUint$1(decoder);
   if (remainingLen === 0) {
     return ''
   } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
+    let encodedString = String.fromCodePoint(readUint8$1(decoder)); // remember to decrease remainingLen
     if (--remainingLen < 100) { // do not create a Uint8Array for small strings
       while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8(decoder));
+        encodedString += String.fromCodePoint(readUint8$1(decoder));
       }
     } else {
       while (remainingLen > 0) {
@@ -1230,14 +1230,14 @@ const removeAwarenessStates = (awareness, clients, origin) => {
 const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
   const len = clients.length;
   const encoder = createEncoder();
-  writeVarUint(encoder, len);
+  writeVarUint$1(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(encoder, clientID);
-    writeVarUint(encoder, clock);
-    writeVarString(encoder, JSON.stringify(state));
+    writeVarUint$1(encoder, clientID);
+    writeVarUint$1(encoder, clock);
+    writeVarString$1(encoder, JSON.stringify(state));
   }
   return toUint8Array(encoder)
 };
@@ -1254,11 +1254,11 @@ const applyAwarenessUpdate = (awareness, update, origin) => {
   const updated = [];
   const filteredUpdated = [];
   const removed = [];
-  const len = readVarUint(decoder);
+  const len = readVarUint$1(decoder);
   for (let i = 0; i < len; i++) {
-    const clientID = readVarUint(decoder);
-    let clock = readVarUint(decoder);
-    const state = JSON.parse(readVarString(decoder));
+    const clientID = readVarUint$1(decoder);
+    let clock = readVarUint$1(decoder);
+    const state = JSON.parse(readVarString$1(decoder));
     const clientMeta = awareness.meta.get(clientID);
     const prevState = awareness.states.get(clientID);
     const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
@@ -1402,13 +1402,13 @@ class IncomingMessage {
         this.decoder = createDecoder(new Uint8Array(this.data));
     }
     readVarUint() {
-        return readVarUint(this.decoder);
+        return readVarUint$1(this.decoder);
     }
     readVarUint8Array() {
         return readVarUint8Array(this.decoder);
     }
     writeVarUint(type) {
-        return writeVarUint(this.encoder, type);
+        return writeVarUint$1(this.encoder, type);
     }
     writeVarUint8Array(data) {
         return writeVarUint8Array(this.encoder, data);
@@ -1462,7 +1462,7 @@ const messageYjsUpdate = 2;
  * @param {Y.Doc} doc
  */
 const writeSyncStep1 = (encoder, doc) => {
-  writeVarUint(encoder, messageYjsSyncStep1);
+  writeVarUint$1(encoder, messageYjsSyncStep1);
   const sv = Y__namespace.encodeStateVector(doc);
   writeVarUint8Array(encoder, sv);
 };
@@ -1473,7 +1473,7 @@ const writeSyncStep1 = (encoder, doc) => {
  * @param {Uint8Array} [encodedStateVector]
  */
 const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
-  writeVarUint(encoder, messageYjsSyncStep2);
+  writeVarUint$1(encoder, messageYjsSyncStep2);
   writeVarUint8Array(encoder, Y__namespace.encodeStateAsUpdate(doc, encodedStateVector));
 };
 
@@ -1508,7 +1508,7 @@ const readSyncStep2 = (decoder, doc, transactionOrigin) => {
  * @param {Uint8Array} update
  */
 const writeUpdate = (encoder, update) => {
-  writeVarUint(encoder, messageYjsUpdate);
+  writeVarUint$1(encoder, messageYjsUpdate);
   writeVarUint8Array(encoder, update);
 };
 
@@ -1528,7 +1528,7 @@ const readUpdate = readSyncStep2;
  * @param {any} transactionOrigin
  */
 const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
-  const messageType = readVarUint(decoder);
+  const messageType = readVarUint$1(decoder);
   switch (messageType) {
     case messageYjsSyncStep1:
       readSyncStep1(decoder, encoder, doc);
@@ -1545,6 +1545,239 @@ 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;
+      }
+  }
+};
+
 exports.MessageType = void 0;
 (function (MessageType) {
     MessageType[MessageType["Sync"] = 0] = "Sync";
@@ -1553,29 +1786,6 @@ exports.MessageType = void 0;
     MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
 })(exports.MessageType || (exports.MessageType = {}));
 
-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;
-        }
-    }
-};
-
 class OutgoingMessage {
     constructor() {
         this.encoder = createEncoder();
@@ -1681,7 +1891,7 @@ class SyncStepOneMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step one message requires document as an argument');
         }
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         writeSyncStep1(this.encoder, args.document);
         return this.encoder;
     }
@@ -1697,7 +1907,7 @@ class SyncStepTwoMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step two message requires document as an argument');
         }
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         writeSyncStep2(this.encoder, args.document);
         return this.encoder;
     }
@@ -1710,7 +1920,7 @@ class QueryAwarenessMessage extends OutgoingMessage {
         this.description = 'Queries awareness states';
     }
     get(args) {
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         return this.encoder;
     }
 }
@@ -1725,7 +1935,7 @@ class AuthenticationMessage extends OutgoingMessage {
         if (typeof args.token === 'undefined') {
             throw new Error('The authentication message requires `token` as an argument.');
         }
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         writeAuthentication(this.encoder, args.token);
         return this.encoder;
     }
@@ -1744,7 +1954,7 @@ class AwarenessMessage extends OutgoingMessage {
         if (typeof args.clients === 'undefined') {
             throw new Error('The awareness message requires clients as an argument');
         }
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         let awarenessUpdate;
         if (args.states === undefined) {
             awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
@@ -1764,7 +1974,7 @@ class UpdateMessage extends OutgoingMessage {
         this.description = 'A document update';
     }
     get(args) {
-        writeVarUint(this.encoder, this.type);
+        writeVarUint$1(this.encoder, this.type);
         writeUpdate(this.encoder, args.update);
         return this.encoder;
     }