pptx-react-viewer 3.20.1 → 3.21.0

package/dist/{y-webrtc-TAJBJIKH.js → y-webrtc-6H3ROPRC.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkNB7M4XBG_js = require('./chunk-NB7M4XBG.js');
-var chunkZYQT7I5C_js = require('./chunk-ZYQT7I5C.js');
+var chunkYQQXFRZT_js = require('./chunk-YQQXFRZT.js');
 var chunk4VNS5WPM_js = require('./chunk-4VNS5WPM.js');
+require('yjs');
 
 // ../../node_modules/.bun/simple-peer@9.11.1/node_modules/simple-peer/simplepeer.min.js
 var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
@@ -249,7 +249,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
               return G(H(t4, e2.length - n3), e2, n3, r2);
             }
             function T(e2, t4, n3, r2) {
-              return G(Y(t4), e2, n3, r2);
+              return G(Y2(t4), e2, n3, r2);
             }
             function v(e2, t4, n3, r2) {
               return T(e2, t4, n3, r2);
@@ -261,7 +261,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
               return G(V(t4, e2.length - n3), e2, n3, r2);
             }
             function A(e2, t4, n3) {
-              return 0 === t4 && n3 === e2.length ? $.fromByteArray(e2) : $.fromByteArray(e2.slice(t4, n3));
+              return 0 === t4 && n3 === e2.length ? $2.fromByteArray(e2) : $2.fromByteArray(e2.slice(t4, n3));
             }
             function x(e2, t4, n3) {
               n3 = o(e2.length, n3);
@@ -367,7 +367,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
               }
               return o2;
             }
-            function Y(e2) {
+            function Y2(e2) {
               for (var t4 = [], n3 = 0; n3 < e2.length; ++n3) t4.push(255 & e2.charCodeAt(n3));
               return t4;
             }
@@ -376,7 +376,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
               return o2;
             }
             function z(e2) {
-              return $.toByteArray(q(e2));
+              return $2.toByteArray(q(e2));
             }
             function G(e2, t4, n3, r2) {
               for (var a = 0; a < r2 && !(a + n3 >= t4.length || a >= e2.length); ++a) t4[a + n3] = e2[a];
@@ -388,7 +388,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             function X(e2) {
               return e2 !== e2;
             }
-            var $ = e("base64-js"), J = e("ieee754");
+            var $2 = e("base64-js"), J = e("ieee754");
             n2.Buffer = s, n2.SlowBuffer = function(e2) {
               return +e2 != e2 && (e2 = 0), s.alloc(+e2);
             }, n2.INSPECT_MAX_BYTES = 50;
@@ -1362,9 +1362,9 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             }, O = e("util");
             x = O && O.debuglog ? O.debuglog("stream") : function() {
             };
-            var F, B, U, j = e("./internal/streams/buffer_list"), q = e("./internal/streams/destroy"), W = e("./internal/streams/state"), H = W.getHighWaterMark, Y = e("../errors").codes, V = Y.ERR_INVALID_ARG_TYPE, z = Y.ERR_STREAM_PUSH_AFTER_EOF, G = Y.ERR_METHOD_NOT_IMPLEMENTED, K = Y.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+            var F, B, U, j = e("./internal/streams/buffer_list"), q = e("./internal/streams/destroy"), W = e("./internal/streams/state"), H = W.getHighWaterMark, Y2 = e("../errors").codes, V = Y2.ERR_INVALID_ARG_TYPE, z = Y2.ERR_STREAM_PUSH_AFTER_EOF, G = Y2.ERR_METHOD_NOT_IMPLEMENTED, K = Y2.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
             e("inherits")(s, I);
-            var X = q.errorOrDestroy, $ = ["error", "close", "destroy", "pause", "resume"];
+            var X = q.errorOrDestroy, $2 = ["error", "close", "destroy", "pause", "resume"];
             Object.defineProperty(s.prototype, "destroyed", { enumerable: false, get: function() {
               return void 0 !== this._readableState && this._readableState.destroyed;
             }, set: function(e2) {
@@ -1485,7 +1485,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
                   return e2[t4].apply(e2, arguments);
                 };
               })(o2));
-              for (var i2 = 0; i2 < $.length; i2++) e2.on($[i2], this.emit.bind(this, $[i2]));
+              for (var i2 = 0; i2 < $2.length; i2++) e2.on($2[i2], this.emit.bind(this, $2[i2]));
               return this._read = function(t4) {
                 x("wrapped _read", t4), a2 && (a2 = false, e2.resume());
               }, this;
