pptx-react-viewer 3.20.0 → 3.21.0

package/dist/{y-webrtc-7DLWG3LJ.mjs → y-webrtc-XJDH2YTR.mjs}

@@ -1,6 +1,6 @@
-import { writeSyncStep1, encodeAwarenessUpdate, writeUpdate, removeAwarenessStates, subscribe, writeSyncStep2, unsubscribe, Awareness, applyAwarenessUpdate, readSyncMessage, messageYjsSyncStep2, publish, messageYjsSyncStep1 } from './chunk-FXGO5KLU.mjs';
-import { createModuleLogger, BOLD, createEncoder, writeVarUint, writeVarUint8Array, uuidv4, toUint8Array, writeUint8, writeVarString, toBase64, fromBase64, ObservableV2, resolve, floor, rand, setIfUndefined, UNBOLD, GREY, UNCOLOR, createDecoder, readVarString, reject, create2, readVarUint8Array, readVarUint, readUint8, writeAny, Observable, getUnixTime, readAny, encodeUtf8, min, log10 } from './chunk-DWIIYEOG.mjs';
+import { getUnixTime, create2, floor, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, unexpectedCase, some, isArray, every, every2, create3, fromCharCode, hasProperty, getVariable, nop, equalityDeep, EqualityTraitSymbol, methodUnimplemented, equals, isObject, production, repeat, createEncoder, writeVarUint, writeSyncStep1, writeVarUint8Array, encodeAwarenessUpdate, toUint8Array, writeUpdate, removeAwarenessStates, subscribe, writeSyncStep2, writeUint8, writeVarString, unsubscribe, toBase64, fromBase64, ObservableV2, Awareness, setIfUndefined, createDecoder, readVarString, readVarUint8Array, readVarUint, readUint8, applyAwarenessUpdate, readSyncMessage, messageYjsSyncStep2, publish, writeAny, Observable, readAny, encodeUtf8, supportsColor, create, min, log10, map, messageYjsSyncStep1 } from './chunk-MRWGWKA2.mjs';
 import { __commonJS, __toESM, __require } from './chunk-XGB3TDIC.mjs';
+import 'yjs';
 
 // ../../node_modules/.bun/simple-peer@9.11.1/node_modules/simple-peer/simplepeer.min.js
 var require_simplepeer_min = __commonJS({
@@ -247,7 +247,7 @@ var require_simplepeer_min = __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);
@@ -259,7 +259,7 @@ var require_simplepeer_min = __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);
@@ -365,7 +365,7 @@ var require_simplepeer_min = __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;
             }
