@symbo.ls/sdk 2.33.41 → 2.34.1

package/dist/esm/services/CollabService.js

@@ -79,7 +79,7 @@ var init_set = __esm({
 });
 
 // ../../../node_modules/lib0/array.js
-var last, appendTo, from, isArray;
+var last, appendTo, from, every, some, unfold, isArray;
 var init_array = __esm({
   "../../../node_modules/lib0/array.js"() {
     last = (arr) => arr[arr.length - 1];
@@ -89,6 +89,29 @@ var init_array = __esm({
       }
     };
     from = Array.from;
+    every = (arr, f) => {
+      for (let i = 0; i < arr.length; i++) {
+        if (!f(arr[i], i, arr)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    some = (arr, f) => {
+      for (let i = 0; i < arr.length; i++) {
+        if (f(arr[i], i, arr)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    unfold = (len, f) => {
+      const array = new Array(len);
+      for (let i = 0; i < len; i++) {
+        array[i] = f(i, array);
+      }
+      return array;
+    };
     isArray = Array.isArray;
   }
 });
@@ -284,23 +307,24 @@ var init_binary = __esm({
 });
 
 // ../../../node_modules/lib0/number.js
-var MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, LOWEST_INT32, isInteger, isNaN3, parseInt2;
+var MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, LOWEST_INT32, isInteger2, isNaN3, parseInt2;
 var init_number = __esm({
   "../../../node_modules/lib0/number.js"() {
     init_math();
     MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
     MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
     LOWEST_INT32 = 1 << 31;
-    isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+    isInteger2 = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
     isNaN3 = Number.isNaN;
     parseInt2 = Number.parseInt;
   }
 });
 
 // ../../../node_modules/lib0/string.js
-var fromCharCode, fromCodePoint, MAX_UTF16_CHARACTER, toLowerCase, trimLeftRegex, trimLeft, fromCamelCaseRegex, fromCamelCase, _encodeUtf8Polyfill, utf8TextEncoder, _encodeUtf8Native, encodeUtf8, utf8TextDecoder;
+var fromCharCode, fromCodePoint, MAX_UTF16_CHARACTER, toLowerCase, trimLeftRegex, trimLeft, fromCamelCaseRegex, fromCamelCase, _encodeUtf8Polyfill, utf8TextEncoder, _encodeUtf8Native, encodeUtf8, utf8TextDecoder, repeat;
 var init_string = __esm({
   "../../../node_modules/lib0/string.js"() {
+    init_array();
     fromCharCode = String.fromCharCode;
     fromCodePoint = String.fromCodePoint;
     MAX_UTF16_CHARACTER = fromCharCode(65535);
@@ -308,7 +332,7 @@ var init_string = __esm({
     trimLeftRegex = /^\s*/g;
     trimLeft = (s) => s.replace(trimLeftRegex, "");
     fromCamelCaseRegex = /([A-Z])/g;
-    fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+    fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
     _encodeUtf8Polyfill = (str) => {
       const encodedString = unescape(encodeURIComponent(str));
       const len = encodedString.length;
@@ -327,6 +351,7 @@ var init_string = __esm({
     if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
       utf8TextDecoder = null;
     }
+    repeat = (source, n) => unfold(n, () => source).join("");
   }
 });
 
@@ -471,7 +496,7 @@ var init_encoding = __esm({
           writeVarString(encoder, data2);
           break;
         case "number":
-          if (isInteger(data2) && abs(data2) <= BITS31) {
+          if (isInteger2(data2) && abs(data2) <= BITS31) {
             write(encoder, 125);
             writeVarInt(encoder, data2);
           } else if (isFloat32(data2)) {
@@ -674,7 +699,7 @@ var init_decoding = __esm({
     errorIntegerOutOfRange = create3("Integer out of Range");
     Decoder2 = class {
       /**
-       * @param {Uint8Array} uint8Array Binary data to decode
+       * @param {Uint8Array<Buf>} uint8Array Binary data to decode
        */
       constructor(uint8Array) {
         this.arr = uint8Array;
@@ -1001,10 +1026,24 @@ var init_storage = __esm({
   }
 });
 
+// ../../../node_modules/lib0/trait/equality.js
+var EqualityTraitSymbol, equals;
+var init_equality = __esm({
+  "../../../node_modules/lib0/trait/equality.js"() {
+    EqualityTraitSymbol = Symbol("Equality");
+    equals = (a, b) => {
+      var _a;
+      return a === b || !!((_a = a == null ? void 0 : a[EqualityTraitSymbol]) == null ? void 0 : _a.call(a, b)) || false;
+    };
+  }
+});
+
 // ../../../node_modules/lib0/object.js
-var assign, keys, forEach, size, isEmpty, every, hasProperty, equalFlat, freeze, deepFreeze;
+var isObject2, assign, keys, forEach, size, isEmpty, every2, hasProperty, equalFlat, freeze, deepFreeze;
 var init_object = __esm({
   "../../../node_modules/lib0/object.js"() {
+    init_equality();
+    isObject2 = (o) => typeof o === "object";
     assign = Object.assign;
     keys = Object.keys;
     forEach = (obj, f) => {
@@ -1019,7 +1058,7 @@ var init_object = __esm({
       }
       return true;
     };
-    every = (obj, f) => {
+    every2 = (obj, f) => {
       for (const key in obj) {
         if (!f(obj[key], key)) {
           return false;
@@ -1028,7 +1067,7 @@ var init_object = __esm({
       return true;
     };
     hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-    equalFlat = (a, b) => a === b || size(a) === size(b) && every(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && b[key] === val);
+    equalFlat = (a, b) => a === b || size(a) === size(b) && every2(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && equals(b[key], val));
     freeze = Object.freeze;
     deepFreeze = (o) => {
       for (const key in o) {
@@ -1043,9 +1082,11 @@ var init_object = __esm({
 });
 
 // ../../../node_modules/lib0/function.js
-var callAll, id, isOneOf;
+var callAll, id, equalityDeep, isOneOf;
 var init_function = __esm({
   "../../../node_modules/lib0/function.js"() {
+    init_object();
+    init_equality();
     callAll = (fs, args2, i = 0) => {
       try {
         for (; i < fs.length; i++) {
@@ -1058,6 +1099,80 @@ var init_function = __esm({
       }
     };
     id = (a) => a;
+    equalityDeep = (a, b) => {
+      if (a === b) {
+        return true;
+      }
+      if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
+        return false;
+      }
+      if (a[EqualityTraitSymbol] != null) {
+        return a[EqualityTraitSymbol](b);
+      }
+      switch (a.constructor) {
+        case ArrayBuffer:
+          a = new Uint8Array(a);
+          b = new Uint8Array(b);
+        // eslint-disable-next-line no-fallthrough
+        case Uint8Array: {
+          if (a.byteLength !== b.byteLength) {
+            return false;
+          }
+          for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+              return false;
+            }
+          }
+          break;
+        }
+        case Set: {
+          if (a.size !== b.size) {
+            return false;
+          }
+          for (const value2 of a) {
+            if (!b.has(value2)) {
+              return false;
+            }
+          }
+          break;
+        }
+        case Map: {
+          if (a.size !== b.size) {
+            return false;
+          }
+          for (const key of a.keys()) {
+            if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+              return false;
+            }
+          }
+          break;
+        }
+        case void 0:
+        case Object:
+          if (size(a) !== size(b)) {
+            return false;
+          }
+          for (const key in a) {
+            if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+              return false;
+            }
+          }
+          break;
+        case Array:
+          if (a.length !== b.length) {
+            return false;
+          }
+          for (let i = 0; i < a.length; i++) {
+            if (!equalityDeep(a[i], b[i])) {
+              return false;
+            }
+          }
+          break;
+        default:
+          return false;
+      }
+      return true;
+    };
     isOneOf = (value2, options) => options.includes(value2);
   }
 });
@@ -1155,15 +1270,769 @@ var init_pair = __esm({
   }
 });
 
+// ../../../node_modules/lib0/prng.js
+var bool, int53, int32, int31, letter, word, oneOf;
+var init_prng = __esm({
+  "../../../node_modules/lib0/prng.js"() {
+    init_string();
+    init_math();
+    bool = (gen) => gen.next() >= 0.5;
+    int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+    int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+    int31 = (gen, min2, max2) => int32(gen, min2, max2);
+    letter = (gen) => fromCharCode(int31(gen, 97, 122));
+    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;
+    };
+    oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+  }
+});
+
+// ../../../node_modules/lib0/schema.js
+var schemaSymbol, ValidationError, shapeExtends, Schema, $ConstructedBy, $constructedBy, $$constructedBy, $Custom, $custom, $$custom, $Literal, $literal, $$literal, _regexEscape, _schemaStringTemplateToRegex, $StringTemplate, $$stringTemplate, isOptionalSymbol, $Optional, $$optional, $Never, $never, $$never, _$Object, $Object, $object, $$object, $objectAny, $Record, $record, $$record, $Tuple, $tuple, $$tuple, $Array, $array, $$array, $arrayAny, $InstanceOf, $instanceOf, $$instanceOf, $$schema, $Lambda, $$lambda, $function, $Intersection, $$intersect, $Union, $union, $$union, _t, $any, $$any, $bigint, $$bigint, $symbol, $$symbol, $number, $$number, $string, $$string, $boolean, $$boolean, $undefined, $$undefined, $void, $null, $$null, $uint8Array, $$uint8Array, $primitive, $json, $, assert, PatternMatcher, match, _random, random;
+var init_schema = __esm({
+  "../../../node_modules/lib0/schema.js"() {
+    init_object();
+    init_array();
+    init_error();
+    init_environment();
+    init_equality();
+    init_function();
+    init_string();
+    init_prng();
+    init_number();
+    schemaSymbol = Symbol("0schema");
+    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");
+      }
+    };
+    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 (isObject2(a)) {
+        return every2(
+          a,
+          (aitem, akey) => shapeExtends(aitem, b[akey])
+        );
+      }
+      return false;
+    };
+    Schema = class {
+      /**
+       * @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;
+      }
+    };
+    // 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
+     */
+    __publicField(Schema, "_dilutes", false);
+    $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 == null ? void 0 : o.constructor) === this.shape && (this._c == null || this._c(o));
+        !c && (err == null ? void 0 : err.extend(null, this.shape.name, o == null ? void 0 : o.constructor.name, (o == null ? void 0 : o.constructor) !== this.shape ? "Constructor match failed" : "Check failed"));
+        return c;
+      }
+    };
+    $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+    $$constructedBy = $constructedBy($ConstructedBy);
+    $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 == null ? void 0 : err.extend(null, "custom prop", o == null ? void 0 : o.constructor.name, "failed to check custom prop"));
+        return c;
+      }
+    };
+    $custom = (check) => new $Custom(check);
+    $$custom = $constructedBy($Custom);
+    $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 == null ? void 0 : err.extend(null, this.shape.join(" | "), o.toString()));
+        return c;
+      }
+    };
+    $literal = (...literals) => new $Literal(literals);
+    $$literal = $constructedBy($Literal);
+    _regexEscape = /** @type {any} */
+    RegExp.escape || /** @type {(str:string) => string} */
+    ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s));
+    _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();
+    };
+    $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 == null ? void 0 : err.extend(null, this._r.toString(), o.toString(), "String doesn't match string template."));
+        return c;
+      }
+    };
+    $$stringTemplate = $constructedBy($StringTemplate);
+    isOptionalSymbol = Symbol("optional");
+    $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 == null ? void 0 : err.extend(null, "undefined (optional)", "()"));
+        return c;
+      }
+      get [isOptionalSymbol]() {
+        return true;
+      }
+    };
+    $$optional = $constructedBy($Optional);
+    $Never = class extends Schema {
+      /**
+       * @param {any} _o
+       * @param {ValidationError} [err]
+       * @return {_o is never}
+       */
+      check(_o, err) {
+        err == null ? void 0 : err.extend(null, "never", typeof _o);
+        return false;
+      }
+    };
+    $never = new $Never();
+    $$never = $constructedBy($Never);
+    _$Object = class _$Object extends Schema {
+      /**
+       * @param {S} shape
+       * @param {boolean} partial
+       */
+      constructor(shape, partial = false) {
+        super();
+        this.shape = shape;
+        this._isPartial = partial;
+      }
+      /**
+       * @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 == null ? void 0 : 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 == null ? void 0 : err.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match"));
+          return c;
+        });
+      }
+    };
+    __publicField(_$Object, "_dilutes", true);
+    $Object = _$Object;
+    $object = (def) => (
+      /** @type {any} */
+      new $Object(def)
+    );
+    $$object = $constructedBy($Object);
+    $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
+    $Record = class extends Schema {
+      /**
+       * @param {Keys} keys
+       * @param {Values} values
+       */
+      constructor(keys2, values) {
+        super();
+        this.shape = {
+          keys: keys2,
+          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 == null ? void 0 : 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);
+        });
+      }
+    };
+    $record = (keys2, values) => new $Record(keys2, values);
+    $$record = $constructedBy($Record);
+    $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 == null ? void 0 : err.extend(vk.toString(), "Tuple", typeof vv));
+          return c;
+        });
+      }
+    };
+    $tuple = (...def) => new $Tuple(def);
+    $$tuple = $constructedBy($Tuple);
+    $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 == null ? void 0 : err.extend(null, "Array", ""));
+        return c;
+      }
+    };
+    $array = (...def) => new $Array(def);
+    $$array = $constructedBy($Array);
+    $arrayAny = $custom((o) => isArray(o));
+    $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 == null ? void 0 : err.extend(null, this.shape.name, o == null ? void 0 : o.constructor.name));
+        return c;
+      }
+    };
+    $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+    $$instanceOf = $constructedBy($InstanceOf);
+    $$schema = $instanceOf(Schema);
+    $Lambda = class extends Schema {
+      /**
+       * @param {Args} args
+       */
+      constructor(args2) {
+        super();
+        this.len = args2.length - 1;
+        this.args = $tuple(...args2.slice(-1));
+        this.res = args2[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 == null ? void 0 : err.extend(null, "function", typeof f));
+        return c;
+      }
+    };
+    $$lambda = $constructedBy($Lambda);
+    $function = $custom((o) => typeof o === "function");
+    $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 == null ? void 0 : err.extend(null, "Intersectinon", typeof o));
+        return c;
+      }
+    };
+    $$intersect = $constructedBy($Intersection, (o) => o.shape.length > 0);
+    $Union = class extends Schema {
+      /**
+       * @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 == null ? void 0 : err.extend(null, "Union", typeof o);
+        return c;
+      }
+    };
+    __publicField($Union, "_dilutes", true);
+    $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);
+    $$union = /** @type {Schema<$Union<any>>} */
+    $constructedBy($Union);
+    _t = () => true;
+    $any = $custom(_t);
+    $$any = /** @type {Schema<Schema<any>>} */
+    $constructedBy($Custom, (o) => o.shape === _t);
+    $bigint = $custom((o) => typeof o === "bigint");
+    $$bigint = /** @type {Schema<Schema<BigInt>>} */
+    $custom((o) => o === $bigint);
+    $symbol = $custom((o) => typeof o === "symbol");
+    $$symbol = /** @type {Schema<Schema<Symbol>>} */
+    $custom((o) => o === $symbol);
+    $number = $custom((o) => typeof o === "number");
+    $$number = /** @type {Schema<Schema<number>>} */
+    $custom((o) => o === $number);
+    $string = $custom((o) => typeof o === "string");
+    $$string = /** @type {Schema<Schema<string>>} */
+    $custom((o) => o === $string);
+    $boolean = $custom((o) => typeof o === "boolean");
+    $$boolean = /** @type {Schema<Schema<Boolean>>} */
+    $custom((o) => o === $boolean);
+    $undefined = $literal(void 0);
+    $$undefined = /** @type {Schema<Schema<undefined>>} */
+    $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0);
+    $void = $literal(void 0);
+    $null = $literal(null);
+    $$null = /** @type {Schema<Schema<null>>} */
+    $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null);
+    $uint8Array = $constructedBy(Uint8Array);
+    $$uint8Array = /** @type {Schema<Schema<Uint8Array>>} */
+    $constructedBy($ConstructedBy, (o) => o.shape === Uint8Array);
+    $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+    $json = (() => {
+      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;
+    })();
+    $ = (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();
+    };
+    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()}`);
+      }
+    };
+    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");
+          }
+        );
+      }
+    };
+    match = (state) => new PatternMatcher(
+      /** @type {any} */
+      state
+    );
+    _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();
+    random = (gen, schema) => (
+      /** @type {any} */
+      _random($(schema), gen)
+    );
+  }
+});
+
 // ../../../node_modules/lib0/dom.js
-var doc, domParser, mapToStyleString, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, DOCUMENT_FRAGMENT_NODE;
+var doc, $fragment, domParser, $element, $text, mapToStyleString, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, DOCUMENT_FRAGMENT_NODE, $node;
 var init_dom = __esm({
   "../../../node_modules/lib0/dom.js"() {
     init_map();
+    init_schema();
     doc = /** @type {Document} */
     typeof document !== "undefined" ? document : {};
+    $fragment = $custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
     domParser = /** @type {DOMParser} */
     typeof DOMParser !== "undefined" ? new DOMParser() : null;
+    $element = $custom((el) => el.nodeType === ELEMENT_NODE);
+    $text = $custom((el) => el.nodeType === TEXT_NODE);
     mapToStyleString = (m) => map(m, (value2, key) => `${key}:${value2};`).join("");
     ELEMENT_NODE = doc.ELEMENT_NODE;
     TEXT_NODE = doc.TEXT_NODE;
@@ -1172,6 +2041,7 @@ var init_dom = __esm({
     DOCUMENT_NODE = doc.DOCUMENT_NODE;
     DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE;
     DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+    $node = $custom((el) => el.nodeType === DOCUMENT_NODE);
   }
 });
 
@@ -2962,15 +3832,19 @@ var init_yjs = __esm({
                   event._path = null;
                 });
                 events.sort((event1, event2) => event1.path.length - event2.path.length);
-                callEventHandlerListeners(type._dEH, events, transaction);
+                fs.push(() => {
+                  callEventHandlerListeners(type._dEH, events, transaction);
+                });
+              }
+            });
+            fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
+            fs.push(() => {
+              if (transaction._needFormattingCleanup) {
+                cleanupYTextAfterTransaction(transaction);
               }
             });
           });
-          fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
           callAll(fs, []);
-          if (transaction._needFormattingCleanup) {
-            cleanupYTextAfterTransaction(transaction);
-          }
         } finally {
           if (doc2.gc) {
             tryGcDeleteSet(ds, store, doc2.gcFilter);
@@ -3354,7 +4228,7 @@ var init_yjs = __esm({
         return isDeleted(this.transaction.deleteSet, struct.id);
       }
       /**
-       * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+       * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
        */
       get keys() {
         if (this._keys === null) {
@@ -6060,11 +6934,13 @@ var init_yjs = __esm({
         const el = new _YXmlElement(this.nodeName);
         const attrs = this.getAttributes();
         forEach(attrs, (value2, key) => {
-          if (typeof value2 === "string") {
-            el.setAttribute(key, value2);
-          }
+          el.setAttribute(
+            key,
+            /** @type {any} */
+            value2
+          );
         });
-        el.insert(0, this.toArray().map((item) => item instanceof AbstractType ? item.clone() : item));
+        el.insert(0, this.toArray().map((v) => v instanceof AbstractType ? v.clone() : v));
         return el;
       }
       /**
@@ -8117,7 +8993,7 @@ var require_dexie = __commonJS({
       function override(origFunc, overridedFactory) {
         return overridedFactory(origFunc);
       }
-      function assert(b) {
+      function assert2(b) {
         if (!b)
           throw new Error("Assertion Failed");
       }
@@ -8161,7 +9037,7 @@ var require_dexie = __commonJS({
         if ("isFrozen" in Object && Object.isFrozen(obj))
           return;
         if (typeof keyPath !== "string" && "length" in keyPath) {
-          assert(typeof value2 !== "string" && "length" in value2);
+          assert2(typeof value2 !== "string" && "length" in value2);
           for (var i = 0, l = keyPath.length; i < l; ++i) {
             setByKeyPath(obj, keyPath[i], value2[i]);
           }
@@ -9431,7 +10307,7 @@ var require_dexie = __commonJS({
           if (!compoundIndex && debug)
             console.warn("The query ".concat(JSON.stringify(indexOrCrit), " on ").concat(this.name, " would benefit from a ") + "compound index [".concat(keyPaths.join("+"), "]"));
           var idxByName = this.schema.idxByName;
-          function equals(a, b) {
+          function equals2(a, b) {
             return cmp2(a, b) === 0;
           }
           var _a2 = keyPaths.reduce(function(_a3, keyPath) {
@@ -9443,10 +10319,10 @@ var require_dexie = __commonJS({
               prevIndex || !index ? combine(prevFilterFn, index && index.multi ? function(x) {
                 var prop = getByKeyPath(x, keyPath);
                 return isArray3(prop) && prop.some(function(item) {
-                  return equals(value2, item);
+                  return equals2(value2, item);
                 });
               } : function(x) {
-                return equals(value2, getByKeyPath(x, keyPath));
+                return equals2(value2, getByKeyPath(x, keyPath));
               }) : prevFilterFn
             ];
           }, [null, null]), idx = _a2[0], filterFunction = _a2[1];
@@ -10434,7 +11310,7 @@ var require_dexie = __commonJS({
           return key.substr(0, upperNeedle.length);
         return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
       }
-      function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
+      function addIgnoreCaseAlgorithm(whereClause, match2, needles, suffix) {
         var upper, lower, compare, upperNeedles, lowerNeedles, direction, nextKeySuffix, needlesLen = needles.length;
         if (!needles.every(function(s) {
           return typeof s === "string";
@@ -10472,7 +11348,7 @@ var require_dexie = __commonJS({
           if (typeof key !== "string")
             return false;
           var lowerKey = lower(key);
-          if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) {
+          if (match2(lowerKey, lowerNeedles, firstPossibleNeedle)) {
             return true;
           } else {
             var lowestPossibleCasing = null;
@@ -10810,14 +11686,14 @@ var require_dexie = __commonJS({
         function Transaction3() {
         }
         Transaction3.prototype._lock = function() {
-          assert(!PSD.global);
+          assert2(!PSD.global);
           ++this._reculock;
           if (this._reculock === 1 && !PSD.global)
             PSD.lockOwnerFor = this;
           return this;
         };
         Transaction3.prototype._unlock = function() {
-          assert(!PSD.global);
+          assert2(!PSD.global);
           if (--this._reculock === 0) {
             if (!PSD.global)
               PSD.lockOwnerFor = null;
@@ -10840,7 +11716,7 @@ var require_dexie = __commonJS({
             return this;
           var idbdb = this.db.idbdb;
           var dbOpenError = this.db._state.dbOpenError;
-          assert(!this.idbtrans);
+          assert2(!this.idbtrans);
           if (!idbtrans && !idbdb) {
             switch (dbOpenError && dbOpenError.name) {
               case "DatabaseClosedError":
@@ -10853,7 +11729,7 @@ var require_dexie = __commonJS({
           }
           if (!this.active)
             throw new exceptions.TransactionInactive();
-          assert(this._completion._state === null);
+          assert2(this._completion._state === null);
           idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }) : idbdb.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }));
           idbtrans.onerror = wrap(function(ev) {
             preventDefault(ev);
@@ -15454,7 +16330,7 @@ var Transport = class extends Emitter {
     return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
   }
   _port() {
-    if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) {
+    if (this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80)) {
       return ":" + this.opts.port;
     } else {
       return "";
@@ -16685,6 +17561,7 @@ __export(esm_exports, {
   Decoder: () => Decoder,
   Encoder: () => Encoder,
   PacketType: () => PacketType,
+  isPacketValid: () => isPacketValid,
   protocol: () => protocol3
 });
 
@@ -16790,10 +17667,15 @@ function _reconstructPacket(data2, buffers) {
 // ../../../node_modules/socket.io-parser/build/esm/index.js
 var RESERVED_EVENTS = [
   "connect",
+  // used on the client side
   "connect_error",
+  // used on the client side
   "disconnect",
+  // used on both sides
   "disconnecting",
+  // used on the server side
   "newListener",
+  // used by the Node.js EventEmitter
   "removeListener"
   // used by the Node.js EventEmitter
 ];
@@ -16868,9 +17750,6 @@ var Encoder = class {
     return buffers;
   }
 };
-function isObject(value2) {
-  return Object.prototype.toString.call(value2) === "[object Object]";
-}
 var Decoder = class _Decoder extends Emitter {
   /**
    * Decoder constructor
@@ -17042,6 +17921,37 @@ var BinaryReconstructor = class {
     this.buffers = [];
   }
 };
+function isNamespaceValid(nsp) {
+  return typeof nsp === "string";
+}
+var isInteger = Number.isInteger || function(value2) {
+  return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
+};
+function isAckIdValid(id2) {
+  return id2 === void 0 || isInteger(id2);
+}
+function isObject(value2) {
+  return Object.prototype.toString.call(value2) === "[object Object]";
+}
+function isDataValid(type, payload) {
+  switch (type) {
+    case PacketType.CONNECT:
+      return payload === void 0 || isObject(payload);
+    case PacketType.DISCONNECT:
+      return payload === void 0;
+    case PacketType.EVENT:
+      return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
+    case PacketType.ACK:
+      return Array.isArray(payload);
+    case PacketType.CONNECT_ERROR:
+      return typeof payload === "string" || isObject(payload);
+    default:
+      return false;
+  }
+}
+function isPacketValid(packet) {
+  return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
+}
 
 // ../../../node_modules/socket.io-client/build/esm/on.js
 function on(obj, ev, fn) {
@@ -17307,7 +18217,6 @@ var Socket2 = class extends Emitter {
     };
     args2.push((err, ...responseArgs) => {
       if (packet !== this._queue[0]) {
-        return;
       }
       const hasError = err !== null;
       if (hasError) {
@@ -17539,8 +18448,8 @@ var Socket2 = class extends Emitter {
     this._pid = pid;
     this.connected = true;
     this.emitBuffered();
-    this.emitReserved("connect");
     this._drainQueue(true);
+    this.emitReserved("connect");
   }
   /**
    * Emit buffered events (received and emitted).
@@ -19208,17 +20117,17 @@ pp$9.strictDirective = function(start) {
   for (; ; ) {
     skipWhiteSpace.lastIndex = start;
     start += skipWhiteSpace.exec(this.input)[0].length;
-    var match = literal.exec(this.input.slice(start));
-    if (!match) {
+    var match2 = literal.exec(this.input.slice(start));
+    if (!match2) {
       return false;
     }
-    if ((match[1] || match[2]) === "use strict") {
-      skipWhiteSpace.lastIndex = start + match[0].length;
+    if ((match2[1] || match2[2]) === "use strict") {
+      skipWhiteSpace.lastIndex = start + match2[0].length;
       var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
       var next = this.input.charAt(end);
       return next === ";" || next === "}" || lineBreak.test(spaceAfter[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "=");
     }
-    start += match[0].length;
+    start += match2[0].length;
     skipWhiteSpace.lastIndex = start;
     start += skipWhiteSpace.exec(this.input)[0].length;
     if (this.input[start] === ";") {
@@ -24198,7 +25107,7 @@ pp.readHexChar = function(len) {
 };
 pp.readWord1 = function() {
   this.containsEsc = false;
-  var word = "", first = true, chunkStart = this.pos;
+  var word2 = "", first = true, chunkStart = this.pos;
   var astral = this.options.ecmaVersion >= 6;
   while (this.pos < this.input.length) {
     var ch = this.fullCharCodeAtPos();
@@ -24206,7 +25115,7 @@ pp.readWord1 = function() {
       this.pos += ch <= 65535 ? 1 : 2;
     } else if (ch === 92) {
       this.containsEsc = true;
-      word += this.input.slice(chunkStart, this.pos);
+      word2 += this.input.slice(chunkStart, this.pos);
       var escStart = this.pos;
       if (this.input.charCodeAt(++this.pos) !== 117) {
         this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX");
@@ -24216,22 +25125,22 @@ pp.readWord1 = function() {
       if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) {
         this.invalidStringToken(escStart, "Invalid Unicode escape");
       }
-      word += codePointToString(esc);
+      word2 += codePointToString(esc);
       chunkStart = this.pos;
     } else {
       break;
     }
     first = false;
   }
-  return word + this.input.slice(chunkStart, this.pos);
+  return word2 + this.input.slice(chunkStart, this.pos);
 };
 pp.readWord = function() {
-  var word = this.readWord1();
+  var word2 = this.readWord1();
   var type = types$1.name;
-  if (this.keywords.test(word)) {
-    type = keywords[word];
+  if (this.keywords.test(word2)) {
+    type = keywords[word2];
   }
-  return this.finishToken(type, word);
+  return this.finishToken(type, word2);
 };
 var version = "8.15.0";
 Parser.acorn = {