@@ -1582,11 +1582,11 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             }
             function c(e2, t3) {
               var r3 = new W();
-              Y(e2, r3), n2.nextTick(t3, r3);
+              Y2(e2, r3), n2.nextTick(t3, r3);
             }
             function u(e2, t3, r3, a2) {
               var o2;
-              return null === r3 ? o2 = new q() : "string" != typeof r3 && !t3.objectMode && (o2 = new O("chunk", ["string", "Buffer"], r3)), !o2 || (Y(e2, o2), n2.nextTick(a2, o2), false);
+              return null === r3 ? o2 = new q() : "string" != typeof r3 && !t3.objectMode && (o2 = new O("chunk", ["string", "Buffer"], r3)), !o2 || (Y2(e2, o2), n2.nextTick(a2, o2), false);
             }
             function p(e2, t3, n3) {
               return e2.objectMode || false === e2.decodeStrings || "string" != typeof t3 || (t3 = x.from(t3, n3)), t3;
@@ -1609,7 +1609,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
               t3.writelen = r3, t3.writecb = i2, t3.writing = true, t3.sync = true, t3.destroyed ? t3.onwrite(new j("write")) : n3 ? e2._writev(a2, t3.onwrite) : e2._write(a2, o2, t3.onwrite), t3.sync = false;
             }
             function _(e2, t3, r3, a2, o2) {
-              --t3.pendingcb, r3 ? (n2.nextTick(o2, a2), n2.nextTick(S, e2, t3), e2._writableState.errorEmitted = true, Y(e2, a2)) : (o2(a2), e2._writableState.errorEmitted = true, Y(e2, a2), S(e2, t3));
+              --t3.pendingcb, r3 ? (n2.nextTick(o2, a2), n2.nextTick(S, e2, t3), e2._writableState.errorEmitted = true, Y2(e2, a2)) : (o2(a2), e2._writableState.errorEmitted = true, Y2(e2, a2), S(e2, t3));
             }
             function h(e2) {
               e2.writing = false, e2.writecb = null, e2.length -= e2.writelen, e2.writelen = 0;
@@ -1651,7 +1651,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             }
             function E(e2, t3) {
               e2._final(function(n3) {
-                t3.pendingcb--, n3 && Y(e2, n3), t3.prefinished = true, e2.emit("prefinish"), S(e2, t3);
+                t3.pendingcb--, n3 && Y2(e2, n3), t3.prefinished = true, e2.emit("prefinish"), S(e2, t3);
               });
             }
             function w(e2, t3) {
@@ -1680,7 +1680,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             var k;
             l.WritableState = s;
             var L = { deprecate: e("util-deprecate") }, A = e("./internal/streams/stream"), x = e("buffer").Buffer, N = r2.Uint8Array || function() {
-            }, D = e("./internal/streams/destroy"), I = e("./internal/streams/state"), P = I.getHighWaterMark, M = e("../errors").codes, O = M.ERR_INVALID_ARG_TYPE, F = M.ERR_METHOD_NOT_IMPLEMENTED, B = M.ERR_MULTIPLE_CALLBACK, U = M.ERR_STREAM_CANNOT_PIPE, j = M.ERR_STREAM_DESTROYED, q = M.ERR_STREAM_NULL_VALUES, W = M.ERR_STREAM_WRITE_AFTER_END, H = M.ERR_UNKNOWN_ENCODING, Y = D.errorOrDestroy;
+            }, D = e("./internal/streams/destroy"), I = e("./internal/streams/state"), P = I.getHighWaterMark, M = e("../errors").codes, O = M.ERR_INVALID_ARG_TYPE, F = M.ERR_METHOD_NOT_IMPLEMENTED, B = M.ERR_MULTIPLE_CALLBACK, U = M.ERR_STREAM_CANNOT_PIPE, j = M.ERR_STREAM_DESTROYED, q = M.ERR_STREAM_NULL_VALUES, W = M.ERR_STREAM_WRITE_AFTER_END, H = M.ERR_UNKNOWN_ENCODING, Y2 = D.errorOrDestroy;
             e("inherits")(l, A), s.prototype.getBuffer = function() {
               for (var e2 = this.bufferedRequest, t3 = []; e2; ) t3.push(e2), e2 = e2.next;
               return t3;
@@ -1698,7 +1698,7 @@ var require_simplepeer_min = chunk4VNS5WPM_js.__commonJS({
             } })) : V = function(e2) {
               return e2 instanceof this;
             }, l.prototype.pipe = function() {
-              Y(this, new U());
+              Y2(this, new U());
             }, l.prototype.write = function(e2, t3, n3) {
               var r3 = this._writableState, a2 = false, s2 = !r3.objectMode && i(e2);
               return s2 && !x.isBuffer(e2) && (e2 = o(e2)), "function" == typeof t3 && (n3 = t3, t3 = null), s2 ? t3 = "buffer" : !t3 && (t3 = r3.defaultEncoding), "function" != typeof n3 && (n3 = d), r3.ending ? c(this, n3) : (s2 || u(this, r3, e2, n3)) && (r3.pendingcb++, a2 = f(this, r3, s2, e2, t3, n3)), a2;
@@ -2605,7 +2605,7 @@ var setupWS = (wsclient) => {
     wsclient.connecting = true;
     wsclient.connected = false;
     websocket.onmessage = (event) => {
-      wsclient.lastMessageReceived = chunkZYQT7I5C_js.getUnixTime();
+      wsclient.lastMessageReceived = chunkYQQXFRZT_js.getUnixTime();
       const data = event.data;
       const message = typeof data === "string" ? JSON.parse(data) : data;
       if (message && message.type === "pong") {
@@ -2624,7 +2624,7 @@ var setupWS = (wsclient) => {
         } else {
           wsclient.unsuccessfulReconnects++;
         }
-        setTimeout(setupWS, chunkZYQT7I5C_js.min(chunkZYQT7I5C_js.log10(wsclient.unsuccessfulReconnects + 1) * reconnectTimeoutBase, maxReconnectTimeout), wsclient);
+        setTimeout(setupWS, chunkYQQXFRZT_js.min(chunkYQQXFRZT_js.log10(wsclient.unsuccessfulReconnects + 1) * reconnectTimeoutBase, maxReconnectTimeout), wsclient);
       }
       clearTimeout(pingTimeout);
     };
@@ -2638,7 +2638,7 @@ var setupWS = (wsclient) => {
     websocket.onclose = () => onclose(null);
     websocket.onerror = (error) => onclose(error);
     websocket.onopen = () => {
-      wsclient.lastMessageReceived = chunkZYQT7I5C_js.getUnixTime();
+      wsclient.lastMessageReceived = chunkYQQXFRZT_js.getUnixTime();
       wsclient.connecting = false;
       wsclient.connected = true;
       wsclient.unsuccessfulReconnects = 0;
@@ -2647,7 +2647,7 @@ var setupWS = (wsclient) => {
     };
   }
 };
-var WebsocketClient = class extends chunkZYQT7I5C_js.Observable {
+var WebsocketClient = class extends chunkYQQXFRZT_js.Observable {
   /**
    * @param {string} url
    * @param {object} opts
@@ -2664,7 +2664,7 @@ var WebsocketClient = class extends chunkZYQT7I5C_js.Observable {
     this.lastMessageReceived = 0;
     this.shouldConnect = true;
     this._checkInterval = setInterval(() => {
-      if (this.connected && messageReconnectTimeout < chunkZYQT7I5C_js.getUnixTime() - this.lastMessageReceived) {
+      if (this.connected && messageReconnectTimeout < chunkYQQXFRZT_js.getUnixTime() - this.lastMessageReceived) {
         this.ws.close();
       }
     }, messageReconnectTimeout / 2);
@@ -2696,6 +2696,957 @@ var WebsocketClient = class extends chunkZYQT7I5C_js.Observable {
     }
   }
 };
+var getRandomValues = crypto.getRandomValues.bind(crypto);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/random.js
+var rand = Math.random;
+var uint32 = () => getRandomValues(new Uint32Array(1))[0];
+var uuidv4Template = "10000000-1000-4000-8000" + -1e11;
+var uuidv4 = () => uuidv4Template.replace(
+  /[018]/g,
+  /** @param {number} c */
+  (c) => (c ^ uint32() & 15 >> c / 4).toString(16)
+);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/pair.js
+var Pair = class {
+  /**
+   * @param {L} left
+   * @param {R} right
+   */
+  constructor(left, right) {
+    this.left = left;
+    this.right = right;
+  }
+};
+var create4 = (left, right) => new Pair(left, right);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/prng.js
+var bool = (gen) => gen.next() >= 0.5;
+var int53 = (gen, min2, max) => chunkYQQXFRZT_js.floor(gen.next() * (max + 1 - min2) + min2);
+var int32 = (gen, min2, max) => chunkYQQXFRZT_js.floor(gen.next() * (max + 1 - min2) + min2);
+var int31 = (gen, min2, max) => int32(gen, min2, max);
+var letter = (gen) => chunkYQQXFRZT_js.fromCharCode(int31(gen, 97, 122));
+var word = (gen, minLen = 0, maxLen = 20) => {
+  const len = int31(gen, minLen, maxLen);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += letter(gen);
+  }
+  return str;
+};
+var oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/schema.js
+var schemaSymbol = /* @__PURE__ */ Symbol("0schema");
+var ValidationError = class {
+  constructor() {
+    this._rerrs = [];
+  }
+  /**
+   * @param {string?} path
+   * @param {string} expected
+   * @param {string} has
+   * @param {string?} message
+   */
+  extend(path, expected, has, message = null) {
+    this._rerrs.push({ path, expected, has, message });
+  }
+  toString() {
+    const s = [];
+    for (let i = this._rerrs.length - 1; i > 0; i--) {
+      const r = this._rerrs[i];
+      s.push(chunkYQQXFRZT_js.repeat(" ", (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
+    }
+    return s.join("\n");
+  }
+};
+var shapeExtends = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null || a.constructor !== b.constructor) return false;
+  if (a[chunkYQQXFRZT_js.EqualityTraitSymbol]) return chunkYQQXFRZT_js.equals(a, b);
+  if (chunkYQQXFRZT_js.isArray(a)) {
+    return chunkYQQXFRZT_js.every(
+      a,
+      (aitem) => chunkYQQXFRZT_js.some(b, (bitem) => shapeExtends(aitem, bitem))
+    );
+  } else if (chunkYQQXFRZT_js.isObject(a)) {
+    return chunkYQQXFRZT_js.every2(
+      a,
+      (aitem, akey) => shapeExtends(aitem, b[akey])
+    );
+  }
+  return false;
+};
+var Schema = class {
+  // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
+  /**
+   * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+   * union). By default, the more objects are added, the the fewer objects this schema will accept.
+   * @protected
+   */
+  static _dilutes = false;
+  /**
+   * @param {Schema<any>} other
+   */
+  extends(other) {
+    let [a, b] = [
+      /** @type {any} */
+      this.shape,
+      /** @type {any} */
+      other.shape
+    ];
+    if (
+      /** @type {typeof Schema<any>} */
+      this.constructor._dilutes
+    ) [b, a] = [a, b];
+    return shapeExtends(a, b);
+  }
+  /**
+   * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+   * should have.
+   * @param {Schema<any>} other
+   */
+  equals(other) {
+    return this.constructor === other.constructor && chunkYQQXFRZT_js.equalityDeep(this.shape, other.shape);
+  }
+  [schemaSymbol]() {
+    return true;
+  }
+  /**
+   * @param {object} other
+   */
+  [chunkYQQXFRZT_js.EqualityTraitSymbol](other) {
+    return this.equals(
+      /** @type {any} */
+      other
+    );
+  }
+  /**
+   * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+   * Schema. Validate will check the structure of the parameter and return true iff the instance
+   * really is an instance of Schema.
+   *
+   * @param {T} o
+   * @return {boolean}
+   */
+  validate(o) {
+    return this.check(o);
+  }
+  /* c8 ignore start */
+  /**
+   * Similar to validate, but this method accepts untyped parameters.
+   *
+   * @param {any} _o
+   * @param {ValidationError} [_err]
+   * @return {_o is T}
+   */
+  check(_o, _err) {
+    chunkYQQXFRZT_js.methodUnimplemented();
+  }
+  /* c8 ignore stop */
+  /**
+   * @type {Schema<T?>}
+   */
+  get nullable() {
+    return $union(this, $null);
+  }
+  /**
+   * @type {$Optional<Schema<T>>}
+   */
+  get optional() {
+    return new $Optional(
+      /** @type {Schema<T>} */
+      this
+    );
+  }
+  /**
+   * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check only if not in a production environment.
+   *
+   * @template OO
+   * @param {OO} o
+   * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
+   */
+  cast(o) {
+    assert(o, this);
+    return (
+      /** @type {any} */
+      o
+    );
+  }
+  /**
+   * EXPECTO PATRONUM!! 🪄
+   * This function protects against type errors. Though it may not work in the real world.
+   *
+   * "After all this time?"
+   * "Always." - Snape, talking about type safety
+   *
+   * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check if not in a production environment.
+   *
+   * @param {T} o
+   * @return {o extends T ? T : never}
+   */
+  expect(o) {
+    assert(o, this);
+    return o;
+  }
+};
+var $ConstructedBy = class extends Schema {
+  /**
+   * @param {C} c
+   * @param {((o:Instance<C>)=>boolean)|null} check
+   */
+  constructor(c, check) {
+    super();
+    this.shape = c;
+    this._c = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+   */
+  check(o, err = void 0) {
+    const c = o?.constructor === this.shape && (this._c == null || this._c(o));
+    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
+    return c;
+  }
+};
+var $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+$constructedBy($ConstructedBy);
+var $Custom = class extends Schema {
+  /**
+   * @param {(o:any) => boolean} check
+   */
+  constructor(check) {
+    super();
+    this.shape = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check(o, err) {
+    const c = this.shape(o);
+    !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
+    return c;
+  }
+};
+var $custom = (check) => new $Custom(check);
+$constructedBy($Custom);
+var $Literal = class extends Schema {
+  /**
+   * @param {Array<T>} literals
+   */
+  constructor(literals) {
+    super();
+    this.shape = literals;
+  }
+  /**
+   *
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is T}
+   */
+  check(o, err) {
+    const c = this.shape.some((a) => a === o);
+    !c && err?.extend(null, this.shape.join(" | "), o.toString());
+    return c;
+  }
+};
+var $literal = (...literals) => new $Literal(literals);
+var $$literal = $constructedBy($Literal);
+var _regexEscape = (
+  /** @type {any} */
+  RegExp.escape || /** @type {(str:string) => string} */
+  ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s))
+);
+var _schemaStringTemplateToRegex = (s) => {
+  if ($string.check(s)) {
+    return [_regexEscape(s)];
+  }
+  if ($$literal.check(s)) {
+    return (
+      /** @type {Array<string|number>} */
+      s.shape.map((v) => v + "")
+    );
+  }
+  if ($$number.check(s)) {
+    return ["[+-]?\\d+.?\\d*"];
+  }
+  if ($$string.check(s)) {
+    return [".*"];
+  }
+  if ($$union.check(s)) {
+    return s.shape.map(_schemaStringTemplateToRegex).flat(1);
+  }
+  chunkYQQXFRZT_js.unexpectedCase();
+};
+var $StringTemplate = class extends Schema {
+  /**
+   * @param {T} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+    this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is CastStringTemplateArgsToTemplate<T>}
+   */
+  check(o, err) {
+    const c = this._r.exec(o) != null;
+    !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
+    return c;
+  }
+};
+$constructedBy($StringTemplate);
+var isOptionalSymbol = /* @__PURE__ */ Symbol("optional");
+var $Optional = class extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is (Unwrap<S>|undefined)}
+   */
+  check(o, err) {
+    const c = o === void 0 || this.shape.check(o);
+    !c && err?.extend(null, "undefined (optional)", "()");
+    return c;
+  }
+  get [isOptionalSymbol]() {
+    return true;
+  }
+};
+var $$optional = $constructedBy($Optional);
+var $Never = class extends Schema {
+  /**
+   * @param {any} _o
+   * @param {ValidationError} [err]
+   * @return {_o is never}
+   */
+  check(_o, err) {
+    err?.extend(null, "never", typeof _o);
+    return false;
+  }
+};
+$constructedBy($Never);
+var $Object = class _$Object extends Schema {
+  /**
+   * @param {S} shape
+   * @param {boolean} partial
+   */
+  constructor(shape, partial = false) {
+    super();
+    this.shape = shape;
+    this._isPartial = partial;
+  }
+  static _dilutes = true;
+  /**
+   * @type {Schema<Partial<$ObjectToType<S>>>}
+   */
+  get partial() {
+    return new _$Object(this.shape, true);
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is $ObjectToType<S>}
+   */
+  check(o, err) {
+    if (o == null) {
+      err?.extend(null, "object", "null");
+      return false;
+    }
+    return chunkYQQXFRZT_js.every2(this.shape, (vv, vk) => {
+      const c = this._isPartial && !chunkYQQXFRZT_js.hasProperty(o, vk) || vv.check(o[vk], err);
+      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
+      return c;
+    });
+  }
+};
+var $object = (def) => (
+  /** @type {any} */
+  new $Object(def)
+);
+var $$object = $constructedBy($Object);
+var $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
+var $Record = class extends Schema {
+  /**
+   * @param {Keys} keys
+   * @param {Values} values
+   */
+  constructor(keys, values) {
+    super();
+    this.shape = {
+      keys,
+      values
+    };
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
+   */
+  check(o, err) {
+    return o != null && chunkYQQXFRZT_js.every2(o, (vv, vk) => {
+      const ck = this.shape.keys.check(vk, err);
+      !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
+      return ck && this.shape.values.check(vv, err);
+    });
+  }
+};
+var $record = (keys, values) => new $Record(keys, values);
+var $$record = $constructedBy($Record);
+var $Tuple = class extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
+   */
+  check(o, err) {
+    return o != null && chunkYQQXFRZT_js.every2(this.shape, (vv, vk) => {
+      const c = (
+        /** @type {Schema<any>} */
+        vv.check(o[vk], err)
+      );
+      !c && err?.extend(vk.toString(), "Tuple", typeof vv);
+      return c;
+    });
+  }
+};
+var $tuple = (...def) => new $Tuple(def);
+$constructedBy($Tuple);
+var $Array = class extends Schema {
+  /**
+   * @param {Array<S>} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v.length === 1 ? v[0] : new $Union(v);
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Array<S extends Schema<infer T> ? T : never>} o
+   */
+  check(o, err) {
+    const c = chunkYQQXFRZT_js.isArray(o) && chunkYQQXFRZT_js.every(o, (oi) => this.shape.check(oi));
+    !c && err?.extend(null, "Array", "");
+    return c;
+  }
+};
+var $array = (...def) => new $Array(def);
+var $$array = $constructedBy($Array);
+var $arrayAny = $custom((o) => chunkYQQXFRZT_js.isArray(o));
+var $InstanceOf = class extends Schema {
+  /**
+   * @param {new (...args:any) => T} constructor
+   * @param {((o:T) => boolean)|null} check
+   */
+  constructor(constructor, check) {
+    super();
+    this.shape = constructor;
+    this._c = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is T}
+   */
+  check(o, err) {
+    const c = o instanceof this.shape && (this._c == null || this._c(o));
+    !c && err?.extend(null, this.shape.name, o?.constructor.name);
+    return c;
+  }
+};
+var $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+$constructedBy($InstanceOf);
+var $$schema = $instanceOf(Schema);
+var $Lambda = class extends Schema {
+  /**
+   * @param {Args} args
+   */
+  constructor(args) {
+    super();
+    this.len = args.length - 1;
+    this.args = $tuple(...args.slice(-1));
+    this.res = args[this.len];
+  }
+  /**
+   * @param {any} f
+   * @param {ValidationError} err
+   * @return {f is _LArgsToLambdaDef<Args>}
+   */
+  check(f, err) {
+    const c = f.constructor === Function && f.length <= this.len;
+    !c && err?.extend(null, "function", typeof f);
+    return c;
+  }
+};
+var $$lambda = $constructedBy($Lambda);
+var $function = $custom((o) => typeof o === "function");
+var $Intersection = class extends Schema {
+  /**
+   * @param {T} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Intersect<UnwrapArray<T>>}
+   */
+  check(o, err) {
+    const c = chunkYQQXFRZT_js.every(this.shape, (check) => check.check(o, err));
+    !c && err?.extend(null, "Intersectinon", typeof o);
+    return c;
+  }
+};
+$constructedBy($Intersection, (o) => o.shape.length > 0);
+var $Union = class extends Schema {
+  static _dilutes = true;
+  /**
+   * @param {Array<Schema<S>>} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is S}
+   */
+  check(o, err) {
+    const c = chunkYQQXFRZT_js.some(this.shape, (vv) => vv.check(o, err));
+    err?.extend(null, "Union", typeof o);
+    return c;
+  }
+};
+var $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
+var $$union = (
+  /** @type {Schema<$Union<any>>} */
+  $constructedBy($Union)
+);
+var _t = () => true;
+var $any = $custom(_t);
+var $$any = (
+  /** @type {Schema<Schema<any>>} */
+  $constructedBy($Custom, (o) => o.shape === _t)
+);
+var $bigint = $custom((o) => typeof o === "bigint");
+var $$bigint = (
+  /** @type {Schema<Schema<BigInt>>} */
+  $custom((o) => o === $bigint)
+);
+var $symbol = $custom((o) => typeof o === "symbol");
+(
+  /** @type {Schema<Schema<Symbol>>} */
+  $custom((o) => o === $symbol)
+);
+var $number = $custom((o) => typeof o === "number");
+var $$number = (
+  /** @type {Schema<Schema<number>>} */
+  $custom((o) => o === $number)
+);
+var $string = $custom((o) => typeof o === "string");
+var $$string = (
+  /** @type {Schema<Schema<string>>} */
+  $custom((o) => o === $string)
+);
+var $boolean = $custom((o) => typeof o === "boolean");
+var $$boolean = (
+  /** @type {Schema<Schema<Boolean>>} */
+  $custom((o) => o === $boolean)
+);
+var $undefined = $literal(void 0);
+(
+  /** @type {Schema<Schema<undefined>>} */
+  $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0)
+);
+$literal(void 0);
+var $null = $literal(null);
+var $$null = (
+  /** @type {Schema<Schema<null>>} */
+  $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
+);
+$constructedBy(Uint8Array);
+(
+  /** @type {Schema<Schema<Uint8Array>>} */
+  $constructedBy($ConstructedBy, (o) => o.shape === Uint8Array)
+);
+var $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+(() => {
+  const $jsonArr = (
+    /** @type {$Array<$any>} */
+    $array($any)
+  );
+  const $jsonRecord = (
+    /** @type {$Record<$string,$any>} */
+    $record($string, $any)
+  );
+  const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+  $jsonArr.shape = $json2;
+  $jsonRecord.shape.values = $json2;
+  return $json2;
+})();
+var $ = (o) => {
+  if ($$schema.check(o)) {
+    return (
+      /** @type {any} */
+      o
+    );
+  } else if ($objectAny.check(o)) {
+    const o2 = {};
+    for (const k in o) {
+      o2[k] = $(o[k]);
+    }
+    return (
+      /** @type {any} */
+      $object(o2)
+    );
+  } else if ($arrayAny.check(o)) {
+    return (
+      /** @type {any} */
+      $union(...o.map($))
+    );
+  } else if ($primitive.check(o)) {
+    return (
+      /** @type {any} */
+      $literal(o)
+    );
+  } else if ($function.check(o)) {
+    return (
+      /** @type {any} */
+      $constructedBy(
+        /** @type {any} */
+        o
+      )
+    );
+  }
+  chunkYQQXFRZT_js.unexpectedCase();
+};
+var assert = chunkYQQXFRZT_js.production ? () => {
+} : (o, schema) => {
+  const err = new ValidationError();
+  if (!schema.check(o, err)) {
+    throw chunkYQQXFRZT_js.create3(`Expected value to be of type ${schema.constructor.name}.
+${err.toString()}`);
+  }
+};
+var PatternMatcher = class {
+  /**
+   * @param {Schema<State>} [$state]
+   */
+  constructor($state) {
+    this.patterns = [];
+    this.$state = $state;
+  }
+  /**
+   * @template P
+   * @template R
+   * @param {P} pattern
+   * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
+   * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
+   */
+  if(pattern, handler) {
+    this.patterns.push({ if: $(pattern), h: handler });
+    return this;
+  }
+  /**
+   * @template R
+   * @param {(o:any,s:State)=>R} h
+   */
+  else(h) {
+    return this.if($any, h);
+  }
+  /**
+   * @return {State extends undefined
+   *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
+   *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
+   */
+  done() {
+    return (
+      /** @type {any} */
+      (o, s) => {
+        for (let i = 0; i < this.patterns.length; i++) {
+          const p = this.patterns[i];
+          if (p.if.check(o)) {
+            return p.h(o, s);
+          }
+        }
+        throw chunkYQQXFRZT_js.create3("Unhandled pattern");
+      }
+    );
+  }
+};
+var match = (state) => new PatternMatcher(
+  /** @type {any} */
+  state
+);
+var _random = (
+  /** @type {any} */
+  match(
+    /** @type {Schema<prng.PRNG>} */
+    $any
+  ).if($$number, (_o, gen) => int53(gen, chunkYQQXFRZT_js.MIN_SAFE_INTEGER, chunkYQQXFRZT_js.MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, chunkYQQXFRZT_js.MIN_SAFE_INTEGER, chunkYQQXFRZT_js.MAX_SAFE_INTEGER))).if($$union, (o, gen) => random(gen, oneOf(gen, o.shape))).if($$object, (o, gen) => {
+    const res = {};
+    for (const k in o.shape) {
+      let prop = o.shape[k];
+      if ($$optional.check(prop)) {
+        if (bool(gen)) {
+          continue;
+        }
+        prop = prop.shape;
+      }
+      res[k] = _random(prop, gen);
+    }
+    return res;
+  }).if($$array, (o, gen) => {
+    const arr = [];
+    const n = int32(gen, 0, 42);
+    for (let i = 0; i < n; i++) {
+      arr.push(random(gen, o.shape));
+    }
+    return arr;
+  }).if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape);
+  }).if($$null, (o, gen) => {
+    return null;
+  }).if($$lambda, (o, gen) => {
+    const res = random(gen, o.res);
+    return () => res;
+  }).if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number,
+    $string,
+    $null,
+    $undefined,
+    $bigint,
+    $boolean,
+    $array($number),
+    $record($union("a", "b", "c"), $number)
+  ]))).if($$record, (o, gen) => {
+    const res = {};
+    const keysN = int53(gen, 0, 3);
+    for (let i = 0; i < keysN; i++) {
+      const key = random(gen, o.shape.keys);
+      const val = random(gen, o.shape.values);
+      res[key] = val;
+    }
+    return res;
+  }).done()
+);
+var random = (gen, schema) => (
+  /** @type {any} */
+  _random($(schema), gen)
+);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/dom.js
+var doc = (
+  /** @type {Document} */
+  typeof document !== "undefined" ? document : {}
+);
+$custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
+(
+  /** @type {DOMParser} */
+  typeof DOMParser !== "undefined" ? new DOMParser() : null
+);
+$custom((el) => el.nodeType === ELEMENT_NODE);
+$custom((el) => el.nodeType === TEXT_NODE);
+var mapToStyleString = (m) => chunkYQQXFRZT_js.map(m, (value, key) => `${key}:${value};`).join("");
+var ELEMENT_NODE = doc.ELEMENT_NODE;
+var TEXT_NODE = doc.TEXT_NODE;
+var DOCUMENT_NODE = doc.DOCUMENT_NODE;
+var DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+$custom((el) => el.nodeType === DOCUMENT_NODE);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/json.js
+var stringify = JSON.stringify;
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/symbol.js
+var create5 = Symbol;
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/logging.common.js
+var BOLD = create5();
+var UNBOLD = create5();
+var BLUE = create5();
+var GREY = create5();
+var GREEN = create5();
+var RED = create5();
+var PURPLE = create5();
+var ORANGE = create5();
+var UNCOLOR = create5();
+var computeNoColorLoggingArgs = (args) => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */
+    /** @type {[function]} */
+    args[0]();
+  }
+  const strBuilder = [];
+  const logArgs = [];
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) {
+      break;
+    } else if (arg.constructor === String || arg.constructor === Number) {
+      strBuilder.push(arg);
+    } else if (arg.constructor === Object) {
+      break;
+    }
+  }
+  if (i > 0) {
+    logArgs.push(strBuilder.join(""));
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (!(arg instanceof Symbol)) {
+      logArgs.push(arg);
+    }
+  }
+  return logArgs;
+};
+var loggingColors = [GREEN, PURPLE, ORANGE, BLUE];
+var nextColor = 0;
+var lastLoggingTime = chunkYQQXFRZT_js.getUnixTime();
+var createModuleLogger = (_print, moduleName) => {
+  const color = loggingColors[nextColor];
+  const debugRegexVar = chunkYQQXFRZT_js.getVariable("log");
+  const doLogging = debugRegexVar !== null && (debugRegexVar === "*" || debugRegexVar === "true" || new RegExp(debugRegexVar, "gi").test(moduleName));
+  nextColor = (nextColor + 1) % loggingColors.length;
+  moduleName += ": ";
+  return !doLogging ? chunkYQQXFRZT_js.nop : (...args) => {
+    if (args.length === 1 && args[0]?.constructor === Function) {
+      args = args[0]();
+    }
+    const timeNow = chunkYQQXFRZT_js.getUnixTime();
+    const timeDiff = timeNow - lastLoggingTime;
+    lastLoggingTime = timeNow;
+    _print(
+      color,
+      moduleName,
+      UNCOLOR,
+      ...args.map((arg) => {
+        if (arg != null && arg.constructor === Uint8Array) {
+          arg = Array.from(arg);
+        }
+        const t = typeof arg;
+        switch (t) {
+          case "string":
+          case "symbol":
+            return arg;
+          default: {
+            return stringify(arg);
+          }
+        }
+      }),
+      color,
+      " +" + timeDiff + "ms"
+    );
+  };
+};
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/logging.js
+var _browserStyleMap = {
+  [BOLD]: create4("font-weight", "bold"),
+  [UNBOLD]: create4("font-weight", "normal"),
+  [BLUE]: create4("color", "blue"),
+  [GREEN]: create4("color", "green"),
+  [GREY]: create4("color", "grey"),
+  [RED]: create4("color", "red"),
+  [PURPLE]: create4("color", "purple"),
+  [ORANGE]: create4("color", "orange"),
+  // not well supported in chrome when debugging node with inspector - TODO: deprecate
+  [UNCOLOR]: create4("color", "black")
+};
+var computeBrowserLoggingArgs = (args) => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */
+    /** @type {[function]} */
+    args[0]();
+  }
+  const strBuilder = [];
+  const styles = [];
+  const currentStyle = chunkYQQXFRZT_js.create();
+  let logArgs = [];
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    const style = _browserStyleMap[arg];
+    if (style !== void 0) {
+      currentStyle.set(style.left, style.right);
+    } else {
+      if (arg === void 0) {
+        break;
+      }
+      if (arg.constructor === String || arg.constructor === Number) {
+        const style2 = mapToStyleString(currentStyle);
+        if (i > 0 || style2.length > 0) {
+          strBuilder.push("%c" + arg);
+          styles.push(style2);
+        } else {
+          strBuilder.push(arg);
+        }
+      } else {
+        break;
+      }
+    }
+  }
+  if (i > 0) {
+    logArgs = styles;
+    logArgs.unshift(strBuilder.join(""));
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (!(arg instanceof Symbol)) {
+      logArgs.push(arg);
+    }
+  }
+  return logArgs;
+};
+var computeLoggingArgs = chunkYQQXFRZT_js.supportsColor ? computeBrowserLoggingArgs : computeNoColorLoggingArgs;
+var print = (...args) => {
+  console.log(...computeLoggingArgs(args));
+  vconsoles.forEach((vc) => vc.print(args));
+};
+var vconsoles = chunkYQQXFRZT_js.create2();
+var createModuleLogger2 = (moduleName) => createModuleLogger(print, moduleName);
+
+// ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/promise.js
+Promise.all.bind(Promise);
+var reject = (reason) => Promise.reject(reason);
+var resolve = (res) => Promise.resolve(res);
 
 // ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/mutex.js
 var createMutex = () => {
@@ -2719,8 +3670,8 @@ var import_simplepeer_min = chunk4VNS5WPM_js.__toESM(require_simplepeer_min(), 1
 
 // ../../node_modules/.bun/y-webrtc@10.3.0+48ebd0cf55a3d4ab/node_modules/y-webrtc/src/crypto.js
 var deriveKey = (secret, roomName) => {
-  const secretBuffer = chunkZYQT7I5C_js.encodeUtf8(secret).buffer;
-  const salt = chunkZYQT7I5C_js.encodeUtf8(roomName).buffer;
+  const secretBuffer = chunkYQQXFRZT_js.encodeUtf8(secret).buffer;
+  const salt = chunkYQQXFRZT_js.encodeUtf8(roomName).buffer;
   return crypto.subtle.importKey(
     "raw",
     secretBuffer,
@@ -2749,7 +3700,7 @@ var encrypt = (data, key) => {
   if (!key) {
     return (
       /** @type {PromiseLike<Uint8Array>} */
-      chunkZYQT7I5C_js.resolve(data)
+      resolve(data)
     );
   }
   const iv = crypto.getRandomValues(new Uint8Array(12));
@@ -2761,32 +3712,32 @@ var encrypt = (data, key) => {
     key,
     data
   ).then((cipher) => {
-    const encryptedDataEncoder = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarString(encryptedDataEncoder, "AES-GCM");
-    chunkZYQT7I5C_js.writeVarUint8Array(encryptedDataEncoder, iv);
-    chunkZYQT7I5C_js.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher));
-    return chunkZYQT7I5C_js.toUint8Array(encryptedDataEncoder);
+    const encryptedDataEncoder = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarString(encryptedDataEncoder, "AES-GCM");
+    chunkYQQXFRZT_js.writeVarUint8Array(encryptedDataEncoder, iv);
+    chunkYQQXFRZT_js.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher));
+    return chunkYQQXFRZT_js.toUint8Array(encryptedDataEncoder);
   });
 };
 var encryptJson = (data, key) => {
-  const dataEncoder = chunkZYQT7I5C_js.createEncoder();
-  chunkZYQT7I5C_js.writeAny(dataEncoder, data);
-  return encrypt(chunkZYQT7I5C_js.toUint8Array(dataEncoder), key);
+  const dataEncoder = chunkYQQXFRZT_js.createEncoder();
+  chunkYQQXFRZT_js.writeAny(dataEncoder, data);
+  return encrypt(chunkYQQXFRZT_js.toUint8Array(dataEncoder), key);
 };
 var decrypt = (data, key) => {
   if (!key) {
     return (
       /** @type {PromiseLike<Uint8Array>} */
-      chunkZYQT7I5C_js.resolve(data)
+      resolve(data)
     );
   }
-  const dataDecoder = chunkZYQT7I5C_js.createDecoder(data);
-  const algorithm = chunkZYQT7I5C_js.readVarString(dataDecoder);
+  const dataDecoder = chunkYQQXFRZT_js.createDecoder(data);
+  const algorithm = chunkYQQXFRZT_js.readVarString(dataDecoder);
   if (algorithm !== "AES-GCM") {
-    chunkZYQT7I5C_js.reject(chunkZYQT7I5C_js.create2("Unknown encryption algorithm"));
+    reject(chunkYQQXFRZT_js.create3("Unknown encryption algorithm"));
   }
-  const iv = chunkZYQT7I5C_js.readVarUint8Array(dataDecoder);
-  const cipher = chunkZYQT7I5C_js.readVarUint8Array(dataDecoder);
+  const iv = chunkYQQXFRZT_js.readVarUint8Array(dataDecoder);
+  const cipher = chunkYQQXFRZT_js.readVarUint8Array(dataDecoder);
   return crypto.subtle.decrypt(
     {
       name: "AES-GCM",
@@ -2797,11 +3748,11 @@ var decrypt = (data, key) => {
   ).then((data2) => new Uint8Array(data2));
 };
 var decryptJson = (data, key) => decrypt(data, key).then(
-  (decryptedValue) => chunkZYQT7I5C_js.readAny(chunkZYQT7I5C_js.createDecoder(new Uint8Array(decryptedValue)))
+  (decryptedValue) => chunkYQQXFRZT_js.readAny(chunkYQQXFRZT_js.createDecoder(new Uint8Array(decryptedValue)))
 );
 
 // ../../node_modules/.bun/y-webrtc@10.3.0+48ebd0cf55a3d4ab/node_modules/y-webrtc/src/y-webrtc.js
-var log = chunkZYQT7I5C_js.createModuleLogger("y-webrtc");
+var log = createModuleLogger2("y-webrtc");
 var messageSync = 0;
 var messageQueryAwareness = 3;
 var messageAwareness = 1;
@@ -2818,42 +3769,42 @@ var checkIsSynced = (room) => {
   if (!synced && room.synced || synced && !room.synced) {
     room.synced = synced;
     room.provider.emit("synced", [{ synced }]);
-    log("synced ", chunkZYQT7I5C_js.BOLD, room.name, chunkZYQT7I5C_js.UNBOLD, " with all peers");
+    log("synced ", BOLD, room.name, UNBOLD, " with all peers");
   }
 };
 var readMessage = (room, buf, syncedCallback) => {
-  const decoder = chunkZYQT7I5C_js.createDecoder(buf);
-  const encoder = chunkZYQT7I5C_js.createEncoder();
-  const messageType = chunkZYQT7I5C_js.readVarUint(decoder);
+  const decoder = chunkYQQXFRZT_js.createDecoder(buf);
+  const encoder = chunkYQQXFRZT_js.createEncoder();
+  const messageType = chunkYQQXFRZT_js.readVarUint(decoder);
   if (room === void 0) {
     return null;
   }
   const awareness = room.awareness;
-  const doc = room.doc;
+  const doc2 = room.doc;
   let sendReply = false;
   switch (messageType) {
     case messageSync: {
-      chunkZYQT7I5C_js.writeVarUint(encoder, messageSync);
-      const syncMessageType = chunkNB7M4XBG_js.readSyncMessage(decoder, encoder, doc, room);
-      if (syncMessageType === chunkNB7M4XBG_js.messageYjsSyncStep2 && !room.synced) {
+      chunkYQQXFRZT_js.writeVarUint(encoder, messageSync);
+      const syncMessageType = chunkYQQXFRZT_js.readSyncMessage(decoder, encoder, doc2, room);
+      if (syncMessageType === chunkYQQXFRZT_js.messageYjsSyncStep2 && !room.synced) {
         syncedCallback();
       }
-      if (syncMessageType === chunkNB7M4XBG_js.messageYjsSyncStep1) {
+      if (syncMessageType === chunkYQQXFRZT_js.messageYjsSyncStep1) {
         sendReply = true;
       }
       break;
     }
     case messageQueryAwareness:
-      chunkZYQT7I5C_js.writeVarUint(encoder, messageAwareness);
-      chunkZYQT7I5C_js.writeVarUint8Array(encoder, chunkNB7M4XBG_js.encodeAwarenessUpdate(awareness, Array.from(awareness.getStates().keys())));
+      chunkYQQXFRZT_js.writeVarUint(encoder, messageAwareness);
+      chunkYQQXFRZT_js.writeVarUint8Array(encoder, chunkYQQXFRZT_js.encodeAwarenessUpdate(awareness, Array.from(awareness.getStates().keys())));
       sendReply = true;
       break;
     case messageAwareness:
-      chunkNB7M4XBG_js.applyAwarenessUpdate(awareness, chunkZYQT7I5C_js.readVarUint8Array(decoder), room);
+      chunkYQQXFRZT_js.applyAwarenessUpdate(awareness, chunkYQQXFRZT_js.readVarUint8Array(decoder), room);
       break;
     case messageBcPeerId: {
-      const add = chunkZYQT7I5C_js.readUint8(decoder) === 1;
-      const peerName = chunkZYQT7I5C_js.readVarString(decoder);
+      const add = chunkYQQXFRZT_js.readUint8(decoder) === 1;
+      const peerName = chunkYQQXFRZT_js.readVarString(decoder);
       if (peerName !== room.peerId && (room.bcConns.has(peerName) && !add || !room.bcConns.has(peerName) && add)) {
         const removed = [];
         const added = [];
@@ -2885,22 +3836,22 @@ var readMessage = (room, buf, syncedCallback) => {
 };
 var readPeerMessage = (peerConn, buf) => {
   const room = peerConn.room;
-  log("received message from ", chunkZYQT7I5C_js.BOLD, peerConn.remotePeerId, chunkZYQT7I5C_js.GREY, " (", room.name, ")", chunkZYQT7I5C_js.UNBOLD, chunkZYQT7I5C_js.UNCOLOR);
+  log("received message from ", BOLD, peerConn.remotePeerId, GREY, " (", room.name, ")", UNBOLD, UNCOLOR);
   return readMessage(room, buf, () => {
     peerConn.synced = true;
-    log("synced ", chunkZYQT7I5C_js.BOLD, room.name, chunkZYQT7I5C_js.UNBOLD, " with ", chunkZYQT7I5C_js.BOLD, peerConn.remotePeerId);
+    log("synced ", BOLD, room.name, UNBOLD, " with ", BOLD, peerConn.remotePeerId);
     checkIsSynced(room);
   });
 };
 var sendWebrtcConn = (webrtcConn, encoder) => {
-  log("send message to ", chunkZYQT7I5C_js.BOLD, webrtcConn.remotePeerId, chunkZYQT7I5C_js.UNBOLD, chunkZYQT7I5C_js.GREY, " (", webrtcConn.room.name, ")", chunkZYQT7I5C_js.UNCOLOR);
+  log("send message to ", BOLD, webrtcConn.remotePeerId, UNBOLD, GREY, " (", webrtcConn.room.name, ")", UNCOLOR);
   try {
-    webrtcConn.peer.send(chunkZYQT7I5C_js.toUint8Array(encoder));
+    webrtcConn.peer.send(chunkYQQXFRZT_js.toUint8Array(encoder));
   } catch (e) {
   }
 };
 var broadcastWebrtcConn = (room, m) => {
-  log("broadcast message in ", chunkZYQT7I5C_js.BOLD, room.name, chunkZYQT7I5C_js.UNBOLD);
+  log("broadcast message in ", BOLD, room.name, UNBOLD);
   room.webrtcConns.forEach((conn) => {
     try {
       conn.peer.send(m);
@@ -2916,7 +3867,7 @@ var WebrtcConn = class {
    * @param {Room} room
    */
   constructor(signalingConn, initiator, remotePeerId, room) {
-    log("establishing connection to ", chunkZYQT7I5C_js.BOLD, remotePeerId);
+    log("establishing connection to ", BOLD, remotePeerId);
     this.room = room;
     this.remotePeerId = remotePeerId;
     this.glareToken = void 0;
@@ -2931,20 +3882,20 @@ var WebrtcConn = class {
       publishSignalingMessage(signalingConn, room, { to: remotePeerId, from: room.peerId, type: "signal", token: this.glareToken, signal });
     });
     this.peer.on("connect", () => {
-      log("connected to ", chunkZYQT7I5C_js.BOLD, remotePeerId);
+      log("connected to ", BOLD, remotePeerId);
       this.connected = true;
       const provider = room.provider;
-      const doc = provider.doc;
+      const doc2 = provider.doc;
       const awareness = room.awareness;
-      const encoder = chunkZYQT7I5C_js.createEncoder();
-      chunkZYQT7I5C_js.writeVarUint(encoder, messageSync);
-      chunkNB7M4XBG_js.writeSyncStep1(encoder, doc);
+      const encoder = chunkYQQXFRZT_js.createEncoder();
+      chunkYQQXFRZT_js.writeVarUint(encoder, messageSync);
+      chunkYQQXFRZT_js.writeSyncStep1(encoder, doc2);
       sendWebrtcConn(this, encoder);
       const awarenessStates = awareness.getStates();
       if (awarenessStates.size > 0) {
-        const encoder2 = chunkZYQT7I5C_js.createEncoder();
-        chunkZYQT7I5C_js.writeVarUint(encoder2, messageAwareness);
-        chunkZYQT7I5C_js.writeVarUint8Array(encoder2, chunkNB7M4XBG_js.encodeAwarenessUpdate(awareness, Array.from(awarenessStates.keys())));
+        const encoder2 = chunkYQQXFRZT_js.createEncoder();
+        chunkYQQXFRZT_js.writeVarUint(encoder2, messageAwareness);
+        chunkYQQXFRZT_js.writeVarUint8Array(encoder2, chunkYQQXFRZT_js.encodeAwarenessUpdate(awareness, Array.from(awarenessStates.keys())));
         sendWebrtcConn(this, encoder2);
       }
     });
@@ -2962,11 +3913,11 @@ var WebrtcConn = class {
       }
       checkIsSynced(room);
       this.peer.destroy();
-      log("closed connection to ", chunkZYQT7I5C_js.BOLD, remotePeerId);
+      log("closed connection to ", BOLD, remotePeerId);
       announceSignalingInfo(room);
     });
     this.peer.on("error", (err) => {
-      log("Error in connection to ", chunkZYQT7I5C_js.BOLD, remotePeerId, ": ", err);
+      log("Error in connection to ", BOLD, remotePeerId, ": ", err);
       announceSignalingInfo(room);
     });
     this.peer.on("data", (data) => {
@@ -2982,7 +3933,7 @@ var WebrtcConn = class {
 };
 var broadcastBcMessage = (room, m) => encrypt(m, room.key).then(
   (data) => room.mux(
-    () => chunkNB7M4XBG_js.publish(room.name, data)
+    () => chunkYQQXFRZT_js.publish(room.name, data)
   )
 );
 var broadcastRoomMessage = (room, m) => {
@@ -3003,11 +3954,11 @@ var announceSignalingInfo = (room) => {
 };
 var broadcastBcPeerId = (room) => {
   if (room.provider.filterBcConns) {
-    const encoderPeerIdBc = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderPeerIdBc, messageBcPeerId);
-    chunkZYQT7I5C_js.writeUint8(encoderPeerIdBc, 1);
-    chunkZYQT7I5C_js.writeVarString(encoderPeerIdBc, room.peerId);
-    broadcastBcMessage(room, chunkZYQT7I5C_js.toUint8Array(encoderPeerIdBc));
+    const encoderPeerIdBc = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderPeerIdBc, messageBcPeerId);
+    chunkYQQXFRZT_js.writeUint8(encoderPeerIdBc, 1);
+    chunkYQQXFRZT_js.writeVarString(encoderPeerIdBc, room.peerId);
+    broadcastBcMessage(room, chunkYQQXFRZT_js.toUint8Array(encoderPeerIdBc));
   }
 };
 var Room = class {
@@ -3017,9 +3968,9 @@ var Room = class {
    * @param {string} name
    * @param {CryptoKey|null} key
    */
-  constructor(doc, provider, name, key) {
-    this.peerId = chunkZYQT7I5C_js.uuidv4();
-    this.doc = doc;
+  constructor(doc2, provider, name, key) {
+    this.peerId = uuidv4();
+    this.doc = doc2;
     this.awareness = provider.awareness;
     this.provider = provider;
     this.synced = false;
@@ -3034,25 +3985,25 @@ var Room = class {
         const reply = readMessage(this, m, () => {
         });
         if (reply) {
-          broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(reply));
+          broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(reply));
         }
       })
     );
     this._docUpdateHandler = (update, _origin) => {
-      const encoder = chunkZYQT7I5C_js.createEncoder();
-      chunkZYQT7I5C_js.writeVarUint(encoder, messageSync);
-      chunkNB7M4XBG_js.writeUpdate(encoder, update);
-      broadcastRoomMessage(this, chunkZYQT7I5C_js.toUint8Array(encoder));
+      const encoder = chunkYQQXFRZT_js.createEncoder();
+      chunkYQQXFRZT_js.writeVarUint(encoder, messageSync);
+      chunkYQQXFRZT_js.writeUpdate(encoder, update);
+      broadcastRoomMessage(this, chunkYQQXFRZT_js.toUint8Array(encoder));
     };
     this._awarenessUpdateHandler = ({ added, updated, removed }, _origin) => {
       const changedClients = added.concat(updated).concat(removed);
-      const encoderAwareness = chunkZYQT7I5C_js.createEncoder();
-      chunkZYQT7I5C_js.writeVarUint(encoderAwareness, messageAwareness);
-      chunkZYQT7I5C_js.writeVarUint8Array(encoderAwareness, chunkNB7M4XBG_js.encodeAwarenessUpdate(this.awareness, changedClients));
-      broadcastRoomMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderAwareness));
+      const encoderAwareness = chunkYQQXFRZT_js.createEncoder();
+      chunkYQQXFRZT_js.writeVarUint(encoderAwareness, messageAwareness);
+      chunkYQQXFRZT_js.writeVarUint8Array(encoderAwareness, chunkYQQXFRZT_js.encodeAwarenessUpdate(this.awareness, changedClients));
+      broadcastRoomMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderAwareness));
     };
     this._beforeUnloadHandler = () => {
-      chunkNB7M4XBG_js.removeAwarenessStates(this.awareness, [doc.clientID], "window unload");
+      chunkYQQXFRZT_js.removeAwarenessStates(this.awareness, [doc2.clientID], "window unload");
       rooms.forEach((room) => {
         room.disconnect();
       });
@@ -3068,24 +4019,24 @@ var Room = class {
     this.awareness.on("update", this._awarenessUpdateHandler);
     announceSignalingInfo(this);
     const roomName = this.name;
-    chunkNB7M4XBG_js.subscribe(roomName, this._bcSubscriber);
+    chunkYQQXFRZT_js.subscribe(roomName, this._bcSubscriber);
     this.bcconnected = true;
     broadcastBcPeerId(this);
-    const encoderSync = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderSync, messageSync);
-    chunkNB7M4XBG_js.writeSyncStep1(encoderSync, this.doc);
-    broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderSync));
-    const encoderState = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderState, messageSync);
-    chunkNB7M4XBG_js.writeSyncStep2(encoderState, this.doc);
-    broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderState));
-    const encoderAwarenessQuery = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
-    broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderAwarenessQuery));
-    const encoderAwarenessState = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderAwarenessState, messageAwareness);
-    chunkZYQT7I5C_js.writeVarUint8Array(encoderAwarenessState, chunkNB7M4XBG_js.encodeAwarenessUpdate(this.awareness, [this.doc.clientID]));
-    broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderAwarenessState));
+    const encoderSync = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderSync, messageSync);
+    chunkYQQXFRZT_js.writeSyncStep1(encoderSync, this.doc);
+    broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderSync));
+    const encoderState = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderState, messageSync);
+    chunkYQQXFRZT_js.writeSyncStep2(encoderState, this.doc);
+    broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderState));
+    const encoderAwarenessQuery = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
+    broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderAwarenessQuery));
+    const encoderAwarenessState = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderAwarenessState, messageAwareness);
+    chunkYQQXFRZT_js.writeVarUint8Array(encoderAwarenessState, chunkYQQXFRZT_js.encodeAwarenessUpdate(this.awareness, [this.doc.clientID]));
+    broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderAwarenessState));
   }
   disconnect() {
     signalingConns.forEach((conn) => {
@@ -3093,13 +4044,13 @@ var Room = class {
         conn.send({ type: "unsubscribe", topics: [this.name] });
       }
     });
-    chunkNB7M4XBG_js.removeAwarenessStates(this.awareness, [this.doc.clientID], "disconnect");
-    const encoderPeerIdBc = chunkZYQT7I5C_js.createEncoder();
-    chunkZYQT7I5C_js.writeVarUint(encoderPeerIdBc, messageBcPeerId);
-    chunkZYQT7I5C_js.writeUint8(encoderPeerIdBc, 0);
-    chunkZYQT7I5C_js.writeVarString(encoderPeerIdBc, this.peerId);
-    broadcastBcMessage(this, chunkZYQT7I5C_js.toUint8Array(encoderPeerIdBc));
-    chunkNB7M4XBG_js.unsubscribe(this.name, this._bcSubscriber);
+    chunkYQQXFRZT_js.removeAwarenessStates(this.awareness, [this.doc.clientID], "disconnect");
+    const encoderPeerIdBc = chunkYQQXFRZT_js.createEncoder();
+    chunkYQQXFRZT_js.writeVarUint(encoderPeerIdBc, messageBcPeerId);
+    chunkYQQXFRZT_js.writeUint8(encoderPeerIdBc, 0);
+    chunkYQQXFRZT_js.writeVarString(encoderPeerIdBc, this.peerId);
+    broadcastBcMessage(this, chunkYQQXFRZT_js.toUint8Array(encoderPeerIdBc));
+    chunkYQQXFRZT_js.unsubscribe(this.name, this._bcSubscriber);
     this.bcconnected = false;
     this.doc.off("update", this._docUpdateHandler);
     this.awareness.off("update", this._awarenessUpdateHandler);
@@ -3114,11 +4065,11 @@ var Room = class {
     }
   }
 };