@@ -374,7 +374,7 @@ var require_simplepeer_min = __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];
@@ -386,7 +386,7 @@ var require_simplepeer_min = __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;
@@ -1360,9 +1360,9 @@ var require_simplepeer_min = __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) {
@@ -1483,7 +1483,7 @@ var require_simplepeer_min = __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;
@@ -1580,11 +1580,11 @@ var require_simplepeer_min = __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;
@@ -1607,7 +1607,7 @@ var require_simplepeer_min = __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;
@@ -1649,7 +1649,7 @@ var require_simplepeer_min = __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) {
@@ -1678,7 +1678,7 @@ var require_simplepeer_min = __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;
@@ -1696,7 +1696,7 @@ var require_simplepeer_min = __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;
@@ -2694,6 +2694,957 @@ var WebsocketClient = class extends 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) => floor(gen.next() * (max + 1 - min2) + min2);
+var int32 = (gen, min2, max) => floor(gen.next() * (max + 1 - min2) + min2);
+var int31 = (gen, min2, max) => int32(gen, min2, max);
+var letter = (gen) => 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(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[EqualityTraitSymbol]) return equals(a, b);
+  if (isArray(a)) {
+    return every(
+      a,
+      (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
+    );
+  } else if (isObject(a)) {
+    return 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 && equalityDeep(this.shape, other.shape);
+  }
+  [schemaSymbol]() {
+    return true;
+  }
+  /**
+   * @param {object} other
+   */
+  [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) {
+    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);
+  }
+  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 every2(this.shape, (vv, vk) => {
+      const c = this._isPartial && !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 && 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 && 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 = isArray(o) && 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) => 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 = 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 = 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
+      )
+    );
+  }
+  unexpectedCase();
+};
+var assert = production ? () => {
+} : (o, schema) => {
+  const err = new ValidationError();
+  if (!schema.check(o, err)) {
+    throw 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 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, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, 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) => 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 = getUnixTime();
+var createModuleLogger = (_print, moduleName) => {
+  const color = loggingColors[nextColor];
+  const debugRegexVar = getVariable("log");
+  const doLogging = debugRegexVar !== null && (debugRegexVar === "*" || debugRegexVar === "true" || new RegExp(debugRegexVar, "gi").test(moduleName));
+  nextColor = (nextColor + 1) % loggingColors.length;
+  moduleName += ": ";
+  return !doLogging ? nop : (...args) => {
+    if (args.length === 1 && args[0]?.constructor === Function) {
+      args = args[0]();
+    }
+    const timeNow = 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 = 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 = supportsColor ? computeBrowserLoggingArgs : computeNoColorLoggingArgs;
+var print = (...args) => {
+  console.log(...computeLoggingArgs(args));
+  vconsoles.forEach((vc) => vc.print(args));
+};
+var vconsoles = 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 = () => {
@@ -2781,7 +3732,7 @@ var decrypt = (data, key) => {
   const dataDecoder = createDecoder(data);
   const algorithm = readVarString(dataDecoder);
   if (algorithm !== "AES-GCM") {
-    reject(create2("Unknown encryption algorithm"));
+    reject(create3("Unknown encryption algorithm"));
   }
   const iv = readVarUint8Array(dataDecoder);
   const cipher = readVarUint8Array(dataDecoder);
@@ -2799,7 +3750,7 @@ var decryptJson = (data, key) => decrypt(data, key).then(
 );
 
 // ../../node_modules/.bun/y-webrtc@10.3.0+48ebd0cf55a3d4ab/node_modules/y-webrtc/src/y-webrtc.js
-var log = createModuleLogger("y-webrtc");
+var log = createModuleLogger2("y-webrtc");
 var messageSync = 0;
 var messageQueryAwareness = 3;
 var messageAwareness = 1;
@@ -2827,12 +3778,12 @@ var readMessage = (room, buf, syncedCallback) => {
     return null;
   }
   const awareness = room.awareness;
-  const doc = room.doc;
+  const doc2 = room.doc;
   let sendReply = false;
   switch (messageType) {
     case messageSync: {
       writeVarUint(encoder, messageSync);
-      const syncMessageType = readSyncMessage(decoder, encoder, doc, room);
+      const syncMessageType = readSyncMessage(decoder, encoder, doc2, room);
       if (syncMessageType === messageYjsSyncStep2 && !room.synced) {
         syncedCallback();
       }
@@ -2932,11 +3883,11 @@ var WebrtcConn = class {
       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 = createEncoder();
       writeVarUint(encoder, messageSync);
-      writeSyncStep1(encoder, doc);
+      writeSyncStep1(encoder, doc2);
       sendWebrtcConn(this, encoder);
       const awarenessStates = awareness.getStates();
       if (awarenessStates.size > 0) {
@@ -3015,9 +3966,9 @@ var Room = class {
    * @param {string} name
    * @param {CryptoKey|null} key
    */
-  constructor(doc, provider, name, key) {
+  constructor(doc2, provider, name, key) {
     this.peerId = uuidv4();
-    this.doc = doc;
+    this.doc = doc2;
     this.awareness = provider.awareness;
     this.provider = provider;
     this.synced = false;
@@ -3050,7 +4001,7 @@ var Room = class {
       broadcastRoomMessage(this, toUint8Array(encoderAwareness));
     };
     this._beforeUnloadHandler = () => {
-      removeAwarenessStates(this.awareness, [doc.clientID], "window unload");
+      removeAwarenessStates(this.awareness, [doc2.clientID], "window unload");
       rooms.forEach((room) => {
         room.disconnect();
       });
@@ -3112,11 +4063,11 @@ var Room = class {
     }
   }
 };
-var openRoom = (doc, provider, name, key) => {
+var openRoom = (doc2, provider, name, key) => {
   if (rooms.has(name)) {
-    throw create2(`A Yjs Doc connected to room "${name}" already exists!`);
+    throw 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} */
@@ -3222,10 +4173,10 @@ var WebrtcProvider = class extends ObservableV2 {
    * @param {Y.Doc} doc
    * @param {ProviderOptions?} opts
    */
-  constructor(roomName, doc, {
+  constructor(roomName, doc2, {
     signaling = ["wss://y-webrtc-eu.fly.dev"],
     password = null,
-    awareness = new Awareness(doc),
+    awareness = new Awareness(doc2),
     maxConns = 20 + floor(rand() * 15),
     // the random factor reduces the chance that n clients form a cluster
     filterBcConns = true,
@@ -3234,7 +4185,7 @@ var WebrtcProvider = class extends ObservableV2 {
   } = {}) {
     super();
     this.roomName = roomName;
-    this.doc = doc;
+    this.doc = doc2;
     this.filterBcConns = filterBcConns;
     this.awareness = awareness;
     this.shouldConnect = false;
@@ -3248,7 +4199,7 @@ var WebrtcProvider = class extends ObservableV2 {
     );
     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 {
@@ -3258,7 +4209,7 @@ var WebrtcProvider = class extends 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.