-var openRoom = (doc, provider, name, key) => {
+var openRoom = (doc2, provider, name, key) => {
   if (rooms.has(name)) {
-    throw chunkZYQT7I5C_js.create2(`A Yjs Doc connected to room "${name}" already exists!`);
+    throw chunkYQQXFRZT_js.create3(`A Yjs Doc connected to room "${name}" already exists!`);
   }
-  const room = new Room(doc, provider, name, key);
+  const room = new Room(doc2, provider, name, key);
   rooms.set(
     name,
     /** @type {Room} */
@@ -3129,7 +4080,7 @@ var openRoom = (doc, provider, name, key) => {
 var publishSignalingMessage = (conn, room, data) => {
   if (room.key) {
     encryptJson(data, room.key).then((data2) => {
-      conn.send({ type: "publish", topic: room.name, data: chunkZYQT7I5C_js.toBase64(data2) });
+      conn.send({ type: "publish", topic: room.name, data: chunkYQQXFRZT_js.toBase64(data2) });
     });
   } else {
     conn.send({ type: "publish", topic: room.name, data });
@@ -3171,7 +4122,7 @@ var SignalingConn = class extends WebsocketClient {
             switch (data.type) {
               case "announce":
                 if (webrtcConns.size < room.provider.maxConns) {
-                  chunkZYQT7I5C_js.setIfUndefined(webrtcConns, data.from, () => new WebrtcConn(this, true, data.from, room));
+                  chunkYQQXFRZT_js.setIfUndefined(webrtcConns, data.from, () => new WebrtcConn(this, true, data.from, room));
                   emitPeerChange();
                 }
                 break;
@@ -3194,7 +4145,7 @@ var SignalingConn = class extends WebsocketClient {
                   existingConn.glareToken = void 0;
                 }
                 if (data.to === peerId) {
-                  chunkZYQT7I5C_js.setIfUndefined(webrtcConns, data.from, () => new WebrtcConn(this, false, data.from, room)).peer.signal(data.signal);
+                  chunkYQQXFRZT_js.setIfUndefined(webrtcConns, data.from, () => new WebrtcConn(this, false, data.from, room)).peer.signal(data.signal);
                   emitPeerChange();
                 }
                 break;
@@ -3202,7 +4153,7 @@ var SignalingConn = class extends WebsocketClient {
           };
           if (room.key) {
             if (typeof m.data === "string") {
-              decryptJson(chunkZYQT7I5C_js.fromBase64(m.data), room.key).then(execMessage);
+              decryptJson(chunkYQQXFRZT_js.fromBase64(m.data), room.key).then(execMessage);
             }
           } else {
             execMessage(m.data);
@@ -3218,17 +4169,17 @@ var emitStatus = (provider) => {
     connected: provider.connected
   }]);
 };
-var WebrtcProvider = class extends chunkZYQT7I5C_js.ObservableV2 {
+var WebrtcProvider = class extends chunkYQQXFRZT_js.ObservableV2 {
   /**
    * @param {string} roomName
    * @param {Y.Doc} doc
    * @param {ProviderOptions?} opts
    */
-  constructor(roomName, doc, {
+  constructor(roomName, doc2, {
     signaling = ["wss://y-webrtc-eu.fly.dev"],
     password = null,
-    awareness = new chunkNB7M4XBG_js.Awareness(doc),
-    maxConns = 20 + chunkZYQT7I5C_js.floor(chunkZYQT7I5C_js.rand() * 15),
+    awareness = new chunkYQQXFRZT_js.Awareness(doc2),
+    maxConns = 20 + chunkYQQXFRZT_js.floor(rand() * 15),
     // the random factor reduces the chance that n clients form a cluster
     filterBcConns = true,
     peerOpts = {}
@@ -3236,7 +4187,7 @@ var WebrtcProvider = class extends chunkZYQT7I5C_js.ObservableV2 {
   } = {}) {
     super();
     this.roomName = roomName;
-    this.doc = doc;
+    this.doc = doc2;
     this.filterBcConns = filterBcConns;
     this.awareness = awareness;
     this.shouldConnect = false;
@@ -3246,11 +4197,11 @@ var WebrtcProvider = class extends chunkZYQT7I5C_js.ObservableV2 {
     this.peerOpts = peerOpts;
     this.key = password ? deriveKey(password, roomName) : (
       /** @type {PromiseLike<null>} */
-      chunkZYQT7I5C_js.resolve(null)
+      resolve(null)
     );
     this.room = null;
     this.key.then((key) => {
-      this.room = openRoom(doc, this, roomName, key);
+      this.room = openRoom(doc2, this, roomName, key);
       if (this.shouldConnect) {
         this.room.connect();
       } else {
@@ -3260,7 +4211,7 @@ var WebrtcProvider = class extends chunkZYQT7I5C_js.ObservableV2 {
     });
     this.connect();
     this.destroy = this.destroy.bind(this);
-    doc.on("destroy", this.destroy);
+    doc2.on("destroy", this.destroy);
   }
   /**
    * Indicates whether the provider is looking for other peers.
@@ -3280,7 +4231,7 @@ var WebrtcProvider = class extends chunkZYQT7I5C_js.ObservableV2 {
   connect() {
     this.shouldConnect = true;
     this.signalingUrls.forEach((url) => {
-      const signalingConn = chunkZYQT7I5C_js.setIfUndefined(signalingConns, url, () => new SignalingConn(url));
+      const signalingConn = chunkYQQXFRZT_js.setIfUndefined(signalingConns, url, () => new SignalingConn(url));
       this.signalingConns.push(signalingConn);
       signalingConn.providers.add(this);
     });