[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).sync = (() => {
   5    var __create = Object.create;
   6    var __defProp = Object.defineProperty;
   7    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   8    var __getOwnPropNames = Object.getOwnPropertyNames;
   9    var __getProtoOf = Object.getPrototypeOf;
  10    var __hasOwnProp = Object.prototype.hasOwnProperty;
  11    var __commonJS = (cb, mod) => function __require() {
  12      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  13    };
  14    var __export = (target, all2) => {
  15      for (var name in all2)
  16        __defProp(target, name, { get: all2[name], enumerable: true });
  17    };
  18    var __copyProps = (to, from2, except, desc) => {
  19      if (from2 && typeof from2 === "object" || typeof from2 === "function") {
  20        for (let key of __getOwnPropNames(from2))
  21          if (!__hasOwnProp.call(to, key) && key !== except)
  22            __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
  23      }
  24      return to;
  25    };
  26    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  27      // If the importer is in node compatibility mode or this is not an ESM
  28      // file that has been converted to a CommonJS file using a Babel-
  29      // compatible transform (i.e. "__esModule" has not been set), then set
  30      // "default" to the CommonJS "module.exports" for node compatibility.
  31      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  32      mod
  33    ));
  34    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  35  
  36    // package-external:@wordpress/private-apis
  37    var require_private_apis = __commonJS({
  38      "package-external:@wordpress/private-apis"(exports, module) {
  39        module.exports = window.wp.privateApis;
  40      }
  41    });
  42  
  43    // package-external:@wordpress/hooks
  44    var require_hooks = __commonJS({
  45      "package-external:@wordpress/hooks"(exports, module) {
  46        module.exports = window.wp.hooks;
  47      }
  48    });
  49  
  50    // package-external:@wordpress/api-fetch
  51    var require_api_fetch = __commonJS({
  52      "package-external:@wordpress/api-fetch"(exports, module) {
  53        module.exports = window.wp.apiFetch;
  54      }
  55    });
  56  
  57    // node_modules/fast-deep-equal/es6/index.js
  58    var require_es6 = __commonJS({
  59      "node_modules/fast-deep-equal/es6/index.js"(exports, module) {
  60        "use strict";
  61        module.exports = function equal(a, b) {
  62          if (a === b) return true;
  63          if (a && b && typeof a == "object" && typeof b == "object") {
  64            if (a.constructor !== b.constructor) return false;
  65            var length2, i, keys2;
  66            if (Array.isArray(a)) {
  67              length2 = a.length;
  68              if (length2 != b.length) return false;
  69              for (i = length2; i-- !== 0; )
  70                if (!equal(a[i], b[i])) return false;
  71              return true;
  72            }
  73            if (a instanceof Map && b instanceof Map) {
  74              if (a.size !== b.size) return false;
  75              for (i of a.entries())
  76                if (!b.has(i[0])) return false;
  77              for (i of a.entries())
  78                if (!equal(i[1], b.get(i[0]))) return false;
  79              return true;
  80            }
  81            if (a instanceof Set && b instanceof Set) {
  82              if (a.size !== b.size) return false;
  83              for (i of a.entries())
  84                if (!b.has(i[0])) return false;
  85              return true;
  86            }
  87            if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
  88              length2 = a.length;
  89              if (length2 != b.length) return false;
  90              for (i = length2; i-- !== 0; )
  91                if (a[i] !== b[i]) return false;
  92              return true;
  93            }
  94            if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
  95            if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
  96            if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
  97            keys2 = Object.keys(a);
  98            length2 = keys2.length;
  99            if (length2 !== Object.keys(b).length) return false;
 100            for (i = length2; i-- !== 0; )
 101              if (!Object.prototype.hasOwnProperty.call(b, keys2[i])) return false;
 102            for (i = length2; i-- !== 0; ) {
 103              var key = keys2[i];
 104              if (!equal(a[key], b[key])) return false;
 105            }
 106            return true;
 107          }
 108          return a !== a && b !== b;
 109        };
 110      }
 111    });
 112  
 113    // packages/sync/build-module/index.mjs
 114    var index_exports = {};
 115    __export(index_exports, {
 116      Awareness: () => Awareness,
 117      Y: () => yjs_exports,
 118      YJS_VERSION: () => YJS_VERSION,
 119      privateApis: () => privateApis
 120    });
 121  
 122    // node_modules/yjs/dist/yjs.mjs
 123    var yjs_exports = {};
 124    __export(yjs_exports, {
 125      AbsolutePosition: () => AbsolutePosition,
 126      AbstractConnector: () => AbstractConnector,
 127      AbstractStruct: () => AbstractStruct,
 128      AbstractType: () => AbstractType,
 129      Array: () => YArray,
 130      ContentAny: () => ContentAny,
 131      ContentBinary: () => ContentBinary,
 132      ContentDeleted: () => ContentDeleted,
 133      ContentDoc: () => ContentDoc,
 134      ContentEmbed: () => ContentEmbed,
 135      ContentFormat: () => ContentFormat,
 136      ContentJSON: () => ContentJSON,
 137      ContentString: () => ContentString,
 138      ContentType: () => ContentType,
 139      Doc: () => Doc,
 140      GC: () => GC,
 141      ID: () => ID,
 142      Item: () => Item,
 143      Map: () => YMap,
 144      PermanentUserData: () => PermanentUserData,
 145      RelativePosition: () => RelativePosition,
 146      Skip: () => Skip,
 147      Snapshot: () => Snapshot,
 148      Text: () => YText,
 149      Transaction: () => Transaction,
 150      UndoManager: () => UndoManager,
 151      UpdateDecoderV1: () => UpdateDecoderV1,
 152      UpdateDecoderV2: () => UpdateDecoderV2,
 153      UpdateEncoderV1: () => UpdateEncoderV1,
 154      UpdateEncoderV2: () => UpdateEncoderV2,
 155      XmlElement: () => YXmlElement,
 156      XmlFragment: () => YXmlFragment,
 157      XmlHook: () => YXmlHook,
 158      XmlText: () => YXmlText,
 159      YArrayEvent: () => YArrayEvent,
 160      YEvent: () => YEvent,
 161      YMapEvent: () => YMapEvent,
 162      YTextEvent: () => YTextEvent,
 163      YXmlEvent: () => YXmlEvent,
 164      applyUpdate: () => applyUpdate,
 165      applyUpdateV2: () => applyUpdateV2,
 166      cleanupYTextFormatting: () => cleanupYTextFormatting,
 167      compareIDs: () => compareIDs,
 168      compareRelativePositions: () => compareRelativePositions,
 169      convertUpdateFormatV1ToV2: () => convertUpdateFormatV1ToV2,
 170      convertUpdateFormatV2ToV1: () => convertUpdateFormatV2ToV1,
 171      createAbsolutePositionFromRelativePosition: () => createAbsolutePositionFromRelativePosition,
 172      createDeleteSet: () => createDeleteSet,
 173      createDeleteSetFromStructStore: () => createDeleteSetFromStructStore,
 174      createDocFromSnapshot: () => createDocFromSnapshot,
 175      createID: () => createID,
 176      createRelativePositionFromJSON: () => createRelativePositionFromJSON,
 177      createRelativePositionFromTypeIndex: () => createRelativePositionFromTypeIndex,
 178      createSnapshot: () => createSnapshot,
 179      decodeRelativePosition: () => decodeRelativePosition,
 180      decodeSnapshot: () => decodeSnapshot,
 181      decodeSnapshotV2: () => decodeSnapshotV2,
 182      decodeStateVector: () => decodeStateVector,
 183      decodeUpdate: () => decodeUpdate,
 184      decodeUpdateV2: () => decodeUpdateV2,
 185      diffUpdate: () => diffUpdate,
 186      diffUpdateV2: () => diffUpdateV2,
 187      emptySnapshot: () => emptySnapshot,
 188      encodeRelativePosition: () => encodeRelativePosition,
 189      encodeSnapshot: () => encodeSnapshot,
 190      encodeSnapshotV2: () => encodeSnapshotV2,
 191      encodeStateAsUpdate: () => encodeStateAsUpdate,
 192      encodeStateAsUpdateV2: () => encodeStateAsUpdateV2,
 193      encodeStateVector: () => encodeStateVector,
 194      encodeStateVectorFromUpdate: () => encodeStateVectorFromUpdate,
 195      encodeStateVectorFromUpdateV2: () => encodeStateVectorFromUpdateV2,
 196      equalDeleteSets: () => equalDeleteSets,
 197      equalSnapshots: () => equalSnapshots,
 198      findIndexSS: () => findIndexSS,
 199      findRootTypeKey: () => findRootTypeKey,
 200      getItem: () => getItem,
 201      getItemCleanEnd: () => getItemCleanEnd,
 202      getItemCleanStart: () => getItemCleanStart,
 203      getState: () => getState,
 204      getTypeChildren: () => getTypeChildren,
 205      isDeleted: () => isDeleted,
 206      isParentOf: () => isParentOf,
 207      iterateDeletedStructs: () => iterateDeletedStructs,
 208      logType: () => logType,
 209      logUpdate: () => logUpdate,
 210      logUpdateV2: () => logUpdateV2,
 211      mergeDeleteSets: () => mergeDeleteSets,
 212      mergeUpdates: () => mergeUpdates,
 213      mergeUpdatesV2: () => mergeUpdatesV2,
 214      obfuscateUpdate: () => obfuscateUpdate,
 215      obfuscateUpdateV2: () => obfuscateUpdateV2,
 216      parseUpdateMeta: () => parseUpdateMeta,
 217      parseUpdateMetaV2: () => parseUpdateMetaV2,
 218      readUpdate: () => readUpdate,
 219      readUpdateV2: () => readUpdateV2,
 220      relativePositionToJSON: () => relativePositionToJSON,
 221      snapshot: () => snapshot,
 222      snapshotContainsUpdate: () => snapshotContainsUpdate,
 223      transact: () => transact,
 224      tryGc: () => tryGc,
 225      typeListToArraySnapshot: () => typeListToArraySnapshot,
 226      typeMapGetAllSnapshot: () => typeMapGetAllSnapshot,
 227      typeMapGetSnapshot: () => typeMapGetSnapshot
 228    });
 229  
 230    // node_modules/lib0/map.js
 231    var create = () => /* @__PURE__ */ new Map();
 232    var copy = (m) => {
 233      const r = create();
 234      m.forEach((v, k) => {
 235        r.set(k, v);
 236      });
 237      return r;
 238    };
 239    var setIfUndefined = (map2, key, createT) => {
 240      let set = map2.get(key);
 241      if (set === void 0) {
 242        map2.set(key, set = createT());
 243      }
 244      return set;
 245    };
 246    var map = (m, f) => {
 247      const res = [];
 248      for (const [key, value] of m) {
 249        res.push(f(value, key));
 250      }
 251      return res;
 252    };
 253    var any = (m, f) => {
 254      for (const [key, value] of m) {
 255        if (f(value, key)) {
 256          return true;
 257        }
 258      }
 259      return false;
 260    };
 261  
 262    // node_modules/lib0/set.js
 263    var create2 = () => /* @__PURE__ */ new Set();
 264  
 265    // node_modules/lib0/array.js
 266    var last = (arr) => arr[arr.length - 1];
 267    var appendTo = (dest, src) => {
 268      for (let i = 0; i < src.length; i++) {
 269        dest.push(src[i]);
 270      }
 271    };
 272    var from = Array.from;
 273    var every = (arr, f) => {
 274      for (let i = 0; i < arr.length; i++) {
 275        if (!f(arr[i], i, arr)) {
 276          return false;
 277        }
 278      }
 279      return true;
 280    };
 281    var some = (arr, f) => {
 282      for (let i = 0; i < arr.length; i++) {
 283        if (f(arr[i], i, arr)) {
 284          return true;
 285        }
 286      }
 287      return false;
 288    };
 289    var unfold = (len, f) => {
 290      const array = new Array(len);
 291      for (let i = 0; i < len; i++) {
 292        array[i] = f(i, array);
 293      }
 294      return array;
 295    };
 296    var isArray = Array.isArray;
 297  
 298    // node_modules/lib0/observable.js
 299    var ObservableV2 = class {
 300      constructor() {
 301        this._observers = create();
 302      }
 303      /**
 304       * @template {keyof EVENTS & string} NAME
 305       * @param {NAME} name
 306       * @param {EVENTS[NAME]} f
 307       */
 308      on(name, f) {
 309        setIfUndefined(
 310          this._observers,
 311          /** @type {string} */
 312          name,
 313          create2
 314        ).add(f);
 315        return f;
 316      }
 317      /**
 318       * @template {keyof EVENTS & string} NAME
 319       * @param {NAME} name
 320       * @param {EVENTS[NAME]} f
 321       */
 322      once(name, f) {
 323        const _f = (...args2) => {
 324          this.off(
 325            name,
 326            /** @type {any} */
 327            _f
 328          );
 329          f(...args2);
 330        };
 331        this.on(
 332          name,
 333          /** @type {any} */
 334          _f
 335        );
 336      }
 337      /**
 338       * @template {keyof EVENTS & string} NAME
 339       * @param {NAME} name
 340       * @param {EVENTS[NAME]} f
 341       */
 342      off(name, f) {
 343        const observers = this._observers.get(name);
 344        if (observers !== void 0) {
 345          observers.delete(f);
 346          if (observers.size === 0) {
 347            this._observers.delete(name);
 348          }
 349        }
 350      }
 351      /**
 352       * Emit a named event. All registered event listeners that listen to the
 353       * specified name will receive the event.
 354       *
 355       * @todo This should catch exceptions
 356       *
 357       * @template {keyof EVENTS & string} NAME
 358       * @param {NAME} name The event name.
 359       * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
 360       */
 361      emit(name, args2) {
 362        return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
 363      }
 364      destroy() {
 365        this._observers = create();
 366      }
 367    };
 368    var Observable = class {
 369      constructor() {
 370        this._observers = create();
 371      }
 372      /**
 373       * @param {N} name
 374       * @param {function} f
 375       */
 376      on(name, f) {
 377        setIfUndefined(this._observers, name, create2).add(f);
 378      }
 379      /**
 380       * @param {N} name
 381       * @param {function} f
 382       */
 383      once(name, f) {
 384        const _f = (...args2) => {
 385          this.off(name, _f);
 386          f(...args2);
 387        };
 388        this.on(name, _f);
 389      }
 390      /**
 391       * @param {N} name
 392       * @param {function} f
 393       */
 394      off(name, f) {
 395        const observers = this._observers.get(name);
 396        if (observers !== void 0) {
 397          observers.delete(f);
 398          if (observers.size === 0) {
 399            this._observers.delete(name);
 400          }
 401        }
 402      }
 403      /**
 404       * Emit a named event. All registered event listeners that listen to the
 405       * specified name will receive the event.
 406       *
 407       * @todo This should catch exceptions
 408       *
 409       * @param {N} name The event name.
 410       * @param {Array<any>} args The arguments that are applied to the event listener.
 411       */
 412      emit(name, args2) {
 413        return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
 414      }
 415      destroy() {
 416        this._observers = create();
 417      }
 418    };
 419  
 420    // node_modules/lib0/math.js
 421    var floor = Math.floor;
 422    var abs = Math.abs;
 423    var min = (a, b) => a < b ? a : b;
 424    var max = (a, b) => a > b ? a : b;
 425    var isNaN2 = Number.isNaN;
 426    var isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
 427  
 428    // node_modules/lib0/binary.js
 429    var BIT1 = 1;
 430    var BIT2 = 2;
 431    var BIT3 = 4;
 432    var BIT4 = 8;
 433    var BIT6 = 32;
 434    var BIT7 = 64;
 435    var BIT8 = 128;
 436    var BIT18 = 1 << 17;
 437    var BIT19 = 1 << 18;
 438    var BIT20 = 1 << 19;
 439    var BIT21 = 1 << 20;
 440    var BIT22 = 1 << 21;
 441    var BIT23 = 1 << 22;
 442    var BIT24 = 1 << 23;
 443    var BIT25 = 1 << 24;
 444    var BIT26 = 1 << 25;
 445    var BIT27 = 1 << 26;
 446    var BIT28 = 1 << 27;
 447    var BIT29 = 1 << 28;
 448    var BIT30 = 1 << 29;
 449    var BIT31 = 1 << 30;
 450    var BIT32 = 1 << 31;
 451    var BITS5 = 31;
 452    var BITS6 = 63;
 453    var BITS7 = 127;
 454    var BITS17 = BIT18 - 1;
 455    var BITS18 = BIT19 - 1;
 456    var BITS19 = BIT20 - 1;
 457    var BITS20 = BIT21 - 1;
 458    var BITS21 = BIT22 - 1;
 459    var BITS22 = BIT23 - 1;
 460    var BITS23 = BIT24 - 1;
 461    var BITS24 = BIT25 - 1;
 462    var BITS25 = BIT26 - 1;
 463    var BITS26 = BIT27 - 1;
 464    var BITS27 = BIT28 - 1;
 465    var BITS28 = BIT29 - 1;
 466    var BITS29 = BIT30 - 1;
 467    var BITS30 = BIT31 - 1;
 468    var BITS31 = 2147483647;
 469  
 470    // node_modules/lib0/number.js
 471    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 472    var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 473    var LOWEST_INT32 = 1 << 31;
 474    var isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
 475    var isNaN3 = Number.isNaN;
 476    var parseInt2 = Number.parseInt;
 477  
 478    // node_modules/lib0/string.js
 479    var fromCharCode = String.fromCharCode;
 480    var fromCodePoint = String.fromCodePoint;
 481    var MAX_UTF16_CHARACTER = fromCharCode(65535);
 482    var toLowerCase = (s) => s.toLowerCase();
 483    var trimLeftRegex = /^\s*/g;
 484    var trimLeft = (s) => s.replace(trimLeftRegex, "");
 485    var fromCamelCaseRegex = /([A-Z])/g;
 486    var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `$separator}$toLowerCase(match2)}`));
 487    var _encodeUtf8Polyfill = (str) => {
 488      const encodedString = unescape(encodeURIComponent(str));
 489      const len = encodedString.length;
 490      const buf = new Uint8Array(len);
 491      for (let i = 0; i < len; i++) {
 492        buf[i] = /** @type {number} */
 493        encodedString.codePointAt(i);
 494      }
 495      return buf;
 496    };
 497    var utf8TextEncoder = (
 498      /** @type {TextEncoder} */
 499      typeof TextEncoder !== "undefined" ? new TextEncoder() : null
 500    );
 501    var _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
 502    var encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
 503    var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 504    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
 505      utf8TextDecoder = null;
 506    }
 507    var repeat = (source, n) => unfold(n, () => source).join("");
 508  
 509    // node_modules/lib0/encoding.js
 510    var Encoder = class {
 511      constructor() {
 512        this.cpos = 0;
 513        this.cbuf = new Uint8Array(100);
 514        this.bufs = [];
 515      }
 516    };
 517    var createEncoder = () => new Encoder();
 518    var length = (encoder) => {
 519      let len = encoder.cpos;
 520      for (let i = 0; i < encoder.bufs.length; i++) {
 521        len += encoder.bufs[i].length;
 522      }
 523      return len;
 524    };
 525    var toUint8Array = (encoder) => {
 526      const uint8arr = new Uint8Array(length(encoder));
 527      let curPos = 0;
 528      for (let i = 0; i < encoder.bufs.length; i++) {
 529        const d = encoder.bufs[i];
 530        uint8arr.set(d, curPos);
 531        curPos += d.length;
 532      }
 533      uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
 534      return uint8arr;
 535    };
 536    var verifyLen = (encoder, len) => {
 537      const bufferLen = encoder.cbuf.length;
 538      if (bufferLen - encoder.cpos < len) {
 539        encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
 540        encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
 541        encoder.cpos = 0;
 542      }
 543    };
 544    var write = (encoder, num) => {
 545      const bufferLen = encoder.cbuf.length;
 546      if (encoder.cpos === bufferLen) {
 547        encoder.bufs.push(encoder.cbuf);
 548        encoder.cbuf = new Uint8Array(bufferLen * 2);
 549        encoder.cpos = 0;
 550      }
 551      encoder.cbuf[encoder.cpos++] = num;
 552    };
 553    var writeUint8 = write;
 554    var writeVarUint = (encoder, num) => {
 555      while (num > BITS7) {
 556        write(encoder, BIT8 | BITS7 & num);
 557        num = floor(num / 128);
 558      }
 559      write(encoder, BITS7 & num);
 560    };
 561    var writeVarInt = (encoder, num) => {
 562      const isNegative = isNegativeZero(num);
 563      if (isNegative) {
 564        num = -num;
 565      }
 566      write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | BITS6 & num);
 567      num = floor(num / 64);
 568      while (num > 0) {
 569        write(encoder, (num > BITS7 ? BIT8 : 0) | BITS7 & num);
 570        num = floor(num / 128);
 571      }
 572    };
 573    var _strBuffer = new Uint8Array(3e4);
 574    var _maxStrBSize = _strBuffer.length / 3;
 575    var _writeVarStringNative = (encoder, str) => {
 576      if (str.length < _maxStrBSize) {
 577        const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
 578        writeVarUint(encoder, written);
 579        for (let i = 0; i < written; i++) {
 580          write(encoder, _strBuffer[i]);
 581        }
 582      } else {
 583        writeVarUint8Array(encoder, encodeUtf8(str));
 584      }
 585    };
 586    var _writeVarStringPolyfill = (encoder, str) => {
 587      const encodedString = unescape(encodeURIComponent(str));
 588      const len = encodedString.length;
 589      writeVarUint(encoder, len);
 590      for (let i = 0; i < len; i++) {
 591        write(
 592          encoder,
 593          /** @type {number} */
 594          encodedString.codePointAt(i)
 595        );
 596      }
 597    };
 598    var writeVarString = utf8TextEncoder && /** @type {any} */
 599    utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
 600    var writeBinaryEncoder = (encoder, append2) => writeUint8Array(encoder, toUint8Array(append2));
 601    var writeUint8Array = (encoder, uint8Array) => {
 602      const bufferLen = encoder.cbuf.length;
 603      const cpos = encoder.cpos;
 604      const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
 605      const rightCopyLen = uint8Array.length - leftCopyLen;
 606      encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
 607      encoder.cpos += leftCopyLen;
 608      if (rightCopyLen > 0) {
 609        encoder.bufs.push(encoder.cbuf);
 610        encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
 611        encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
 612        encoder.cpos = rightCopyLen;
 613      }
 614    };
 615    var writeVarUint8Array = (encoder, uint8Array) => {
 616      writeVarUint(encoder, uint8Array.byteLength);
 617      writeUint8Array(encoder, uint8Array);
 618    };
 619    var writeOnDataView = (encoder, len) => {
 620      verifyLen(encoder, len);
 621      const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
 622      encoder.cpos += len;
 623      return dview;
 624    };
 625    var writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
 626    var writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
 627    var writeBigInt64 = (encoder, num) => (
 628      /** @type {any} */
 629      writeOnDataView(encoder, 8).setBigInt64(0, num, false)
 630    );
 631    var floatTestBed = new DataView(new ArrayBuffer(4));
 632    var isFloat32 = (num) => {
 633      floatTestBed.setFloat32(0, num);
 634      return floatTestBed.getFloat32(0) === num;
 635    };
 636    var writeAny = (encoder, data) => {
 637      switch (typeof data) {
 638        case "string":
 639          write(encoder, 119);
 640          writeVarString(encoder, data);
 641          break;
 642        case "number":
 643          if (isInteger(data) && abs(data) <= BITS31) {
 644            write(encoder, 125);
 645            writeVarInt(encoder, data);
 646          } else if (isFloat32(data)) {
 647            write(encoder, 124);
 648            writeFloat32(encoder, data);
 649          } else {
 650            write(encoder, 123);
 651            writeFloat64(encoder, data);
 652          }
 653          break;
 654        case "bigint":
 655          write(encoder, 122);
 656          writeBigInt64(encoder, data);
 657          break;
 658        case "object":
 659          if (data === null) {
 660            write(encoder, 126);
 661          } else if (isArray(data)) {
 662            write(encoder, 117);
 663            writeVarUint(encoder, data.length);
 664            for (let i = 0; i < data.length; i++) {
 665              writeAny(encoder, data[i]);
 666            }
 667          } else if (data instanceof Uint8Array) {
 668            write(encoder, 116);
 669            writeVarUint8Array(encoder, data);
 670          } else {
 671            write(encoder, 118);
 672            const keys2 = Object.keys(data);
 673            writeVarUint(encoder, keys2.length);
 674            for (let i = 0; i < keys2.length; i++) {
 675              const key = keys2[i];
 676              writeVarString(encoder, key);
 677              writeAny(encoder, data[key]);
 678            }
 679          }
 680          break;
 681        case "boolean":
 682          write(encoder, data ? 120 : 121);
 683          break;
 684        default:
 685          write(encoder, 127);
 686      }
 687    };
 688    var RleEncoder = class extends Encoder {
 689      /**
 690       * @param {function(Encoder, T):void} writer
 691       */
 692      constructor(writer) {
 693        super();
 694        this.w = writer;
 695        this.s = null;
 696        this.count = 0;
 697      }
 698      /**
 699       * @param {T} v
 700       */
 701      write(v) {
 702        if (this.s === v) {
 703          this.count++;
 704        } else {
 705          if (this.count > 0) {
 706            writeVarUint(this, this.count - 1);
 707          }
 708          this.count = 1;
 709          this.w(this, v);
 710          this.s = v;
 711        }
 712      }
 713    };
 714    var flushUintOptRleEncoder = (encoder) => {
 715      if (encoder.count > 0) {
 716        writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
 717        if (encoder.count > 1) {
 718          writeVarUint(encoder.encoder, encoder.count - 2);
 719        }
 720      }
 721    };
 722    var UintOptRleEncoder = class {
 723      constructor() {
 724        this.encoder = new Encoder();
 725        this.s = 0;
 726        this.count = 0;
 727      }
 728      /**
 729       * @param {number} v
 730       */
 731      write(v) {
 732        if (this.s === v) {
 733          this.count++;
 734        } else {
 735          flushUintOptRleEncoder(this);
 736          this.count = 1;
 737          this.s = v;
 738        }
 739      }
 740      /**
 741       * Flush the encoded state and transform this to a Uint8Array.
 742       *
 743       * Note that this should only be called once.
 744       */
 745      toUint8Array() {
 746        flushUintOptRleEncoder(this);
 747        return toUint8Array(this.encoder);
 748      }
 749    };
 750    var flushIntDiffOptRleEncoder = (encoder) => {
 751      if (encoder.count > 0) {
 752        const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
 753        writeVarInt(encoder.encoder, encodedDiff);
 754        if (encoder.count > 1) {
 755          writeVarUint(encoder.encoder, encoder.count - 2);
 756        }
 757      }
 758    };
 759    var IntDiffOptRleEncoder = class {
 760      constructor() {
 761        this.encoder = new Encoder();
 762        this.s = 0;
 763        this.count = 0;
 764        this.diff = 0;
 765      }
 766      /**
 767       * @param {number} v
 768       */
 769      write(v) {
 770        if (this.diff === v - this.s) {
 771          this.s = v;
 772          this.count++;
 773        } else {
 774          flushIntDiffOptRleEncoder(this);
 775          this.count = 1;
 776          this.diff = v - this.s;
 777          this.s = v;
 778        }
 779      }
 780      /**
 781       * Flush the encoded state and transform this to a Uint8Array.
 782       *
 783       * Note that this should only be called once.
 784       */
 785      toUint8Array() {
 786        flushIntDiffOptRleEncoder(this);
 787        return toUint8Array(this.encoder);
 788      }
 789    };
 790    var StringEncoder = class {
 791      constructor() {
 792        this.sarr = [];
 793        this.s = "";
 794        this.lensE = new UintOptRleEncoder();
 795      }
 796      /**
 797       * @param {string} string
 798       */
 799      write(string) {
 800        this.s += string;
 801        if (this.s.length > 19) {
 802          this.sarr.push(this.s);
 803          this.s = "";
 804        }
 805        this.lensE.write(string.length);
 806      }
 807      toUint8Array() {
 808        const encoder = new Encoder();
 809        this.sarr.push(this.s);
 810        this.s = "";
 811        writeVarString(encoder, this.sarr.join(""));
 812        writeUint8Array(encoder, this.lensE.toUint8Array());
 813        return toUint8Array(encoder);
 814      }
 815    };
 816  
 817    // node_modules/lib0/error.js
 818    var create3 = (s) => new Error(s);
 819    var methodUnimplemented = () => {
 820      throw create3("Method unimplemented");
 821    };
 822    var unexpectedCase = () => {
 823      throw create3("Unexpected case");
 824    };
 825  
 826    // node_modules/lib0/decoding.js
 827    var errorUnexpectedEndOfArray = create3("Unexpected end of array");
 828    var errorIntegerOutOfRange = create3("Integer out of Range");
 829    var Decoder = class {
 830      /**
 831       * @param {Uint8Array<Buf>} uint8Array Binary data to decode
 832       */
 833      constructor(uint8Array) {
 834        this.arr = uint8Array;
 835        this.pos = 0;
 836      }
 837    };
 838    var createDecoder = (uint8Array) => new Decoder(uint8Array);
 839    var hasContent = (decoder) => decoder.pos !== decoder.arr.length;
 840    var readUint8Array = (decoder, len) => {
 841      const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
 842      decoder.pos += len;
 843      return view;
 844    };
 845    var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
 846    var readUint8 = (decoder) => decoder.arr[decoder.pos++];
 847    var readVarUint = (decoder) => {
 848      let num = 0;
 849      let mult = 1;
 850      const len = decoder.arr.length;
 851      while (decoder.pos < len) {
 852        const r = decoder.arr[decoder.pos++];
 853        num = num + (r & BITS7) * mult;
 854        mult *= 128;
 855        if (r < BIT8) {
 856          return num;
 857        }
 858        if (num > MAX_SAFE_INTEGER) {
 859          throw errorIntegerOutOfRange;
 860        }
 861      }
 862      throw errorUnexpectedEndOfArray;
 863    };
 864    var readVarInt = (decoder) => {
 865      let r = decoder.arr[decoder.pos++];
 866      let num = r & BITS6;
 867      let mult = 64;
 868      const sign = (r & BIT7) > 0 ? -1 : 1;
 869      if ((r & BIT8) === 0) {
 870        return sign * num;
 871      }
 872      const len = decoder.arr.length;
 873      while (decoder.pos < len) {
 874        r = decoder.arr[decoder.pos++];
 875        num = num + (r & BITS7) * mult;
 876        mult *= 128;
 877        if (r < BIT8) {
 878          return sign * num;
 879        }
 880        if (num > MAX_SAFE_INTEGER) {
 881          throw errorIntegerOutOfRange;
 882        }
 883      }
 884      throw errorUnexpectedEndOfArray;
 885    };
 886    var _readVarStringPolyfill = (decoder) => {
 887      let remainingLen = readVarUint(decoder);
 888      if (remainingLen === 0) {
 889        return "";
 890      } else {
 891        let encodedString = String.fromCodePoint(readUint8(decoder));
 892        if (--remainingLen < 100) {
 893          while (remainingLen--) {
 894            encodedString += String.fromCodePoint(readUint8(decoder));
 895          }
 896        } else {
 897          while (remainingLen > 0) {
 898            const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
 899            const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
 900            decoder.pos += nextLen;
 901            encodedString += String.fromCodePoint.apply(
 902              null,
 903              /** @type {any} */
 904              bytes
 905            );
 906            remainingLen -= nextLen;
 907          }
 908        }
 909        return decodeURIComponent(escape(encodedString));
 910      }
 911    };
 912    var _readVarStringNative = (decoder) => (
 913      /** @type any */
 914      utf8TextDecoder.decode(readVarUint8Array(decoder))
 915    );
 916    var readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
 917    var readFromDataView = (decoder, len) => {
 918      const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
 919      decoder.pos += len;
 920      return dv;
 921    };
 922    var readFloat32 = (decoder) => readFromDataView(decoder, 4).getFloat32(0, false);
 923    var readFloat64 = (decoder) => readFromDataView(decoder, 8).getFloat64(0, false);
 924    var readBigInt64 = (decoder) => (
 925      /** @type {any} */
 926      readFromDataView(decoder, 8).getBigInt64(0, false)
 927    );
 928    var readAnyLookupTable = [
 929      (decoder) => void 0,
 930      // CASE 127: undefined
 931      (decoder) => null,
 932      // CASE 126: null
 933      readVarInt,
 934      // CASE 125: integer
 935      readFloat32,
 936      // CASE 124: float32
 937      readFloat64,
 938      // CASE 123: float64
 939      readBigInt64,
 940      // CASE 122: bigint
 941      (decoder) => false,
 942      // CASE 121: boolean (false)
 943      (decoder) => true,
 944      // CASE 120: boolean (true)
 945      readVarString,
 946      // CASE 119: string
 947      (decoder) => {
 948        const len = readVarUint(decoder);
 949        const obj = {};
 950        for (let i = 0; i < len; i++) {
 951          const key = readVarString(decoder);
 952          obj[key] = readAny(decoder);
 953        }
 954        return obj;
 955      },
 956      (decoder) => {
 957        const len = readVarUint(decoder);
 958        const arr = [];
 959        for (let i = 0; i < len; i++) {
 960          arr.push(readAny(decoder));
 961        }
 962        return arr;
 963      },
 964      readVarUint8Array
 965      // CASE 116: Uint8Array
 966    ];
 967    var readAny = (decoder) => readAnyLookupTable[127 - readUint8(decoder)](decoder);
 968    var RleDecoder = class extends Decoder {
 969      /**
 970       * @param {Uint8Array} uint8Array
 971       * @param {function(Decoder):T} reader
 972       */
 973      constructor(uint8Array, reader) {
 974        super(uint8Array);
 975        this.reader = reader;
 976        this.s = null;
 977        this.count = 0;
 978      }
 979      read() {
 980        if (this.count === 0) {
 981          this.s = this.reader(this);
 982          if (hasContent(this)) {
 983            this.count = readVarUint(this) + 1;
 984          } else {
 985            this.count = -1;
 986          }
 987        }
 988        this.count--;
 989        return (
 990          /** @type {T} */
 991          this.s
 992        );
 993      }
 994    };
 995    var UintOptRleDecoder = class extends Decoder {
 996      /**
 997       * @param {Uint8Array} uint8Array
 998       */
 999      constructor(uint8Array) {
1000        super(uint8Array);
1001        this.s = 0;
1002        this.count = 0;
1003      }
1004      read() {
1005        if (this.count === 0) {
1006          this.s = readVarInt(this);
1007          const isNegative = isNegativeZero(this.s);
1008          this.count = 1;
1009          if (isNegative) {
1010            this.s = -this.s;
1011            this.count = readVarUint(this) + 2;
1012          }
1013        }
1014        this.count--;
1015        return (
1016          /** @type {number} */
1017          this.s
1018        );
1019      }
1020    };
1021    var IntDiffOptRleDecoder = class extends Decoder {
1022      /**
1023       * @param {Uint8Array} uint8Array
1024       */
1025      constructor(uint8Array) {
1026        super(uint8Array);
1027        this.s = 0;
1028        this.count = 0;
1029        this.diff = 0;
1030      }
1031      /**
1032       * @return {number}
1033       */
1034      read() {
1035        if (this.count === 0) {
1036          const diff = readVarInt(this);
1037          const hasCount = diff & 1;
1038          this.diff = floor(diff / 2);
1039          this.count = 1;
1040          if (hasCount) {
1041            this.count = readVarUint(this) + 2;
1042          }
1043        }
1044        this.s += this.diff;
1045        this.count--;
1046        return this.s;
1047      }
1048    };
1049    var StringDecoder = class {
1050      /**
1051       * @param {Uint8Array} uint8Array
1052       */
1053      constructor(uint8Array) {
1054        this.decoder = new UintOptRleDecoder(uint8Array);
1055        this.str = readVarString(this.decoder);
1056        this.spos = 0;
1057      }
1058      /**
1059       * @return {string}
1060       */
1061      read() {
1062        const end = this.spos + this.decoder.read();
1063        const res = this.str.slice(this.spos, end);
1064        this.spos = end;
1065        return res;
1066      }
1067    };
1068  
1069    // node_modules/lib0/webcrypto.js
1070    var subtle = crypto.subtle;
1071    var getRandomValues = crypto.getRandomValues.bind(crypto);
1072  
1073    // node_modules/lib0/random.js
1074    var uint32 = () => getRandomValues(new Uint32Array(1))[0];
1075    var uuidv4Template = "10000000-1000-4000-8000" + -1e11;
1076    var uuidv4 = () => uuidv4Template.replace(
1077      /[018]/g,
1078      /** @param {number} c */
1079      (c) => (c ^ uint32() & 15 >> c / 4).toString(16)
1080    );
1081  
1082    // node_modules/lib0/time.js
1083    var getUnixTime = Date.now;
1084  
1085    // node_modules/lib0/promise.js
1086    var create4 = (f) => (
1087      /** @type {Promise<T>} */
1088      new Promise(f)
1089    );
1090    var all = Promise.all.bind(Promise);
1091  
1092    // node_modules/lib0/conditions.js
1093    var undefinedToNull = (v) => v === void 0 ? null : v;
1094  
1095    // node_modules/lib0/storage.js
1096    var VarStoragePolyfill = class {
1097      constructor() {
1098        this.map = /* @__PURE__ */ new Map();
1099      }
1100      /**
1101       * @param {string} key
1102       * @param {any} newValue
1103       */
1104      setItem(key, newValue) {
1105        this.map.set(key, newValue);
1106      }
1107      /**
1108       * @param {string} key
1109       */
1110      getItem(key) {
1111        return this.map.get(key);
1112      }
1113    };
1114    var _localStorage = new VarStoragePolyfill();
1115    var usePolyfill = true;
1116    try {
1117      if (typeof localStorage !== "undefined" && localStorage) {
1118        _localStorage = localStorage;
1119        usePolyfill = false;
1120      }
1121    } catch (e) {
1122    }
1123    var varStorage = _localStorage;
1124  
1125    // node_modules/lib0/trait/equality.js
1126    var EqualityTraitSymbol = /* @__PURE__ */ Symbol("Equality");
1127    var equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
1128  
1129    // node_modules/lib0/object.js
1130    var isObject = (o) => typeof o === "object";
1131    var assign = Object.assign;
1132    var keys = Object.keys;
1133    var forEach = (obj, f) => {
1134      for (const key in obj) {
1135        f(obj[key], key);
1136      }
1137    };
1138    var size = (obj) => keys(obj).length;
1139    var isEmpty = (obj) => {
1140      for (const _k in obj) {
1141        return false;
1142      }
1143      return true;
1144    };
1145    var every2 = (obj, f) => {
1146      for (const key in obj) {
1147        if (!f(obj[key], key)) {
1148          return false;
1149        }
1150      }
1151      return true;
1152    };
1153    var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
1154    var equalFlat = (a, b) => a === b || size(a) === size(b) && every2(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && equals(b[key], val));
1155    var freeze = Object.freeze;
1156    var deepFreeze = (o) => {
1157      for (const key in o) {
1158        const c = o[key];
1159        if (typeof c === "object" || typeof c === "function") {
1160          deepFreeze(o[key]);
1161        }
1162      }
1163      return freeze(o);
1164    };
1165  
1166    // node_modules/lib0/function.js
1167    var callAll = (fs, args2, i = 0) => {
1168      try {
1169        for (; i < fs.length; i++) {
1170          fs[i](...args2);
1171        }
1172      } finally {
1173        if (i < fs.length) {
1174          callAll(fs, args2, i + 1);
1175        }
1176      }
1177    };
1178    var id = (a) => a;
1179    var equalityDeep = (a, b) => {
1180      if (a === b) {
1181        return true;
1182      }
1183      if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
1184        return false;
1185      }
1186      if (a[EqualityTraitSymbol] != null) {
1187        return a[EqualityTraitSymbol](b);
1188      }
1189      switch (a.constructor) {
1190        case ArrayBuffer:
1191          a = new Uint8Array(a);
1192          b = new Uint8Array(b);
1193        // eslint-disable-next-line no-fallthrough
1194        case Uint8Array: {
1195          if (a.byteLength !== b.byteLength) {
1196            return false;
1197          }
1198          for (let i = 0; i < a.length; i++) {
1199            if (a[i] !== b[i]) {
1200              return false;
1201            }
1202          }
1203          break;
1204        }
1205        case Set: {
1206          if (a.size !== b.size) {
1207            return false;
1208          }
1209          for (const value of a) {
1210            if (!b.has(value)) {
1211              return false;
1212            }
1213          }
1214          break;
1215        }
1216        case Map: {
1217          if (a.size !== b.size) {
1218            return false;
1219          }
1220          for (const key of a.keys()) {
1221            if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
1222              return false;
1223            }
1224          }
1225          break;
1226        }
1227        case void 0:
1228        case Object:
1229          if (size(a) !== size(b)) {
1230            return false;
1231          }
1232          for (const key in a) {
1233            if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
1234              return false;
1235            }
1236          }
1237          break;
1238        case Array:
1239          if (a.length !== b.length) {
1240            return false;
1241          }
1242          for (let i = 0; i < a.length; i++) {
1243            if (!equalityDeep(a[i], b[i])) {
1244              return false;
1245            }
1246          }
1247          break;
1248        default:
1249          return false;
1250      }
1251      return true;
1252    };
1253    var isOneOf = (value, options) => options.includes(value);
1254  
1255    // node_modules/lib0/environment.js
1256    var isNode = typeof process !== "undefined" && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
1257    var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && !isNode;
1258    var isMac = typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
1259    var params;
1260    var args = [];
1261    var computeParams = () => {
1262      if (params === void 0) {
1263        if (isNode) {
1264          params = create();
1265          const pargs = process.argv;
1266          let currParamName = null;
1267          for (let i = 0; i < pargs.length; i++) {
1268            const parg = pargs[i];
1269            if (parg[0] === "-") {
1270              if (currParamName !== null) {
1271                params.set(currParamName, "");
1272              }
1273              currParamName = parg;
1274            } else {
1275              if (currParamName !== null) {
1276                params.set(currParamName, parg);
1277                currParamName = null;
1278              } else {
1279                args.push(parg);
1280              }
1281            }
1282          }
1283          if (currParamName !== null) {
1284            params.set(currParamName, "");
1285          }
1286        } else if (typeof location === "object") {
1287          params = create();
1288          (location.search || "?").slice(1).split("&").forEach((kv) => {
1289            if (kv.length !== 0) {
1290              const [key, value] = kv.split("=");
1291              params.set(`--$fromCamelCase(key, "-")}`, value);
1292              params.set(`-$fromCamelCase(key, "-")}`, value);
1293            }
1294          });
1295        } else {
1296          params = create();
1297        }
1298      }
1299      return params;
1300    };
1301    var hasParam = (name) => computeParams().has(name);
1302    var getVariable = (name) => isNode ? undefinedToNull(process.env[name.toUpperCase().replaceAll("-", "_")]) : undefinedToNull(varStorage.getItem(name));
1303    var hasConf = (name) => hasParam("--" + name) || getVariable(name) !== null;
1304    var production = hasConf("production");
1305    var forceColor = isNode && isOneOf(process.env.FORCE_COLOR, ["true", "1", "2"]);
1306    var supportsColor = forceColor || !hasParam("--no-colors") && // @todo deprecate --no-colors
1307    !hasConf("no-color") && (!isNode || process.stdout.isTTY) && (!isNode || hasParam("--color") || getVariable("COLORTERM") !== null || (getVariable("TERM") || "").includes("color"));
1308  
1309    // node_modules/lib0/buffer.js
1310    var createUint8ArrayFromLen = (len) => new Uint8Array(len);
1311    var createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length2) => new Uint8Array(buffer, byteOffset, length2);
1312    var toBase64Browser = (bytes) => {
1313      let s = "";
1314      for (let i = 0; i < bytes.byteLength; i++) {
1315        s += fromCharCode(bytes[i]);
1316      }
1317      return btoa(s);
1318    };
1319    var toBase64Node = (bytes) => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
1320    var fromBase64Browser = (s) => {
1321      const a = atob(s);
1322      const bytes = createUint8ArrayFromLen(a.length);
1323      for (let i = 0; i < a.length; i++) {
1324        bytes[i] = a.charCodeAt(i);
1325      }
1326      return bytes;
1327    };
1328    var fromBase64Node = (s) => {
1329      const buf = Buffer.from(s, "base64");
1330      return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength);
1331    };
1332    var toBase64 = isBrowser ? toBase64Browser : toBase64Node;
1333    var fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
1334    var copyUint8Array = (uint8Array) => {
1335      const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
1336      newBuf.set(uint8Array);
1337      return newBuf;
1338    };
1339  
1340    // node_modules/lib0/pair.js
1341    var Pair = class {
1342      /**
1343       * @param {L} left
1344       * @param {R} right
1345       */
1346      constructor(left, right) {
1347        this.left = left;
1348        this.right = right;
1349      }
1350    };
1351    var create5 = (left, right) => new Pair(left, right);
1352  
1353    // node_modules/lib0/prng.js
1354    var bool = (gen) => gen.next() >= 0.5;
1355    var int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1356    var int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1357    var int31 = (gen, min2, max2) => int32(gen, min2, max2);
1358    var letter = (gen) => fromCharCode(int31(gen, 97, 122));
1359    var word = (gen, minLen = 0, maxLen = 20) => {
1360      const len = int31(gen, minLen, maxLen);
1361      let str = "";
1362      for (let i = 0; i < len; i++) {
1363        str += letter(gen);
1364      }
1365      return str;
1366    };
1367    var oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
1368  
1369    // node_modules/lib0/schema.js
1370    var schemaSymbol = /* @__PURE__ */ Symbol("0schema");
1371    var ValidationError = class {
1372      constructor() {
1373        this._rerrs = [];
1374      }
1375      /**
1376       * @param {string?} path
1377       * @param {string} expected
1378       * @param {string} has
1379       * @param {string?} message
1380       */
1381      extend(path, expected, has, message = null) {
1382        this._rerrs.push({ path, expected, has, message });
1383      }
1384      toString() {
1385        const s = [];
1386        for (let i = this._rerrs.length - 1; i > 0; i--) {
1387          const r = this._rerrs[i];
1388          s.push(repeat(" ", (this._rerrs.length - i) * 2) + `$r.path != null ? `[$r.path}] ` : ""}$r.has} doesn't match $r.expected}. $r.message}`);
1389        }
1390        return s.join("\n");
1391      }
1392    };
1393    var shapeExtends = (a, b) => {
1394      if (a === b) return true;
1395      if (a == null || b == null || a.constructor !== b.constructor) return false;
1396      if (a[EqualityTraitSymbol]) return equals(a, b);
1397      if (isArray(a)) {
1398        return every(
1399          a,
1400          (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
1401        );
1402      } else if (isObject(a)) {
1403        return every2(
1404          a,
1405          (aitem, akey) => shapeExtends(aitem, b[akey])
1406        );
1407      }
1408      return false;
1409    };
1410    var Schema = class {
1411      // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
1412      /**
1413       * If true, the more things are added to the shape the more objects this schema will accept (e.g.
1414       * union). By default, the more objects are added, the the fewer objects this schema will accept.
1415       * @protected
1416       */
1417      static _dilutes = false;
1418      /**
1419       * @param {Schema<any>} other
1420       */
1421      extends(other) {
1422        let [a, b] = [
1423          /** @type {any} */
1424          this.shape,
1425          /** @type {any} */
1426          other.shape
1427        ];
1428        if (
1429          /** @type {typeof Schema<any>} */
1430          this.constructor._dilutes
1431        ) [b, a] = [a, b];
1432        return shapeExtends(a, b);
1433      }
1434      /**
1435       * Overwrite this when necessary. By default, we only check the `shape` property which every shape
1436       * should have.
1437       * @param {Schema<any>} other
1438       */
1439      equals(other) {
1440        return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
1441      }
1442      [schemaSymbol]() {
1443        return true;
1444      }
1445      /**
1446       * @param {object} other
1447       */
1448      [EqualityTraitSymbol](other) {
1449        return this.equals(
1450          /** @type {any} */
1451          other
1452        );
1453      }
1454      /**
1455       * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
1456       * Schema. Validate will check the structure of the parameter and return true iff the instance
1457       * really is an instance of Schema.
1458       *
1459       * @param {T} o
1460       * @return {boolean}
1461       */
1462      validate(o) {
1463        return this.check(o);
1464      }
1465      /* c8 ignore start */
1466      /**
1467       * Similar to validate, but this method accepts untyped parameters.
1468       *
1469       * @param {any} _o
1470       * @param {ValidationError} [_err]
1471       * @return {_o is T}
1472       */
1473      check(_o, _err) {
1474        methodUnimplemented();
1475      }
1476      /* c8 ignore stop */
1477      /**
1478       * @type {Schema<T?>}
1479       */
1480      get nullable() {
1481        return $union(this, $null);
1482      }
1483      /**
1484       * @type {$Optional<Schema<T>>}
1485       */
1486      get optional() {
1487        return new $Optional(
1488          /** @type {Schema<T>} */
1489          this
1490        );
1491      }
1492      /**
1493       * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
1494       * Use this if you know that the type is of a specific type and you just want to convince the type
1495       * system.
1496       *
1497       * **Do not rely on these error messages!**
1498       * Performs an assertion check only if not in a production environment.
1499       *
1500       * @template OO
1501       * @param {OO} o
1502       * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
1503       */
1504      cast(o) {
1505        assert(o, this);
1506        return (
1507          /** @type {any} */
1508          o
1509        );
1510      }
1511      /**
1512       * EXPECTO PATRONUM!! 🪄
1513       * This function protects against type errors. Though it may not work in the real world.
1514       *
1515       * "After all this time?"
1516       * "Always." - Snape, talking about type safety
1517       *
1518       * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
1519       * Use this if you know that the type is of a specific type and you just want to convince the type
1520       * system.
1521       *
1522       * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
1523       *
1524       * **Do not rely on these error messages!**
1525       * Performs an assertion check if not in a production environment.
1526       *
1527       * @param {T} o
1528       * @return {o extends T ? T : never}
1529       */
1530      expect(o) {
1531        assert(o, this);
1532        return o;
1533      }
1534    };
1535    var $ConstructedBy = class extends Schema {
1536      /**
1537       * @param {C} c
1538       * @param {((o:Instance<C>)=>boolean)|null} check
1539       */
1540      constructor(c, check) {
1541        super();
1542        this.shape = c;
1543        this._c = check;
1544      }
1545      /**
1546       * @param {any} o
1547       * @param {ValidationError} [err]
1548       * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
1549       */
1550      check(o, err = void 0) {
1551        const c = o?.constructor === this.shape && (this._c == null || this._c(o));
1552        !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
1553        return c;
1554      }
1555    };
1556    var $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
1557    var $$constructedBy = $constructedBy($ConstructedBy);
1558    var $Custom = class extends Schema {
1559      /**
1560       * @param {(o:any) => boolean} check
1561       */
1562      constructor(check) {
1563        super();
1564        this.shape = check;
1565      }
1566      /**
1567       * @param {any} o
1568       * @param {ValidationError} err
1569       * @return {o is any}
1570       */
1571      check(o, err) {
1572        const c = this.shape(o);
1573        !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
1574        return c;
1575      }
1576    };
1577    var $custom = (check) => new $Custom(check);
1578    var $$custom = $constructedBy($Custom);
1579    var $Literal = class extends Schema {
1580      /**
1581       * @param {Array<T>} literals
1582       */
1583      constructor(literals) {
1584        super();
1585        this.shape = literals;
1586      }
1587      /**
1588       *
1589       * @param {any} o
1590       * @param {ValidationError} [err]
1591       * @return {o is T}
1592       */
1593      check(o, err) {
1594        const c = this.shape.some((a) => a === o);
1595        !c && err?.extend(null, this.shape.join(" | "), o.toString());
1596        return c;
1597      }
1598    };
1599    var $literal = (...literals) => new $Literal(literals);
1600    var $$literal = $constructedBy($Literal);
1601    var _regexEscape = (
1602      /** @type {any} */
1603      RegExp.escape || /** @type {(str:string) => string} */
1604      ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s))
1605    );
1606    var _schemaStringTemplateToRegex = (s) => {
1607      if ($string.check(s)) {
1608        return [_regexEscape(s)];
1609      }
1610      if ($$literal.check(s)) {
1611        return (
1612          /** @type {Array<string|number>} */
1613          s.shape.map((v) => v + "")
1614        );
1615      }
1616      if ($$number.check(s)) {
1617        return ["[+-]?\\d+.?\\d*"];
1618      }
1619      if ($$string.check(s)) {
1620        return [".*"];
1621      }
1622      if ($$union.check(s)) {
1623        return s.shape.map(_schemaStringTemplateToRegex).flat(1);
1624      }
1625      unexpectedCase();
1626    };
1627    var $StringTemplate = class extends Schema {
1628      /**
1629       * @param {T} shape
1630       */
1631      constructor(shape) {
1632        super();
1633        this.shape = shape;
1634        this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `($opts.join("|")})`).join("") + "$");
1635      }
1636      /**
1637       * @param {any} o
1638       * @param {ValidationError} [err]
1639       * @return {o is CastStringTemplateArgsToTemplate<T>}
1640       */
1641      check(o, err) {
1642        const c = this._r.exec(o) != null;
1643        !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
1644        return c;
1645      }
1646    };
1647    var $$stringTemplate = $constructedBy($StringTemplate);
1648    var isOptionalSymbol = /* @__PURE__ */ Symbol("optional");
1649    var $Optional = class extends Schema {
1650      /**
1651       * @param {S} shape
1652       */
1653      constructor(shape) {
1654        super();
1655        this.shape = shape;
1656      }
1657      /**
1658       * @param {any} o
1659       * @param {ValidationError} [err]
1660       * @return {o is (Unwrap<S>|undefined)}
1661       */
1662      check(o, err) {
1663        const c = o === void 0 || this.shape.check(o);
1664        !c && err?.extend(null, "undefined (optional)", "()");
1665        return c;
1666      }
1667      get [isOptionalSymbol]() {
1668        return true;
1669      }
1670    };
1671    var $$optional = $constructedBy($Optional);
1672    var $Never = class extends Schema {
1673      /**
1674       * @param {any} _o
1675       * @param {ValidationError} [err]
1676       * @return {_o is never}
1677       */
1678      check(_o, err) {
1679        err?.extend(null, "never", typeof _o);
1680        return false;
1681      }
1682    };
1683    var $never = new $Never();
1684    var $$never = $constructedBy($Never);
1685    var $Object = class _$Object extends Schema {
1686      /**
1687       * @param {S} shape
1688       * @param {boolean} partial
1689       */
1690      constructor(shape, partial = false) {
1691        super();
1692        this.shape = shape;
1693        this._isPartial = partial;
1694      }
1695      static _dilutes = true;
1696      /**
1697       * @type {Schema<Partial<$ObjectToType<S>>>}
1698       */
1699      get partial() {
1700        return new _$Object(this.shape, true);
1701      }
1702      /**
1703       * @param {any} o
1704       * @param {ValidationError} err
1705       * @return {o is $ObjectToType<S>}
1706       */
1707      check(o, err) {
1708        if (o == null) {
1709          err?.extend(null, "object", "null");
1710          return false;
1711        }
1712        return every2(this.shape, (vv, vk) => {
1713          const c = this._isPartial && !hasProperty(o, vk) || vv.check(o[vk], err);
1714          !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
1715          return c;
1716        });
1717      }
1718    };
1719    var $object = (def) => (
1720      /** @type {any} */
1721      new $Object(def)
1722    );
1723    var $$object = $constructedBy($Object);
1724    var $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
1725    var $Record = class extends Schema {
1726      /**
1727       * @param {Keys} keys
1728       * @param {Values} values
1729       */
1730      constructor(keys2, values) {
1731        super();
1732        this.shape = {
1733          keys: keys2,
1734          values
1735        };
1736      }
1737      /**
1738       * @param {any} o
1739       * @param {ValidationError} err
1740       * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
1741       */
1742      check(o, err) {
1743        return o != null && every2(o, (vv, vk) => {
1744          const ck = this.shape.keys.check(vk, err);
1745          !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
1746          return ck && this.shape.values.check(vv, err);
1747        });
1748      }
1749    };
1750    var $record = (keys2, values) => new $Record(keys2, values);
1751    var $$record = $constructedBy($Record);
1752    var $Tuple = class extends Schema {
1753      /**
1754       * @param {S} shape
1755       */
1756      constructor(shape) {
1757        super();
1758        this.shape = shape;
1759      }
1760      /**
1761       * @param {any} o
1762       * @param {ValidationError} err
1763       * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
1764       */
1765      check(o, err) {
1766        return o != null && every2(this.shape, (vv, vk) => {
1767          const c = (
1768            /** @type {Schema<any>} */
1769            vv.check(o[vk], err)
1770          );
1771          !c && err?.extend(vk.toString(), "Tuple", typeof vv);
1772          return c;
1773        });
1774      }
1775    };
1776    var $tuple = (...def) => new $Tuple(def);
1777    var $$tuple = $constructedBy($Tuple);
1778    var $Array = class extends Schema {
1779      /**
1780       * @param {Array<S>} v
1781       */
1782      constructor(v) {
1783        super();
1784        this.shape = v.length === 1 ? v[0] : new $Union(v);
1785      }
1786      /**
1787       * @param {any} o
1788       * @param {ValidationError} [err]
1789       * @return {o is Array<S extends Schema<infer T> ? T : never>} o
1790       */
1791      check(o, err) {
1792        const c = isArray(o) && every(o, (oi) => this.shape.check(oi));
1793        !c && err?.extend(null, "Array", "");
1794        return c;
1795      }
1796    };
1797    var $array = (...def) => new $Array(def);
1798    var $$array = $constructedBy($Array);
1799    var $arrayAny = $custom((o) => isArray(o));
1800    var $InstanceOf = class extends Schema {
1801      /**
1802       * @param {new (...args:any) => T} constructor
1803       * @param {((o:T) => boolean)|null} check
1804       */
1805      constructor(constructor, check) {
1806        super();
1807        this.shape = constructor;
1808        this._c = check;
1809      }
1810      /**
1811       * @param {any} o
1812       * @param {ValidationError} err
1813       * @return {o is T}
1814       */
1815      check(o, err) {
1816        const c = o instanceof this.shape && (this._c == null || this._c(o));
1817        !c && err?.extend(null, this.shape.name, o?.constructor.name);
1818        return c;
1819      }
1820    };
1821    var $instanceOf = (c, check = null) => new $InstanceOf(c, check);
1822    var $$instanceOf = $constructedBy($InstanceOf);
1823    var $$schema = $instanceOf(Schema);
1824    var $Lambda = class extends Schema {
1825      /**
1826       * @param {Args} args
1827       */
1828      constructor(args2) {
1829        super();
1830        this.len = args2.length - 1;
1831        this.args = $tuple(...args2.slice(-1));
1832        this.res = args2[this.len];
1833      }
1834      /**
1835       * @param {any} f
1836       * @param {ValidationError} err
1837       * @return {f is _LArgsToLambdaDef<Args>}
1838       */
1839      check(f, err) {
1840        const c = f.constructor === Function && f.length <= this.len;
1841        !c && err?.extend(null, "function", typeof f);
1842        return c;
1843      }
1844    };
1845    var $$lambda = $constructedBy($Lambda);
1846    var $function = $custom((o) => typeof o === "function");
1847    var $Intersection = class extends Schema {
1848      /**
1849       * @param {T} v
1850       */
1851      constructor(v) {
1852        super();
1853        this.shape = v;
1854      }
1855      /**
1856       * @param {any} o
1857       * @param {ValidationError} [err]
1858       * @return {o is Intersect<UnwrapArray<T>>}
1859       */
1860      check(o, err) {
1861        const c = every(this.shape, (check) => check.check(o, err));
1862        !c && err?.extend(null, "Intersectinon", typeof o);
1863        return c;
1864      }
1865    };
1866    var $$intersect = $constructedBy($Intersection, (o) => o.shape.length > 0);
1867    var $Union = class extends Schema {
1868      static _dilutes = true;
1869      /**
1870       * @param {Array<Schema<S>>} v
1871       */
1872      constructor(v) {
1873        super();
1874        this.shape = v;
1875      }
1876      /**
1877       * @param {any} o
1878       * @param {ValidationError} [err]
1879       * @return {o is S}
1880       */
1881      check(o, err) {
1882        const c = some(this.shape, (vv) => vv.check(o, err));
1883        err?.extend(null, "Union", typeof o);
1884        return c;
1885      }
1886    };
1887    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);
1888    var $$union = (
1889      /** @type {Schema<$Union<any>>} */
1890      $constructedBy($Union)
1891    );
1892    var _t = () => true;
1893    var $any = $custom(_t);
1894    var $$any = (
1895      /** @type {Schema<Schema<any>>} */
1896      $constructedBy($Custom, (o) => o.shape === _t)
1897    );
1898    var $bigint = $custom((o) => typeof o === "bigint");
1899    var $$bigint = (
1900      /** @type {Schema<Schema<BigInt>>} */
1901      $custom((o) => o === $bigint)
1902    );
1903    var $symbol = $custom((o) => typeof o === "symbol");
1904    var $$symbol = (
1905      /** @type {Schema<Schema<Symbol>>} */
1906      $custom((o) => o === $symbol)
1907    );
1908    var $number = $custom((o) => typeof o === "number");
1909    var $$number = (
1910      /** @type {Schema<Schema<number>>} */
1911      $custom((o) => o === $number)
1912    );
1913    var $string = $custom((o) => typeof o === "string");
1914    var $$string = (
1915      /** @type {Schema<Schema<string>>} */
1916      $custom((o) => o === $string)
1917    );
1918    var $boolean = $custom((o) => typeof o === "boolean");
1919    var $$boolean = (
1920      /** @type {Schema<Schema<Boolean>>} */
1921      $custom((o) => o === $boolean)
1922    );
1923    var $undefined = $literal(void 0);
1924    var $$undefined = (
1925      /** @type {Schema<Schema<undefined>>} */
1926      $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0)
1927    );
1928    var $void = $literal(void 0);
1929    var $null = $literal(null);
1930    var $$null = (
1931      /** @type {Schema<Schema<null>>} */
1932      $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
1933    );
1934    var $uint8Array = $constructedBy(Uint8Array);
1935    var $$uint8Array = (
1936      /** @type {Schema<Schema<Uint8Array>>} */
1937      $constructedBy($ConstructedBy, (o) => o.shape === Uint8Array)
1938    );
1939    var $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
1940    var $json = (() => {
1941      const $jsonArr = (
1942        /** @type {$Array<$any>} */
1943        $array($any)
1944      );
1945      const $jsonRecord = (
1946        /** @type {$Record<$string,$any>} */
1947        $record($string, $any)
1948      );
1949      const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
1950      $jsonArr.shape = $json2;
1951      $jsonRecord.shape.values = $json2;
1952      return $json2;
1953    })();
1954    var $ = (o) => {
1955      if ($$schema.check(o)) {
1956        return (
1957          /** @type {any} */
1958          o
1959        );
1960      } else if ($objectAny.check(o)) {
1961        const o2 = {};
1962        for (const k in o) {
1963          o2[k] = $(o[k]);
1964        }
1965        return (
1966          /** @type {any} */
1967          $object(o2)
1968        );
1969      } else if ($arrayAny.check(o)) {
1970        return (
1971          /** @type {any} */
1972          $union(...o.map($))
1973        );
1974      } else if ($primitive.check(o)) {
1975        return (
1976          /** @type {any} */
1977          $literal(o)
1978        );
1979      } else if ($function.check(o)) {
1980        return (
1981          /** @type {any} */
1982          $constructedBy(
1983            /** @type {any} */
1984            o
1985          )
1986        );
1987      }
1988      unexpectedCase();
1989    };
1990    var assert = production ? () => {
1991    } : (o, schema) => {
1992      const err = new ValidationError();
1993      if (!schema.check(o, err)) {
1994        throw create3(`Expected value to be of type $schema.constructor.name}.
1995  $err.toString()}`);
1996      }
1997    };
1998    var PatternMatcher = class {
1999      /**
2000       * @param {Schema<State>} [$state]
2001       */
2002      constructor($state) {
2003        this.patterns = [];
2004        this.$state = $state;
2005      }
2006      /**
2007       * @template P
2008       * @template R
2009       * @param {P} pattern
2010       * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
2011       * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
2012       */
2013      if(pattern, handler) {
2014        this.patterns.push({ if: $(pattern), h: handler });
2015        return this;
2016      }
2017      /**
2018       * @template R
2019       * @param {(o:any,s:State)=>R} h
2020       */
2021      else(h) {
2022        return this.if($any, h);
2023      }
2024      /**
2025       * @return {State extends undefined
2026       *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
2027       *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
2028       */
2029      done() {
2030        return (
2031          /** @type {any} */
2032          (o, s) => {
2033            for (let i = 0; i < this.patterns.length; i++) {
2034              const p = this.patterns[i];
2035              if (p.if.check(o)) {
2036                return p.h(o, s);
2037              }
2038            }
2039            throw create3("Unhandled pattern");
2040          }
2041        );
2042      }
2043    };
2044    var match = (state) => new PatternMatcher(
2045      /** @type {any} */
2046      state
2047    );
2048    var _random = (
2049      /** @type {any} */
2050      match(
2051        /** @type {Schema<prng.PRNG>} */
2052        $any
2053      ).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) => {
2054        const res = {};
2055        for (const k in o.shape) {
2056          let prop = o.shape[k];
2057          if ($$optional.check(prop)) {
2058            if (bool(gen)) {
2059              continue;
2060            }
2061            prop = prop.shape;
2062          }
2063          res[k] = _random(prop, gen);
2064        }
2065        return res;
2066      }).if($$array, (o, gen) => {
2067        const arr = [];
2068        const n = int32(gen, 0, 42);
2069        for (let i = 0; i < n; i++) {
2070          arr.push(random(gen, o.shape));
2071        }
2072        return arr;
2073      }).if($$literal, (o, gen) => {
2074        return oneOf(gen, o.shape);
2075      }).if($$null, (o, gen) => {
2076        return null;
2077      }).if($$lambda, (o, gen) => {
2078        const res = random(gen, o.res);
2079        return () => res;
2080      }).if($$any, (o, gen) => random(gen, oneOf(gen, [
2081        $number,
2082        $string,
2083        $null,
2084        $undefined,
2085        $bigint,
2086        $boolean,
2087        $array($number),
2088        $record($union("a", "b", "c"), $number)
2089      ]))).if($$record, (o, gen) => {
2090        const res = {};
2091        const keysN = int53(gen, 0, 3);
2092        for (let i = 0; i < keysN; i++) {
2093          const key = random(gen, o.shape.keys);
2094          const val = random(gen, o.shape.values);
2095          res[key] = val;
2096        }
2097        return res;
2098      }).done()
2099    );
2100    var random = (gen, schema) => (
2101      /** @type {any} */
2102      _random($(schema), gen)
2103    );
2104  
2105    // node_modules/lib0/dom.js
2106    var doc = (
2107      /** @type {Document} */
2108      typeof document !== "undefined" ? document : {}
2109    );
2110    var $fragment = $custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
2111    var domParser = (
2112      /** @type {DOMParser} */
2113      typeof DOMParser !== "undefined" ? new DOMParser() : null
2114    );
2115    var $element = $custom((el) => el.nodeType === ELEMENT_NODE);
2116    var $text = $custom((el) => el.nodeType === TEXT_NODE);
2117    var mapToStyleString = (m) => map(m, (value, key) => `$key}:$value};`).join("");
2118    var ELEMENT_NODE = doc.ELEMENT_NODE;
2119    var TEXT_NODE = doc.TEXT_NODE;
2120    var CDATA_SECTION_NODE = doc.CDATA_SECTION_NODE;
2121    var COMMENT_NODE = doc.COMMENT_NODE;
2122    var DOCUMENT_NODE = doc.DOCUMENT_NODE;
2123    var DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE;
2124    var DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
2125    var $node = $custom((el) => el.nodeType === DOCUMENT_NODE);
2126  
2127    // node_modules/lib0/symbol.js
2128    var create6 = Symbol;
2129  
2130    // node_modules/lib0/logging.common.js
2131    var BOLD = create6();
2132    var UNBOLD = create6();
2133    var BLUE = create6();
2134    var GREY = create6();
2135    var GREEN = create6();
2136    var RED = create6();
2137    var PURPLE = create6();
2138    var ORANGE = create6();
2139    var UNCOLOR = create6();
2140    var computeNoColorLoggingArgs = (args2) => {
2141      if (args2.length === 1 && args2[0]?.constructor === Function) {
2142        args2 = /** @type {Array<string|Symbol|Object|number>} */
2143        /** @type {[function]} */
2144        args2[0]();
2145      }
2146      const strBuilder = [];
2147      const logArgs = [];
2148      let i = 0;
2149      for (; i < args2.length; i++) {
2150        const arg = args2[i];
2151        if (arg === void 0) {
2152          break;
2153        } else if (arg.constructor === String || arg.constructor === Number) {
2154          strBuilder.push(arg);
2155        } else if (arg.constructor === Object) {
2156          break;
2157        }
2158      }
2159      if (i > 0) {
2160        logArgs.push(strBuilder.join(""));
2161      }
2162      for (; i < args2.length; i++) {
2163        const arg = args2[i];
2164        if (!(arg instanceof Symbol)) {
2165          logArgs.push(arg);
2166        }
2167      }
2168      return logArgs;
2169    };
2170    var lastLoggingTime = getUnixTime();
2171  
2172    // node_modules/lib0/logging.js
2173    var _browserStyleMap = {
2174      [BOLD]: create5("font-weight", "bold"),
2175      [UNBOLD]: create5("font-weight", "normal"),
2176      [BLUE]: create5("color", "blue"),
2177      [GREEN]: create5("color", "green"),
2178      [GREY]: create5("color", "grey"),
2179      [RED]: create5("color", "red"),
2180      [PURPLE]: create5("color", "purple"),
2181      [ORANGE]: create5("color", "orange"),
2182      // not well supported in chrome when debugging node with inspector - TODO: deprecate
2183      [UNCOLOR]: create5("color", "black")
2184    };
2185    var computeBrowserLoggingArgs = (args2) => {
2186      if (args2.length === 1 && args2[0]?.constructor === Function) {
2187        args2 = /** @type {Array<string|Symbol|Object|number>} */
2188        /** @type {[function]} */
2189        args2[0]();
2190      }
2191      const strBuilder = [];
2192      const styles = [];
2193      const currentStyle = create();
2194      let logArgs = [];
2195      let i = 0;
2196      for (; i < args2.length; i++) {
2197        const arg = args2[i];
2198        const style = _browserStyleMap[arg];
2199        if (style !== void 0) {
2200          currentStyle.set(style.left, style.right);
2201        } else {
2202          if (arg === void 0) {
2203            break;
2204          }
2205          if (arg.constructor === String || arg.constructor === Number) {
2206            const style2 = mapToStyleString(currentStyle);
2207            if (i > 0 || style2.length > 0) {
2208              strBuilder.push("%c" + arg);
2209              styles.push(style2);
2210            } else {
2211              strBuilder.push(arg);
2212            }
2213          } else {
2214            break;
2215          }
2216        }
2217      }
2218      if (i > 0) {
2219        logArgs = styles;
2220        logArgs.unshift(strBuilder.join(""));
2221      }
2222      for (; i < args2.length; i++) {
2223        const arg = args2[i];
2224        if (!(arg instanceof Symbol)) {
2225          logArgs.push(arg);
2226        }
2227      }
2228      return logArgs;
2229    };
2230    var computeLoggingArgs = supportsColor ? computeBrowserLoggingArgs : computeNoColorLoggingArgs;
2231    var print = (...args2) => {
2232      console.log(...computeLoggingArgs(args2));
2233      vconsoles.forEach((vc) => vc.print(args2));
2234    };
2235    var warn = (...args2) => {
2236      console.warn(...computeLoggingArgs(args2));
2237      args2.unshift(ORANGE);
2238      vconsoles.forEach((vc) => vc.print(args2));
2239    };
2240    var vconsoles = create2();
2241  
2242    // node_modules/lib0/iterator.js
2243    var createIterator = (next) => ({
2244      /**
2245       * @return {IterableIterator<T>}
2246       */
2247      [Symbol.iterator]() {
2248        return this;
2249      },
2250      // @ts-ignore
2251      next
2252    });
2253    var iteratorFilter = (iterator, filter) => createIterator(() => {
2254      let res;
2255      do {
2256        res = iterator.next();
2257      } while (!res.done && !filter(res.value));
2258      return res;
2259    });
2260    var iteratorMap = (iterator, fmap) => createIterator(() => {
2261      const { done, value } = iterator.next();
2262      return { done, value: done ? void 0 : fmap(value) };
2263    });
2264  
2265    // node_modules/yjs/dist/yjs.mjs
2266    var AbstractConnector = class extends ObservableV2 {
2267      /**
2268       * @param {Doc} ydoc
2269       * @param {any} awareness
2270       */
2271      constructor(ydoc, awareness) {
2272        super();
2273        this.doc = ydoc;
2274        this.awareness = awareness;
2275      }
2276    };
2277    var DeleteItem = class {
2278      /**
2279       * @param {number} clock
2280       * @param {number} len
2281       */
2282      constructor(clock, len) {
2283        this.clock = clock;
2284        this.len = len;
2285      }
2286    };
2287    var DeleteSet = class {
2288      constructor() {
2289        this.clients = /* @__PURE__ */ new Map();
2290      }
2291    };
2292    var iterateDeletedStructs = (transaction, ds, f) => ds.clients.forEach((deletes, clientid) => {
2293      const structs = (
2294        /** @type {Array<GC|Item>} */
2295        transaction.doc.store.clients.get(clientid)
2296      );
2297      if (structs != null) {
2298        const lastStruct = structs[structs.length - 1];
2299        const clockState = lastStruct.id.clock + lastStruct.length;
2300        for (let i = 0, del = deletes[i]; i < deletes.length && del.clock < clockState; del = deletes[++i]) {
2301          iterateStructs(transaction, structs, del.clock, del.len, f);
2302        }
2303      }
2304    });
2305    var findIndexDS = (dis, clock) => {
2306      let left = 0;
2307      let right = dis.length - 1;
2308      while (left <= right) {
2309        const midindex = floor((left + right) / 2);
2310        const mid = dis[midindex];
2311        const midclock = mid.clock;
2312        if (midclock <= clock) {
2313          if (clock < midclock + mid.len) {
2314            return midindex;
2315          }
2316          left = midindex + 1;
2317        } else {
2318          right = midindex - 1;
2319        }
2320      }
2321      return null;
2322    };
2323    var isDeleted = (ds, id2) => {
2324      const dis = ds.clients.get(id2.client);
2325      return dis !== void 0 && findIndexDS(dis, id2.clock) !== null;
2326    };
2327    var sortAndMergeDeleteSet = (ds) => {
2328      ds.clients.forEach((dels) => {
2329        dels.sort((a, b) => a.clock - b.clock);
2330        let i, j;
2331        for (i = 1, j = 1; i < dels.length; i++) {
2332          const left = dels[j - 1];
2333          const right = dels[i];
2334          if (left.clock + left.len >= right.clock) {
2335            left.len = max(left.len, right.clock + right.len - left.clock);
2336          } else {
2337            if (j < i) {
2338              dels[j] = right;
2339            }
2340            j++;
2341          }
2342        }
2343        dels.length = j;
2344      });
2345    };
2346    var mergeDeleteSets = (dss) => {
2347      const merged = new DeleteSet();
2348      for (let dssI = 0; dssI < dss.length; dssI++) {
2349        dss[dssI].clients.forEach((delsLeft, client) => {
2350          if (!merged.clients.has(client)) {
2351            const dels = delsLeft.slice();
2352            for (let i = dssI + 1; i < dss.length; i++) {
2353              appendTo(dels, dss[i].clients.get(client) || []);
2354            }
2355            merged.clients.set(client, dels);
2356          }
2357        });
2358      }
2359      sortAndMergeDeleteSet(merged);
2360      return merged;
2361    };
2362    var addToDeleteSet = (ds, client, clock, length2) => {
2363      setIfUndefined(ds.clients, client, () => (
2364        /** @type {Array<DeleteItem>} */
2365        []
2366      )).push(new DeleteItem(clock, length2));
2367    };
2368    var createDeleteSet = () => new DeleteSet();
2369    var createDeleteSetFromStructStore = (ss) => {
2370      const ds = createDeleteSet();
2371      ss.clients.forEach((structs, client) => {
2372        const dsitems = [];
2373        for (let i = 0; i < structs.length; i++) {
2374          const struct = structs[i];
2375          if (struct.deleted) {
2376            const clock = struct.id.clock;
2377            let len = struct.length;
2378            if (i + 1 < structs.length) {
2379              for (let next = structs[i + 1]; i + 1 < structs.length && next.deleted; next = structs[++i + 1]) {
2380                len += next.length;
2381              }
2382            }
2383            dsitems.push(new DeleteItem(clock, len));
2384          }
2385        }
2386        if (dsitems.length > 0) {
2387          ds.clients.set(client, dsitems);
2388        }
2389      });
2390      return ds;
2391    };
2392    var writeDeleteSet = (encoder, ds) => {
2393      writeVarUint(encoder.restEncoder, ds.clients.size);
2394      from(ds.clients.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, dsitems]) => {
2395        encoder.resetDsCurVal();
2396        writeVarUint(encoder.restEncoder, client);
2397        const len = dsitems.length;
2398        writeVarUint(encoder.restEncoder, len);
2399        for (let i = 0; i < len; i++) {
2400          const item = dsitems[i];
2401          encoder.writeDsClock(item.clock);
2402          encoder.writeDsLen(item.len);
2403        }
2404      });
2405    };
2406    var readDeleteSet = (decoder) => {
2407      const ds = new DeleteSet();
2408      const numClients = readVarUint(decoder.restDecoder);
2409      for (let i = 0; i < numClients; i++) {
2410        decoder.resetDsCurVal();
2411        const client = readVarUint(decoder.restDecoder);
2412        const numberOfDeletes = readVarUint(decoder.restDecoder);
2413        if (numberOfDeletes > 0) {
2414          const dsField = setIfUndefined(ds.clients, client, () => (
2415            /** @type {Array<DeleteItem>} */
2416            []
2417          ));
2418          for (let i2 = 0; i2 < numberOfDeletes; i2++) {
2419            dsField.push(new DeleteItem(decoder.readDsClock(), decoder.readDsLen()));
2420          }
2421        }
2422      }
2423      return ds;
2424    };
2425    var readAndApplyDeleteSet = (decoder, transaction, store) => {
2426      const unappliedDS = new DeleteSet();
2427      const numClients = readVarUint(decoder.restDecoder);
2428      for (let i = 0; i < numClients; i++) {
2429        decoder.resetDsCurVal();
2430        const client = readVarUint(decoder.restDecoder);
2431        const numberOfDeletes = readVarUint(decoder.restDecoder);
2432        const structs = store.clients.get(client) || [];
2433        const state = getState(store, client);
2434        for (let i2 = 0; i2 < numberOfDeletes; i2++) {
2435          const clock = decoder.readDsClock();
2436          const clockEnd = clock + decoder.readDsLen();
2437          if (clock < state) {
2438            if (state < clockEnd) {
2439              addToDeleteSet(unappliedDS, client, state, clockEnd - state);
2440            }
2441            let index = findIndexSS(structs, clock);
2442            let struct = structs[index];
2443            if (!struct.deleted && struct.id.clock < clock) {
2444              structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));
2445              index++;
2446            }
2447            while (index < structs.length) {
2448              struct = structs[index++];
2449              if (struct.id.clock < clockEnd) {
2450                if (!struct.deleted) {
2451                  if (clockEnd < struct.id.clock + struct.length) {
2452                    structs.splice(index, 0, splitItem(transaction, struct, clockEnd - struct.id.clock));
2453                  }
2454                  struct.delete(transaction);
2455                }
2456              } else {
2457                break;
2458              }
2459            }
2460          } else {
2461            addToDeleteSet(unappliedDS, client, clock, clockEnd - clock);
2462          }
2463        }
2464      }
2465      if (unappliedDS.clients.size > 0) {
2466        const ds = new UpdateEncoderV2();
2467        writeVarUint(ds.restEncoder, 0);
2468        writeDeleteSet(ds, unappliedDS);
2469        return ds.toUint8Array();
2470      }
2471      return null;
2472    };
2473    var equalDeleteSets = (ds1, ds2) => {
2474      if (ds1.clients.size !== ds2.clients.size) return false;
2475      for (const [client, deleteItems1] of ds1.clients.entries()) {
2476        const deleteItems2 = (
2477          /** @type {Array<import('../internals.js').DeleteItem>} */
2478          ds2.clients.get(client)
2479        );
2480        if (deleteItems2 === void 0 || deleteItems1.length !== deleteItems2.length) return false;
2481        for (let i = 0; i < deleteItems1.length; i++) {
2482          const di1 = deleteItems1[i];
2483          const di2 = deleteItems2[i];
2484          if (di1.clock !== di2.clock || di1.len !== di2.len) {
2485            return false;
2486          }
2487        }
2488      }
2489      return true;
2490    };
2491    var generateNewClientId = uint32;
2492    var Doc = class _Doc extends ObservableV2 {
2493      /**
2494       * @param {DocOpts} opts configuration
2495       */
2496      constructor({ guid = uuidv4(), collectionid = null, gc = true, gcFilter = () => true, meta = null, autoLoad = false, shouldLoad = true } = {}) {
2497        super();
2498        this.gc = gc;
2499        this.gcFilter = gcFilter;
2500        this.clientID = generateNewClientId();
2501        this.guid = guid;
2502        this.collectionid = collectionid;
2503        this.share = /* @__PURE__ */ new Map();
2504        this.store = new StructStore();
2505        this._transaction = null;
2506        this._transactionCleanups = [];
2507        this.subdocs = /* @__PURE__ */ new Set();
2508        this._item = null;
2509        this.shouldLoad = shouldLoad;
2510        this.autoLoad = autoLoad;
2511        this.meta = meta;
2512        this.isLoaded = false;
2513        this.isSynced = false;
2514        this.isDestroyed = false;
2515        this.whenLoaded = create4((resolve) => {
2516          this.on("load", () => {
2517            this.isLoaded = true;
2518            resolve(this);
2519          });
2520        });
2521        const provideSyncedPromise = () => create4((resolve) => {
2522          const eventHandler = (isSynced) => {
2523            if (isSynced === void 0 || isSynced === true) {
2524              this.off("sync", eventHandler);
2525              resolve();
2526            }
2527          };
2528          this.on("sync", eventHandler);
2529        });
2530        this.on("sync", (isSynced) => {
2531          if (isSynced === false && this.isSynced) {
2532            this.whenSynced = provideSyncedPromise();
2533          }
2534          this.isSynced = isSynced === void 0 || isSynced === true;
2535          if (this.isSynced && !this.isLoaded) {
2536            this.emit("load", [this]);
2537          }
2538        });
2539        this.whenSynced = provideSyncedPromise();
2540      }
2541      /**
2542       * Notify the parent document that you request to load data into this subdocument (if it is a subdocument).
2543       *
2544       * `load()` might be used in the future to request any provider to load the most current data.
2545       *
2546       * It is safe to call `load()` multiple times.
2547       */
2548      load() {
2549        const item = this._item;
2550        if (item !== null && !this.shouldLoad) {
2551          transact(
2552            /** @type {any} */
2553            item.parent.doc,
2554            (transaction) => {
2555              transaction.subdocsLoaded.add(this);
2556            },
2557            null,
2558            true
2559          );
2560        }
2561        this.shouldLoad = true;
2562      }
2563      getSubdocs() {
2564        return this.subdocs;
2565      }
2566      getSubdocGuids() {
2567        return new Set(from(this.subdocs).map((doc2) => doc2.guid));
2568      }
2569      /**
2570       * Changes that happen inside of a transaction are bundled. This means that
2571       * the observer fires _after_ the transaction is finished and that all changes
2572       * that happened inside of the transaction are sent as one message to the
2573       * other peers.
2574       *
2575       * @template T
2576       * @param {function(Transaction):T} f The function that should be executed as a transaction
2577       * @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin
2578       * @return T
2579       *
2580       * @public
2581       */
2582      transact(f, origin2 = null) {
2583        return transact(this, f, origin2);
2584      }
2585      /**
2586       * Define a shared data type.
2587       *
2588       * Multiple calls of `ydoc.get(name, TypeConstructor)` yield the same result
2589       * and do not overwrite each other. I.e.
2590       * `ydoc.get(name, Y.Array) === ydoc.get(name, Y.Array)`
2591       *
2592       * After this method is called, the type is also available on `ydoc.share.get(name)`.
2593       *
2594       * *Best Practices:*
2595       * Define all types right after the Y.Doc instance is created and store them in a separate object.
2596       * Also use the typed methods `getText(name)`, `getArray(name)`, ..
2597       *
2598       * @template {typeof AbstractType<any>} Type
2599       * @example
2600       *   const ydoc = new Y.Doc(..)
2601       *   const appState = {
2602       *     document: ydoc.getText('document')
2603       *     comments: ydoc.getArray('comments')
2604       *   }
2605       *
2606       * @param {string} name
2607       * @param {Type} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
2608       * @return {InstanceType<Type>} The created type. Constructed with TypeConstructor
2609       *
2610       * @public
2611       */
2612      get(name, TypeConstructor = (
2613        /** @type {any} */
2614        AbstractType
2615      )) {
2616        const type = setIfUndefined(this.share, name, () => {
2617          const t = new TypeConstructor();
2618          t._integrate(this, null);
2619          return t;
2620        });
2621        const Constr = type.constructor;
2622        if (TypeConstructor !== AbstractType && Constr !== TypeConstructor) {
2623          if (Constr === AbstractType) {
2624            const t = new TypeConstructor();
2625            t._map = type._map;
2626            type._map.forEach(
2627              /** @param {Item?} n */
2628              (n) => {
2629                for (; n !== null; n = n.left) {
2630                  n.parent = t;
2631                }
2632              }
2633            );
2634            t._start = type._start;
2635            for (let n = t._start; n !== null; n = n.right) {
2636              n.parent = t;
2637            }
2638            t._length = type._length;
2639            this.share.set(name, t);
2640            t._integrate(this, null);
2641            return (
2642              /** @type {InstanceType<Type>} */
2643              t
2644            );
2645          } else {
2646            throw new Error(`Type with the name $name} has already been defined with a different constructor`);
2647          }
2648        }
2649        return (
2650          /** @type {InstanceType<Type>} */
2651          type
2652        );
2653      }
2654      /**
2655       * @template T
2656       * @param {string} [name]
2657       * @return {YArray<T>}
2658       *
2659       * @public
2660       */
2661      getArray(name = "") {
2662        return (
2663          /** @type {YArray<T>} */
2664          this.get(name, YArray)
2665        );
2666      }
2667      /**
2668       * @param {string} [name]
2669       * @return {YText}
2670       *
2671       * @public
2672       */
2673      getText(name = "") {
2674        return this.get(name, YText);
2675      }
2676      /**
2677       * @template T
2678       * @param {string} [name]
2679       * @return {YMap<T>}
2680       *
2681       * @public
2682       */
2683      getMap(name = "") {
2684        return (
2685          /** @type {YMap<T>} */
2686          this.get(name, YMap)
2687        );
2688      }
2689      /**
2690       * @param {string} [name]
2691       * @return {YXmlElement}
2692       *
2693       * @public
2694       */
2695      getXmlElement(name = "") {
2696        return (
2697          /** @type {YXmlElement<{[key:string]:string}>} */
2698          this.get(name, YXmlElement)
2699        );
2700      }
2701      /**
2702       * @param {string} [name]
2703       * @return {YXmlFragment}
2704       *
2705       * @public
2706       */
2707      getXmlFragment(name = "") {
2708        return this.get(name, YXmlFragment);
2709      }
2710      /**
2711       * Converts the entire document into a js object, recursively traversing each yjs type
2712       * Doesn't log types that have not been defined (using ydoc.getType(..)).
2713       *
2714       * @deprecated Do not use this method and rather call toJSON directly on the shared types.
2715       *
2716       * @return {Object<string, any>}
2717       */
2718      toJSON() {
2719        const doc2 = {};
2720        this.share.forEach((value, key) => {
2721          doc2[key] = value.toJSON();
2722        });
2723        return doc2;
2724      }
2725      /**
2726       * Emit `destroy` event and unregister all event handlers.
2727       */
2728      destroy() {
2729        this.isDestroyed = true;
2730        from(this.subdocs).forEach((subdoc) => subdoc.destroy());
2731        const item = this._item;
2732        if (item !== null) {
2733          this._item = null;
2734          const content = (
2735            /** @type {ContentDoc} */
2736            item.content
2737          );
2738          content.doc = new _Doc({ guid: this.guid, ...content.opts, shouldLoad: false });
2739          content.doc._item = item;
2740          transact(
2741            /** @type {any} */
2742            item.parent.doc,
2743            (transaction) => {
2744              const doc2 = content.doc;
2745              if (!item.deleted) {
2746                transaction.subdocsAdded.add(doc2);
2747              }
2748              transaction.subdocsRemoved.add(this);
2749            },
2750            null,
2751            true
2752          );
2753        }
2754        this.emit("destroyed", [true]);
2755        this.emit("destroy", [this]);
2756        super.destroy();
2757      }
2758    };
2759    var DSDecoderV1 = class {
2760      /**
2761       * @param {decoding.Decoder} decoder
2762       */
2763      constructor(decoder) {
2764        this.restDecoder = decoder;
2765      }
2766      resetDsCurVal() {
2767      }
2768      /**
2769       * @return {number}
2770       */
2771      readDsClock() {
2772        return readVarUint(this.restDecoder);
2773      }
2774      /**
2775       * @return {number}
2776       */
2777      readDsLen() {
2778        return readVarUint(this.restDecoder);
2779      }
2780    };
2781    var UpdateDecoderV1 = class extends DSDecoderV1 {
2782      /**
2783       * @return {ID}
2784       */
2785      readLeftID() {
2786        return createID(readVarUint(this.restDecoder), readVarUint(this.restDecoder));
2787      }
2788      /**
2789       * @return {ID}
2790       */
2791      readRightID() {
2792        return createID(readVarUint(this.restDecoder), readVarUint(this.restDecoder));
2793      }
2794      /**
2795       * Read the next client id.
2796       * Use this in favor of readID whenever possible to reduce the number of objects created.
2797       */
2798      readClient() {
2799        return readVarUint(this.restDecoder);
2800      }
2801      /**
2802       * @return {number} info An unsigned 8-bit integer
2803       */
2804      readInfo() {
2805        return readUint8(this.restDecoder);
2806      }
2807      /**
2808       * @return {string}
2809       */
2810      readString() {
2811        return readVarString(this.restDecoder);
2812      }
2813      /**
2814       * @return {boolean} isKey
2815       */
2816      readParentInfo() {
2817        return readVarUint(this.restDecoder) === 1;
2818      }
2819      /**
2820       * @return {number} info An unsigned 8-bit integer
2821       */
2822      readTypeRef() {
2823        return readVarUint(this.restDecoder);
2824      }
2825      /**
2826       * Write len of a struct - well suited for Opt RLE encoder.
2827       *
2828       * @return {number} len
2829       */
2830      readLen() {
2831        return readVarUint(this.restDecoder);
2832      }
2833      /**
2834       * @return {any}
2835       */
2836      readAny() {
2837        return readAny(this.restDecoder);
2838      }
2839      /**
2840       * @return {Uint8Array}
2841       */
2842      readBuf() {
2843        return copyUint8Array(readVarUint8Array(this.restDecoder));
2844      }
2845      /**
2846       * Legacy implementation uses JSON parse. We use any-decoding in v2.
2847       *
2848       * @return {any}
2849       */
2850      readJSON() {
2851        return JSON.parse(readVarString(this.restDecoder));
2852      }
2853      /**
2854       * @return {string}
2855       */
2856      readKey() {
2857        return readVarString(this.restDecoder);
2858      }
2859    };
2860    var DSDecoderV2 = class {
2861      /**
2862       * @param {decoding.Decoder} decoder
2863       */
2864      constructor(decoder) {
2865        this.dsCurrVal = 0;
2866        this.restDecoder = decoder;
2867      }
2868      resetDsCurVal() {
2869        this.dsCurrVal = 0;
2870      }
2871      /**
2872       * @return {number}
2873       */
2874      readDsClock() {
2875        this.dsCurrVal += readVarUint(this.restDecoder);
2876        return this.dsCurrVal;
2877      }
2878      /**
2879       * @return {number}
2880       */
2881      readDsLen() {
2882        const diff = readVarUint(this.restDecoder) + 1;
2883        this.dsCurrVal += diff;
2884        return diff;
2885      }
2886    };
2887    var UpdateDecoderV2 = class extends DSDecoderV2 {
2888      /**
2889       * @param {decoding.Decoder} decoder
2890       */
2891      constructor(decoder) {
2892        super(decoder);
2893        this.keys = [];
2894        readVarUint(decoder);
2895        this.keyClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2896        this.clientDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2897        this.leftClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2898        this.rightClockDecoder = new IntDiffOptRleDecoder(readVarUint8Array(decoder));
2899        this.infoDecoder = new RleDecoder(readVarUint8Array(decoder), readUint8);
2900        this.stringDecoder = new StringDecoder(readVarUint8Array(decoder));
2901        this.parentInfoDecoder = new RleDecoder(readVarUint8Array(decoder), readUint8);
2902        this.typeRefDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2903        this.lenDecoder = new UintOptRleDecoder(readVarUint8Array(decoder));
2904      }
2905      /**
2906       * @return {ID}
2907       */
2908      readLeftID() {
2909        return new ID(this.clientDecoder.read(), this.leftClockDecoder.read());
2910      }
2911      /**
2912       * @return {ID}
2913       */
2914      readRightID() {
2915        return new ID(this.clientDecoder.read(), this.rightClockDecoder.read());
2916      }
2917      /**
2918       * Read the next client id.
2919       * Use this in favor of readID whenever possible to reduce the number of objects created.
2920       */
2921      readClient() {
2922        return this.clientDecoder.read();
2923      }
2924      /**
2925       * @return {number} info An unsigned 8-bit integer
2926       */
2927      readInfo() {
2928        return (
2929          /** @type {number} */
2930          this.infoDecoder.read()
2931        );
2932      }
2933      /**
2934       * @return {string}
2935       */
2936      readString() {
2937        return this.stringDecoder.read();
2938      }
2939      /**
2940       * @return {boolean}
2941       */
2942      readParentInfo() {
2943        return this.parentInfoDecoder.read() === 1;
2944      }
2945      /**
2946       * @return {number} An unsigned 8-bit integer
2947       */
2948      readTypeRef() {
2949        return this.typeRefDecoder.read();
2950      }
2951      /**
2952       * Write len of a struct - well suited for Opt RLE encoder.
2953       *
2954       * @return {number}
2955       */
2956      readLen() {
2957        return this.lenDecoder.read();
2958      }
2959      /**
2960       * @return {any}
2961       */
2962      readAny() {
2963        return readAny(this.restDecoder);
2964      }
2965      /**
2966       * @return {Uint8Array}
2967       */
2968      readBuf() {
2969        return readVarUint8Array(this.restDecoder);
2970      }
2971      /**
2972       * This is mainly here for legacy purposes.
2973       *
2974       * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
2975       *
2976       * @return {any}
2977       */
2978      readJSON() {
2979        return readAny(this.restDecoder);
2980      }
2981      /**
2982       * @return {string}
2983       */
2984      readKey() {
2985        const keyClock = this.keyClockDecoder.read();
2986        if (keyClock < this.keys.length) {
2987          return this.keys[keyClock];
2988        } else {
2989          const key = this.stringDecoder.read();
2990          this.keys.push(key);
2991          return key;
2992        }
2993      }
2994    };
2995    var DSEncoderV1 = class {
2996      constructor() {
2997        this.restEncoder = createEncoder();
2998      }
2999      toUint8Array() {
3000        return toUint8Array(this.restEncoder);
3001      }
3002      resetDsCurVal() {
3003      }
3004      /**
3005       * @param {number} clock
3006       */
3007      writeDsClock(clock) {
3008        writeVarUint(this.restEncoder, clock);
3009      }
3010      /**
3011       * @param {number} len
3012       */
3013      writeDsLen(len) {
3014        writeVarUint(this.restEncoder, len);
3015      }
3016    };
3017    var UpdateEncoderV1 = class extends DSEncoderV1 {
3018      /**
3019       * @param {ID} id
3020       */
3021      writeLeftID(id2) {
3022        writeVarUint(this.restEncoder, id2.client);
3023        writeVarUint(this.restEncoder, id2.clock);
3024      }
3025      /**
3026       * @param {ID} id
3027       */
3028      writeRightID(id2) {
3029        writeVarUint(this.restEncoder, id2.client);
3030        writeVarUint(this.restEncoder, id2.clock);
3031      }
3032      /**
3033       * Use writeClient and writeClock instead of writeID if possible.
3034       * @param {number} client
3035       */
3036      writeClient(client) {
3037        writeVarUint(this.restEncoder, client);
3038      }
3039      /**
3040       * @param {number} info An unsigned 8-bit integer
3041       */
3042      writeInfo(info) {
3043        writeUint8(this.restEncoder, info);
3044      }
3045      /**
3046       * @param {string} s
3047       */
3048      writeString(s) {
3049        writeVarString(this.restEncoder, s);
3050      }
3051      /**
3052       * @param {boolean} isYKey
3053       */
3054      writeParentInfo(isYKey) {
3055        writeVarUint(this.restEncoder, isYKey ? 1 : 0);
3056      }
3057      /**
3058       * @param {number} info An unsigned 8-bit integer
3059       */
3060      writeTypeRef(info) {
3061        writeVarUint(this.restEncoder, info);
3062      }
3063      /**
3064       * Write len of a struct - well suited for Opt RLE encoder.
3065       *
3066       * @param {number} len
3067       */
3068      writeLen(len) {
3069        writeVarUint(this.restEncoder, len);
3070      }
3071      /**
3072       * @param {any} any
3073       */
3074      writeAny(any2) {
3075        writeAny(this.restEncoder, any2);
3076      }
3077      /**
3078       * @param {Uint8Array} buf
3079       */
3080      writeBuf(buf) {
3081        writeVarUint8Array(this.restEncoder, buf);
3082      }
3083      /**
3084       * @param {any} embed
3085       */
3086      writeJSON(embed) {
3087        writeVarString(this.restEncoder, JSON.stringify(embed));
3088      }
3089      /**
3090       * @param {string} key
3091       */
3092      writeKey(key) {
3093        writeVarString(this.restEncoder, key);
3094      }
3095    };
3096    var DSEncoderV2 = class {
3097      constructor() {
3098        this.restEncoder = createEncoder();
3099        this.dsCurrVal = 0;
3100      }
3101      toUint8Array() {
3102        return toUint8Array(this.restEncoder);
3103      }
3104      resetDsCurVal() {
3105        this.dsCurrVal = 0;
3106      }
3107      /**
3108       * @param {number} clock
3109       */
3110      writeDsClock(clock) {
3111        const diff = clock - this.dsCurrVal;
3112        this.dsCurrVal = clock;
3113        writeVarUint(this.restEncoder, diff);
3114      }
3115      /**
3116       * @param {number} len
3117       */
3118      writeDsLen(len) {
3119        if (len === 0) {
3120          unexpectedCase();
3121        }
3122        writeVarUint(this.restEncoder, len - 1);
3123        this.dsCurrVal += len;
3124      }
3125    };
3126    var UpdateEncoderV2 = class extends DSEncoderV2 {
3127      constructor() {
3128        super();
3129        this.keyMap = /* @__PURE__ */ new Map();
3130        this.keyClock = 0;
3131        this.keyClockEncoder = new IntDiffOptRleEncoder();
3132        this.clientEncoder = new UintOptRleEncoder();
3133        this.leftClockEncoder = new IntDiffOptRleEncoder();
3134        this.rightClockEncoder = new IntDiffOptRleEncoder();
3135        this.infoEncoder = new RleEncoder(writeUint8);
3136        this.stringEncoder = new StringEncoder();
3137        this.parentInfoEncoder = new RleEncoder(writeUint8);
3138        this.typeRefEncoder = new UintOptRleEncoder();
3139        this.lenEncoder = new UintOptRleEncoder();
3140      }
3141      toUint8Array() {
3142        const encoder = createEncoder();
3143        writeVarUint(encoder, 0);
3144        writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array());
3145        writeVarUint8Array(encoder, this.clientEncoder.toUint8Array());
3146        writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array());
3147        writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array());
3148        writeVarUint8Array(encoder, toUint8Array(this.infoEncoder));
3149        writeVarUint8Array(encoder, this.stringEncoder.toUint8Array());
3150        writeVarUint8Array(encoder, toUint8Array(this.parentInfoEncoder));
3151        writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array());
3152        writeVarUint8Array(encoder, this.lenEncoder.toUint8Array());
3153        writeUint8Array(encoder, toUint8Array(this.restEncoder));
3154        return toUint8Array(encoder);
3155      }
3156      /**
3157       * @param {ID} id
3158       */
3159      writeLeftID(id2) {
3160        this.clientEncoder.write(id2.client);
3161        this.leftClockEncoder.write(id2.clock);
3162      }
3163      /**
3164       * @param {ID} id
3165       */
3166      writeRightID(id2) {
3167        this.clientEncoder.write(id2.client);
3168        this.rightClockEncoder.write(id2.clock);
3169      }
3170      /**
3171       * @param {number} client
3172       */
3173      writeClient(client) {
3174        this.clientEncoder.write(client);
3175      }
3176      /**
3177       * @param {number} info An unsigned 8-bit integer
3178       */
3179      writeInfo(info) {
3180        this.infoEncoder.write(info);
3181      }
3182      /**
3183       * @param {string} s
3184       */
3185      writeString(s) {
3186        this.stringEncoder.write(s);
3187      }
3188      /**
3189       * @param {boolean} isYKey
3190       */
3191      writeParentInfo(isYKey) {
3192        this.parentInfoEncoder.write(isYKey ? 1 : 0);
3193      }
3194      /**
3195       * @param {number} info An unsigned 8-bit integer
3196       */
3197      writeTypeRef(info) {
3198        this.typeRefEncoder.write(info);
3199      }
3200      /**
3201       * Write len of a struct - well suited for Opt RLE encoder.
3202       *
3203       * @param {number} len
3204       */
3205      writeLen(len) {
3206        this.lenEncoder.write(len);
3207      }
3208      /**
3209       * @param {any} any
3210       */
3211      writeAny(any2) {
3212        writeAny(this.restEncoder, any2);
3213      }
3214      /**
3215       * @param {Uint8Array} buf
3216       */
3217      writeBuf(buf) {
3218        writeVarUint8Array(this.restEncoder, buf);
3219      }
3220      /**
3221       * This is mainly here for legacy purposes.
3222       *
3223       * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
3224       *
3225       * @param {any} embed
3226       */
3227      writeJSON(embed) {
3228        writeAny(this.restEncoder, embed);
3229      }
3230      /**
3231       * Property keys are often reused. For example, in y-prosemirror the key `bold` might
3232       * occur very often. For a 3d application, the key `position` might occur very often.
3233       *
3234       * We cache these keys in a Map and refer to them via a unique number.
3235       *
3236       * @param {string} key
3237       */
3238      writeKey(key) {
3239        const clock = this.keyMap.get(key);
3240        if (clock === void 0) {
3241          this.keyClockEncoder.write(this.keyClock++);
3242          this.stringEncoder.write(key);
3243        } else {
3244          this.keyClockEncoder.write(clock);
3245        }
3246      }
3247    };
3248    var writeStructs = (encoder, structs, client, clock) => {
3249      clock = max(clock, structs[0].id.clock);
3250      const startNewStructs = findIndexSS(structs, clock);
3251      writeVarUint(encoder.restEncoder, structs.length - startNewStructs);
3252      encoder.writeClient(client);
3253      writeVarUint(encoder.restEncoder, clock);
3254      const firstStruct = structs[startNewStructs];
3255      firstStruct.write(encoder, clock - firstStruct.id.clock);
3256      for (let i = startNewStructs + 1; i < structs.length; i++) {
3257        structs[i].write(encoder, 0);
3258      }
3259    };
3260    var writeClientsStructs = (encoder, store, _sm) => {
3261      const sm = /* @__PURE__ */ new Map();
3262      _sm.forEach((clock, client) => {
3263        if (getState(store, client) > clock) {
3264          sm.set(client, clock);
3265        }
3266      });
3267      getStateVector(store).forEach((_clock, client) => {
3268        if (!_sm.has(client)) {
3269          sm.set(client, 0);
3270        }
3271      });
3272      writeVarUint(encoder.restEncoder, sm.size);
3273      from(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
3274        writeStructs(
3275          encoder,
3276          /** @type {Array<GC|Item>} */
3277          store.clients.get(client),
3278          client,
3279          clock
3280        );
3281      });
3282    };
3283    var readClientsStructRefs = (decoder, doc2) => {
3284      const clientRefs = create();
3285      const numOfStateUpdates = readVarUint(decoder.restDecoder);
3286      for (let i = 0; i < numOfStateUpdates; i++) {
3287        const numberOfStructs = readVarUint(decoder.restDecoder);
3288        const refs = new Array(numberOfStructs);
3289        const client = decoder.readClient();
3290        let clock = readVarUint(decoder.restDecoder);
3291        clientRefs.set(client, { i: 0, refs });
3292        for (let i2 = 0; i2 < numberOfStructs; i2++) {
3293          const info = decoder.readInfo();
3294          switch (BITS5 & info) {
3295            case 0: {
3296              const len = decoder.readLen();
3297              refs[i2] = new GC(createID(client, clock), len);
3298              clock += len;
3299              break;
3300            }
3301            case 10: {
3302              const len = readVarUint(decoder.restDecoder);
3303              refs[i2] = new Skip(createID(client, clock), len);
3304              clock += len;
3305              break;
3306            }
3307            default: {
3308              const cantCopyParentInfo = (info & (BIT7 | BIT8)) === 0;
3309              const struct = new Item(
3310                createID(client, clock),
3311                null,
3312                // left
3313                (info & BIT8) === BIT8 ? decoder.readLeftID() : null,
3314                // origin
3315                null,
3316                // right
3317                (info & BIT7) === BIT7 ? decoder.readRightID() : null,
3318                // right origin
3319                cantCopyParentInfo ? decoder.readParentInfo() ? doc2.get(decoder.readString()) : decoder.readLeftID() : null,
3320                // parent
3321                cantCopyParentInfo && (info & BIT6) === BIT6 ? decoder.readString() : null,
3322                // parentSub
3323                readItemContent(decoder, info)
3324                // item content
3325              );
3326              refs[i2] = struct;
3327              clock += struct.length;
3328            }
3329          }
3330        }
3331      }
3332      return clientRefs;
3333    };
3334    var integrateStructs = (transaction, store, clientsStructRefs) => {
3335      const stack = [];
3336      let clientsStructRefsIds = from(clientsStructRefs.keys()).sort((a, b) => a - b);
3337      if (clientsStructRefsIds.length === 0) {
3338        return null;
3339      }
3340      const getNextStructTarget = () => {
3341        if (clientsStructRefsIds.length === 0) {
3342          return null;
3343        }
3344        let nextStructsTarget = (
3345          /** @type {{i:number,refs:Array<GC|Item>}} */
3346          clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1])
3347        );
3348        while (nextStructsTarget.refs.length === nextStructsTarget.i) {
3349          clientsStructRefsIds.pop();
3350          if (clientsStructRefsIds.length > 0) {
3351            nextStructsTarget = /** @type {{i:number,refs:Array<GC|Item>}} */
3352            clientsStructRefs.get(clientsStructRefsIds[clientsStructRefsIds.length - 1]);
3353          } else {
3354            return null;
3355          }
3356        }
3357        return nextStructsTarget;
3358      };
3359      let curStructsTarget = getNextStructTarget();
3360      if (curStructsTarget === null) {
3361        return null;
3362      }
3363      const restStructs = new StructStore();
3364      const missingSV = /* @__PURE__ */ new Map();
3365      const updateMissingSv = (client, clock) => {
3366        const mclock = missingSV.get(client);
3367        if (mclock == null || mclock > clock) {
3368          missingSV.set(client, clock);
3369        }
3370      };
3371      let stackHead = (
3372        /** @type {any} */
3373        curStructsTarget.refs[
3374          /** @type {any} */
3375          curStructsTarget.i++
3376        ]
3377      );
3378      const state = /* @__PURE__ */ new Map();
3379      const addStackToRestSS = () => {
3380        for (const item of stack) {
3381          const client = item.id.client;
3382          const inapplicableItems = clientsStructRefs.get(client);
3383          if (inapplicableItems) {
3384            inapplicableItems.i--;
3385            restStructs.clients.set(client, inapplicableItems.refs.slice(inapplicableItems.i));
3386            clientsStructRefs.delete(client);
3387            inapplicableItems.i = 0;
3388            inapplicableItems.refs = [];
3389          } else {
3390            restStructs.clients.set(client, [item]);
3391          }
3392          clientsStructRefsIds = clientsStructRefsIds.filter((c) => c !== client);
3393        }
3394        stack.length = 0;
3395      };
3396      while (true) {
3397        if (stackHead.constructor !== Skip) {
3398          const localClock = setIfUndefined(state, stackHead.id.client, () => getState(store, stackHead.id.client));
3399          const offset = localClock - stackHead.id.clock;
3400          if (offset < 0) {
3401            stack.push(stackHead);
3402            updateMissingSv(stackHead.id.client, stackHead.id.clock - 1);
3403            addStackToRestSS();
3404          } else {
3405            const missing = stackHead.getMissing(transaction, store);
3406            if (missing !== null) {
3407              stack.push(stackHead);
3408              const structRefs = clientsStructRefs.get(
3409                /** @type {number} */
3410                missing
3411              ) || { refs: [], i: 0 };
3412              if (structRefs.refs.length === structRefs.i) {
3413                updateMissingSv(
3414                  /** @type {number} */
3415                  missing,
3416                  getState(store, missing)
3417                );
3418                addStackToRestSS();
3419              } else {
3420                stackHead = structRefs.refs[structRefs.i++];
3421                continue;
3422              }
3423            } else if (offset === 0 || offset < stackHead.length) {
3424              stackHead.integrate(transaction, offset);
3425              state.set(stackHead.id.client, stackHead.id.clock + stackHead.length);
3426            }
3427          }
3428        }
3429        if (stack.length > 0) {
3430          stackHead = /** @type {GC|Item} */
3431          stack.pop();
3432        } else if (curStructsTarget !== null && curStructsTarget.i < curStructsTarget.refs.length) {
3433          stackHead = /** @type {GC|Item} */
3434          curStructsTarget.refs[curStructsTarget.i++];
3435        } else {
3436          curStructsTarget = getNextStructTarget();
3437          if (curStructsTarget === null) {
3438            break;
3439          } else {
3440            stackHead = /** @type {GC|Item} */
3441            curStructsTarget.refs[curStructsTarget.i++];
3442          }
3443        }
3444      }
3445      if (restStructs.clients.size > 0) {
3446        const encoder = new UpdateEncoderV2();
3447        writeClientsStructs(encoder, restStructs, /* @__PURE__ */ new Map());
3448        writeVarUint(encoder.restEncoder, 0);
3449        return { missing: missingSV, update: encoder.toUint8Array() };
3450      }
3451      return null;
3452    };
3453    var writeStructsFromTransaction = (encoder, transaction) => writeClientsStructs(encoder, transaction.doc.store, transaction.beforeState);
3454    var readUpdateV2 = (decoder, ydoc, transactionOrigin, structDecoder = new UpdateDecoderV2(decoder)) => transact(ydoc, (transaction) => {
3455      transaction.local = false;
3456      let retry = false;
3457      const doc2 = transaction.doc;
3458      const store = doc2.store;
3459      const ss = readClientsStructRefs(structDecoder, doc2);
3460      const restStructs = integrateStructs(transaction, store, ss);
3461      const pending = store.pendingStructs;
3462      if (pending) {
3463        for (const [client, clock] of pending.missing) {
3464          if (clock < getState(store, client)) {
3465            retry = true;
3466            break;
3467          }
3468        }
3469        if (restStructs) {
3470          for (const [client, clock] of restStructs.missing) {
3471            const mclock = pending.missing.get(client);
3472            if (mclock == null || mclock > clock) {
3473              pending.missing.set(client, clock);
3474            }
3475          }
3476          pending.update = mergeUpdatesV2([pending.update, restStructs.update]);
3477        }
3478      } else {
3479        store.pendingStructs = restStructs;
3480      }
3481      const dsRest = readAndApplyDeleteSet(structDecoder, transaction, store);
3482      if (store.pendingDs) {
3483        const pendingDSUpdate = new UpdateDecoderV2(createDecoder(store.pendingDs));
3484        readVarUint(pendingDSUpdate.restDecoder);
3485        const dsRest2 = readAndApplyDeleteSet(pendingDSUpdate, transaction, store);
3486        if (dsRest && dsRest2) {
3487          store.pendingDs = mergeUpdatesV2([dsRest, dsRest2]);
3488        } else {
3489          store.pendingDs = dsRest || dsRest2;
3490        }
3491      } else {
3492        store.pendingDs = dsRest;
3493      }
3494      if (retry) {
3495        const update = (
3496          /** @type {{update: Uint8Array}} */
3497          store.pendingStructs.update
3498        );
3499        store.pendingStructs = null;
3500        applyUpdateV2(transaction.doc, update);
3501      }
3502    }, transactionOrigin, false);
3503    var readUpdate = (decoder, ydoc, transactionOrigin) => readUpdateV2(decoder, ydoc, transactionOrigin, new UpdateDecoderV1(decoder));
3504    var applyUpdateV2 = (ydoc, update, transactionOrigin, YDecoder = UpdateDecoderV2) => {
3505      const decoder = createDecoder(update);
3506      readUpdateV2(decoder, ydoc, transactionOrigin, new YDecoder(decoder));
3507    };
3508    var applyUpdate = (ydoc, update, transactionOrigin) => applyUpdateV2(ydoc, update, transactionOrigin, UpdateDecoderV1);
3509    var writeStateAsUpdate = (encoder, doc2, targetStateVector = /* @__PURE__ */ new Map()) => {
3510      writeClientsStructs(encoder, doc2.store, targetStateVector);
3511      writeDeleteSet(encoder, createDeleteSetFromStructStore(doc2.store));
3512    };
3513    var encodeStateAsUpdateV2 = (doc2, encodedTargetStateVector = new Uint8Array([0]), encoder = new UpdateEncoderV2()) => {
3514      const targetStateVector = decodeStateVector(encodedTargetStateVector);
3515      writeStateAsUpdate(encoder, doc2, targetStateVector);
3516      const updates = [encoder.toUint8Array()];
3517      if (doc2.store.pendingDs) {
3518        updates.push(doc2.store.pendingDs);
3519      }
3520      if (doc2.store.pendingStructs) {
3521        updates.push(diffUpdateV2(doc2.store.pendingStructs.update, encodedTargetStateVector));
3522      }
3523      if (updates.length > 1) {
3524        if (encoder.constructor === UpdateEncoderV1) {
3525          return mergeUpdates(updates.map((update, i) => i === 0 ? update : convertUpdateFormatV2ToV1(update)));
3526        } else if (encoder.constructor === UpdateEncoderV2) {
3527          return mergeUpdatesV2(updates);
3528        }
3529      }
3530      return updates[0];
3531    };
3532    var encodeStateAsUpdate = (doc2, encodedTargetStateVector) => encodeStateAsUpdateV2(doc2, encodedTargetStateVector, new UpdateEncoderV1());
3533    var readStateVector = (decoder) => {
3534      const ss = /* @__PURE__ */ new Map();
3535      const ssLength = readVarUint(decoder.restDecoder);
3536      for (let i = 0; i < ssLength; i++) {
3537        const client = readVarUint(decoder.restDecoder);
3538        const clock = readVarUint(decoder.restDecoder);
3539        ss.set(client, clock);
3540      }
3541      return ss;
3542    };
3543    var decodeStateVector = (decodedState) => readStateVector(new DSDecoderV1(createDecoder(decodedState)));
3544    var writeStateVector = (encoder, sv) => {
3545      writeVarUint(encoder.restEncoder, sv.size);
3546      from(sv.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
3547        writeVarUint(encoder.restEncoder, client);
3548        writeVarUint(encoder.restEncoder, clock);
3549      });
3550      return encoder;
3551    };
3552    var writeDocumentStateVector = (encoder, doc2) => writeStateVector(encoder, getStateVector(doc2.store));
3553    var encodeStateVectorV2 = (doc2, encoder = new DSEncoderV2()) => {
3554      if (doc2 instanceof Map) {
3555        writeStateVector(encoder, doc2);
3556      } else {
3557        writeDocumentStateVector(encoder, doc2);
3558      }
3559      return encoder.toUint8Array();
3560    };
3561    var encodeStateVector = (doc2) => encodeStateVectorV2(doc2, new DSEncoderV1());
3562    var EventHandler = class {
3563      constructor() {
3564        this.l = [];
3565      }
3566    };
3567    var createEventHandler = () => new EventHandler();
3568    var addEventHandlerListener = (eventHandler, f) => eventHandler.l.push(f);
3569    var removeEventHandlerListener = (eventHandler, f) => {
3570      const l = eventHandler.l;
3571      const len = l.length;
3572      eventHandler.l = l.filter((g) => f !== g);
3573      if (len === eventHandler.l.length) {
3574        console.error("[yjs] Tried to remove event handler that doesn't exist.");
3575      }
3576    };
3577    var callEventHandlerListeners = (eventHandler, arg0, arg1) => callAll(eventHandler.l, [arg0, arg1]);
3578    var ID = class {
3579      /**
3580       * @param {number} client client id
3581       * @param {number} clock unique per client id, continuous number
3582       */
3583      constructor(client, clock) {
3584        this.client = client;
3585        this.clock = clock;
3586      }
3587    };
3588    var compareIDs = (a, b) => a === b || a !== null && b !== null && a.client === b.client && a.clock === b.clock;
3589    var createID = (client, clock) => new ID(client, clock);
3590    var writeID = (encoder, id2) => {
3591      writeVarUint(encoder, id2.client);
3592      writeVarUint(encoder, id2.clock);
3593    };
3594    var readID = (decoder) => createID(readVarUint(decoder), readVarUint(decoder));
3595    var findRootTypeKey = (type) => {
3596      for (const [key, value] of type.doc.share.entries()) {
3597        if (value === type) {
3598          return key;
3599        }
3600      }
3601      throw unexpectedCase();
3602    };
3603    var isParentOf = (parent, child) => {
3604      while (child !== null) {
3605        if (child.parent === parent) {
3606          return true;
3607        }
3608        child = /** @type {AbstractType<any>} */
3609        child.parent._item;
3610      }
3611      return false;
3612    };
3613    var logType = (type) => {
3614      const res = [];
3615      let n = type._start;
3616      while (n) {
3617        res.push(n);
3618        n = n.right;
3619      }
3620      console.log("Children: ", res);
3621      console.log("Children content: ", res.filter((m) => !m.deleted).map((m) => m.content));
3622    };
3623    var PermanentUserData = class {
3624      /**
3625       * @param {Doc} doc
3626       * @param {YMap<any>} [storeType]
3627       */
3628      constructor(doc2, storeType = doc2.getMap("users")) {
3629        const dss = /* @__PURE__ */ new Map();
3630        this.yusers = storeType;
3631        this.doc = doc2;
3632        this.clients = /* @__PURE__ */ new Map();
3633        this.dss = dss;
3634        const initUser = (user, userDescription) => {
3635          const ds = user.get("ds");
3636          const ids = user.get("ids");
3637          const addClientId = (
3638            /** @param {number} clientid */
3639            (clientid) => this.clients.set(clientid, userDescription)
3640          );
3641          ds.observe(
3642            /** @param {YArrayEvent<any>} event */
3643            (event) => {
3644              event.changes.added.forEach((item) => {
3645                item.content.getContent().forEach((encodedDs) => {
3646                  if (encodedDs instanceof Uint8Array) {
3647                    this.dss.set(userDescription, mergeDeleteSets([this.dss.get(userDescription) || createDeleteSet(), readDeleteSet(new DSDecoderV1(createDecoder(encodedDs)))]));
3648                  }
3649                });
3650              });
3651            }
3652          );
3653          this.dss.set(userDescription, mergeDeleteSets(ds.map((encodedDs) => readDeleteSet(new DSDecoderV1(createDecoder(encodedDs))))));
3654          ids.observe(
3655            /** @param {YArrayEvent<any>} event */
3656            (event) => event.changes.added.forEach((item) => item.content.getContent().forEach(addClientId))
3657          );
3658          ids.forEach(addClientId);
3659        };
3660        storeType.observe((event) => {
3661          event.keysChanged.forEach(
3662            (userDescription) => initUser(storeType.get(userDescription), userDescription)
3663          );
3664        });
3665        storeType.forEach(initUser);
3666      }
3667      /**
3668       * @param {Doc} doc
3669       * @param {number} clientid
3670       * @param {string} userDescription
3671       * @param {Object} conf
3672       * @param {function(Transaction, DeleteSet):boolean} [conf.filter]
3673       */
3674      setUserMapping(doc2, clientid, userDescription, { filter = () => true } = {}) {
3675        const users = this.yusers;
3676        let user = users.get(userDescription);
3677        if (!user) {
3678          user = new YMap();
3679          user.set("ids", new YArray());
3680          user.set("ds", new YArray());
3681          users.set(userDescription, user);
3682        }
3683        user.get("ids").push([clientid]);
3684        users.observe((_event) => {
3685          setTimeout(() => {
3686            const userOverwrite = users.get(userDescription);
3687            if (userOverwrite !== user) {
3688              user = userOverwrite;
3689              this.clients.forEach((_userDescription, clientid2) => {
3690                if (userDescription === _userDescription) {
3691                  user.get("ids").push([clientid2]);
3692                }
3693              });
3694              const encoder = new DSEncoderV1();
3695              const ds = this.dss.get(userDescription);
3696              if (ds) {
3697                writeDeleteSet(encoder, ds);
3698                user.get("ds").push([encoder.toUint8Array()]);
3699              }
3700            }
3701          }, 0);
3702        });
3703        doc2.on(
3704          "afterTransaction",
3705          /** @param {Transaction} transaction */
3706          (transaction) => {
3707            setTimeout(() => {
3708              const yds = user.get("ds");
3709              const ds = transaction.deleteSet;
3710              if (transaction.local && ds.clients.size > 0 && filter(transaction, ds)) {
3711                const encoder = new DSEncoderV1();
3712                writeDeleteSet(encoder, ds);
3713                yds.push([encoder.toUint8Array()]);
3714              }
3715            });
3716          }
3717        );
3718      }
3719      /**
3720       * @param {number} clientid
3721       * @return {any}
3722       */
3723      getUserByClientId(clientid) {
3724        return this.clients.get(clientid) || null;
3725      }
3726      /**
3727       * @param {ID} id
3728       * @return {string | null}
3729       */
3730      getUserByDeletedId(id2) {
3731        for (const [userDescription, ds] of this.dss.entries()) {
3732          if (isDeleted(ds, id2)) {
3733            return userDescription;
3734          }
3735        }
3736        return null;
3737      }
3738    };
3739    var RelativePosition = class {
3740      /**
3741       * @param {ID|null} type
3742       * @param {string|null} tname
3743       * @param {ID|null} item
3744       * @param {number} assoc
3745       */
3746      constructor(type, tname, item, assoc = 0) {
3747        this.type = type;
3748        this.tname = tname;
3749        this.item = item;
3750        this.assoc = assoc;
3751      }
3752    };
3753    var relativePositionToJSON = (rpos) => {
3754      const json = {};
3755      if (rpos.type) {
3756        json.type = rpos.type;
3757      }
3758      if (rpos.tname) {
3759        json.tname = rpos.tname;
3760      }
3761      if (rpos.item) {
3762        json.item = rpos.item;
3763      }
3764      if (rpos.assoc != null) {
3765        json.assoc = rpos.assoc;
3766      }
3767      return json;
3768    };
3769    var createRelativePositionFromJSON = (json) => new RelativePosition(json.type == null ? null : createID(json.type.client, json.type.clock), json.tname ?? null, json.item == null ? null : createID(json.item.client, json.item.clock), json.assoc == null ? 0 : json.assoc);
3770    var AbsolutePosition = class {
3771      /**
3772       * @param {AbstractType<any>} type
3773       * @param {number} index
3774       * @param {number} [assoc]
3775       */
3776      constructor(type, index, assoc = 0) {
3777        this.type = type;
3778        this.index = index;
3779        this.assoc = assoc;
3780      }
3781    };
3782    var createAbsolutePosition = (type, index, assoc = 0) => new AbsolutePosition(type, index, assoc);
3783    var createRelativePosition = (type, item, assoc) => {
3784      let typeid = null;
3785      let tname = null;
3786      if (type._item === null) {
3787        tname = findRootTypeKey(type);
3788      } else {
3789        typeid = createID(type._item.id.client, type._item.id.clock);
3790      }
3791      return new RelativePosition(typeid, tname, item, assoc);
3792    };
3793    var createRelativePositionFromTypeIndex = (type, index, assoc = 0) => {
3794      let t = type._start;
3795      if (assoc < 0) {
3796        if (index === 0) {
3797          return createRelativePosition(type, null, assoc);
3798        }
3799        index--;
3800      }
3801      while (t !== null) {
3802        if (!t.deleted && t.countable) {
3803          if (t.length > index) {
3804            return createRelativePosition(type, createID(t.id.client, t.id.clock + index), assoc);
3805          }
3806          index -= t.length;
3807        }
3808        if (t.right === null && assoc < 0) {
3809          return createRelativePosition(type, t.lastId, assoc);
3810        }
3811        t = t.right;
3812      }
3813      return createRelativePosition(type, null, assoc);
3814    };
3815    var writeRelativePosition = (encoder, rpos) => {
3816      const { type, tname, item, assoc } = rpos;
3817      if (item !== null) {
3818        writeVarUint(encoder, 0);
3819        writeID(encoder, item);
3820      } else if (tname !== null) {
3821        writeUint8(encoder, 1);
3822        writeVarString(encoder, tname);
3823      } else if (type !== null) {
3824        writeUint8(encoder, 2);
3825        writeID(encoder, type);
3826      } else {
3827        throw unexpectedCase();
3828      }
3829      writeVarInt(encoder, assoc);
3830      return encoder;
3831    };
3832    var encodeRelativePosition = (rpos) => {
3833      const encoder = createEncoder();
3834      writeRelativePosition(encoder, rpos);
3835      return toUint8Array(encoder);
3836    };
3837    var readRelativePosition = (decoder) => {
3838      let type = null;
3839      let tname = null;
3840      let itemID = null;
3841      switch (readVarUint(decoder)) {
3842        case 0:
3843          itemID = readID(decoder);
3844          break;
3845        case 1:
3846          tname = readVarString(decoder);
3847          break;
3848        case 2: {
3849          type = readID(decoder);
3850        }
3851      }
3852      const assoc = hasContent(decoder) ? readVarInt(decoder) : 0;
3853      return new RelativePosition(type, tname, itemID, assoc);
3854    };
3855    var decodeRelativePosition = (uint8Array) => readRelativePosition(createDecoder(uint8Array));
3856    var getItemWithOffset = (store, id2) => {
3857      const item = getItem(store, id2);
3858      const diff = id2.clock - item.id.clock;
3859      return {
3860        item,
3861        diff
3862      };
3863    };
3864    var createAbsolutePositionFromRelativePosition = (rpos, doc2, followUndoneDeletions = true) => {
3865      const store = doc2.store;
3866      const rightID = rpos.item;
3867      const typeID = rpos.type;
3868      const tname = rpos.tname;
3869      const assoc = rpos.assoc;
3870      let type = null;
3871      let index = 0;
3872      if (rightID !== null) {
3873        if (getState(store, rightID.client) <= rightID.clock) {
3874          return null;
3875        }
3876        const res = followUndoneDeletions ? followRedone(store, rightID) : getItemWithOffset(store, rightID);
3877        const right = res.item;
3878        if (!(right instanceof Item)) {
3879          return null;
3880        }
3881        type = /** @type {AbstractType<any>} */
3882        right.parent;
3883        if (type._item === null || !type._item.deleted) {
3884          index = right.deleted || !right.countable ? 0 : res.diff + (assoc >= 0 ? 0 : 1);
3885          let n = right.left;
3886          while (n !== null) {
3887            if (!n.deleted && n.countable) {
3888              index += n.length;
3889            }
3890            n = n.left;
3891          }
3892        }
3893      } else {
3894        if (tname !== null) {
3895          type = doc2.get(tname);
3896        } else if (typeID !== null) {
3897          if (getState(store, typeID.client) <= typeID.clock) {
3898            return null;
3899          }
3900          const { item } = followUndoneDeletions ? followRedone(store, typeID) : { item: getItem(store, typeID) };
3901          if (item instanceof Item && item.content instanceof ContentType) {
3902            type = item.content.type;
3903          } else {
3904            return null;
3905          }
3906        } else {
3907          throw unexpectedCase();
3908        }
3909        if (assoc >= 0) {
3910          index = type._length;
3911        } else {
3912          index = 0;
3913        }
3914      }
3915      return createAbsolutePosition(type, index, rpos.assoc);
3916    };
3917    var compareRelativePositions = (a, b) => a === b || a !== null && b !== null && a.tname === b.tname && compareIDs(a.item, b.item) && compareIDs(a.type, b.type) && a.assoc === b.assoc;
3918    var Snapshot = class {
3919      /**
3920       * @param {DeleteSet} ds
3921       * @param {Map<number,number>} sv state map
3922       */
3923      constructor(ds, sv) {
3924        this.ds = ds;
3925        this.sv = sv;
3926      }
3927    };
3928    var equalSnapshots = (snap1, snap2) => {
3929      const ds1 = snap1.ds.clients;
3930      const ds2 = snap2.ds.clients;
3931      const sv1 = snap1.sv;
3932      const sv2 = snap2.sv;
3933      if (sv1.size !== sv2.size || ds1.size !== ds2.size) {
3934        return false;
3935      }
3936      for (const [key, value] of sv1.entries()) {
3937        if (sv2.get(key) !== value) {
3938          return false;
3939        }
3940      }
3941      for (const [client, dsitems1] of ds1.entries()) {
3942        const dsitems2 = ds2.get(client) || [];
3943        if (dsitems1.length !== dsitems2.length) {
3944          return false;
3945        }
3946        for (let i = 0; i < dsitems1.length; i++) {
3947          const dsitem1 = dsitems1[i];
3948          const dsitem2 = dsitems2[i];
3949          if (dsitem1.clock !== dsitem2.clock || dsitem1.len !== dsitem2.len) {
3950            return false;
3951          }
3952        }
3953      }
3954      return true;
3955    };
3956    var encodeSnapshotV2 = (snapshot2, encoder = new DSEncoderV2()) => {
3957      writeDeleteSet(encoder, snapshot2.ds);
3958      writeStateVector(encoder, snapshot2.sv);
3959      return encoder.toUint8Array();
3960    };
3961    var encodeSnapshot = (snapshot2) => encodeSnapshotV2(snapshot2, new DSEncoderV1());
3962    var decodeSnapshotV2 = (buf, decoder = new DSDecoderV2(createDecoder(buf))) => {
3963      return new Snapshot(readDeleteSet(decoder), readStateVector(decoder));
3964    };
3965    var decodeSnapshot = (buf) => decodeSnapshotV2(buf, new DSDecoderV1(createDecoder(buf)));
3966    var createSnapshot = (ds, sm) => new Snapshot(ds, sm);
3967    var emptySnapshot = createSnapshot(createDeleteSet(), /* @__PURE__ */ new Map());
3968    var snapshot = (doc2) => createSnapshot(createDeleteSetFromStructStore(doc2.store), getStateVector(doc2.store));
3969    var isVisible = (item, snapshot2) => snapshot2 === void 0 ? !item.deleted : snapshot2.sv.has(item.id.client) && (snapshot2.sv.get(item.id.client) || 0) > item.id.clock && !isDeleted(snapshot2.ds, item.id);
3970    var splitSnapshotAffectedStructs = (transaction, snapshot2) => {
3971      const meta = setIfUndefined(transaction.meta, splitSnapshotAffectedStructs, create2);
3972      const store = transaction.doc.store;
3973      if (!meta.has(snapshot2)) {
3974        snapshot2.sv.forEach((clock, client) => {
3975          if (clock < getState(store, client)) {
3976            getItemCleanStart(transaction, createID(client, clock));
3977          }
3978        });
3979        iterateDeletedStructs(transaction, snapshot2.ds, (_item) => {
3980        });
3981        meta.add(snapshot2);
3982      }
3983    };
3984    var createDocFromSnapshot = (originDoc, snapshot2, newDoc = new Doc()) => {
3985      if (originDoc.gc) {
3986        throw new Error("Garbage-collection must be disabled in `originDoc`!");
3987      }
3988      const { sv, ds } = snapshot2;
3989      const encoder = new UpdateEncoderV2();
3990      originDoc.transact((transaction) => {
3991        let size2 = 0;
3992        sv.forEach((clock) => {
3993          if (clock > 0) {
3994            size2++;
3995          }
3996        });
3997        writeVarUint(encoder.restEncoder, size2);
3998        for (const [client, clock] of sv) {
3999          if (clock === 0) {
4000            continue;
4001          }
4002          if (clock < getState(originDoc.store, client)) {
4003            getItemCleanStart(transaction, createID(client, clock));
4004          }
4005          const structs = originDoc.store.clients.get(client) || [];
4006          const lastStructIndex = findIndexSS(structs, clock - 1);
4007          writeVarUint(encoder.restEncoder, lastStructIndex + 1);
4008          encoder.writeClient(client);
4009          writeVarUint(encoder.restEncoder, 0);
4010          for (let i = 0; i <= lastStructIndex; i++) {
4011            structs[i].write(encoder, 0);
4012          }
4013        }
4014        writeDeleteSet(encoder, ds);
4015      });
4016      applyUpdateV2(newDoc, encoder.toUint8Array(), "snapshot");
4017      return newDoc;
4018    };
4019    var snapshotContainsUpdateV2 = (snapshot2, update, YDecoder = UpdateDecoderV2) => {
4020      const updateDecoder = new YDecoder(createDecoder(update));
4021      const lazyDecoder = new LazyStructReader(updateDecoder, false);
4022      for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4023        if ((snapshot2.sv.get(curr.id.client) || 0) < curr.id.clock + curr.length) {
4024          return false;
4025        }
4026      }
4027      const mergedDS = mergeDeleteSets([snapshot2.ds, readDeleteSet(updateDecoder)]);
4028      return equalDeleteSets(snapshot2.ds, mergedDS);
4029    };
4030    var snapshotContainsUpdate = (snapshot2, update) => snapshotContainsUpdateV2(snapshot2, update, UpdateDecoderV1);
4031    var StructStore = class {
4032      constructor() {
4033        this.clients = /* @__PURE__ */ new Map();
4034        this.pendingStructs = null;
4035        this.pendingDs = null;
4036      }
4037    };
4038    var getStateVector = (store) => {
4039      const sm = /* @__PURE__ */ new Map();
4040      store.clients.forEach((structs, client) => {
4041        const struct = structs[structs.length - 1];
4042        sm.set(client, struct.id.clock + struct.length);
4043      });
4044      return sm;
4045    };
4046    var getState = (store, client) => {
4047      const structs = store.clients.get(client);
4048      if (structs === void 0) {
4049        return 0;
4050      }
4051      const lastStruct = structs[structs.length - 1];
4052      return lastStruct.id.clock + lastStruct.length;
4053    };
4054    var addStruct = (store, struct) => {
4055      let structs = store.clients.get(struct.id.client);
4056      if (structs === void 0) {
4057        structs = [];
4058        store.clients.set(struct.id.client, structs);
4059      } else {
4060        const lastStruct = structs[structs.length - 1];
4061        if (lastStruct.id.clock + lastStruct.length !== struct.id.clock) {
4062          throw unexpectedCase();
4063        }
4064      }
4065      structs.push(struct);
4066    };
4067    var findIndexSS = (structs, clock) => {
4068      let left = 0;
4069      let right = structs.length - 1;
4070      let mid = structs[right];
4071      let midclock = mid.id.clock;
4072      if (midclock === clock) {
4073        return right;
4074      }
4075      let midindex = floor(clock / (midclock + mid.length - 1) * right);
4076      while (left <= right) {
4077        mid = structs[midindex];
4078        midclock = mid.id.clock;
4079        if (midclock <= clock) {
4080          if (clock < midclock + mid.length) {
4081            return midindex;
4082          }
4083          left = midindex + 1;
4084        } else {
4085          right = midindex - 1;
4086        }
4087        midindex = floor((left + right) / 2);
4088      }
4089      throw unexpectedCase();
4090    };
4091    var find = (store, id2) => {
4092      const structs = store.clients.get(id2.client);
4093      return structs[findIndexSS(structs, id2.clock)];
4094    };
4095    var getItem = (
4096      /** @type {function(StructStore,ID):Item} */
4097      find
4098    );
4099    var findIndexCleanStart = (transaction, structs, clock) => {
4100      const index = findIndexSS(structs, clock);
4101      const struct = structs[index];
4102      if (struct.id.clock < clock && struct instanceof Item) {
4103        structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));
4104        return index + 1;
4105      }
4106      return index;
4107    };
4108    var getItemCleanStart = (transaction, id2) => {
4109      const structs = (
4110        /** @type {Array<Item>} */
4111        transaction.doc.store.clients.get(id2.client)
4112      );
4113      return structs[findIndexCleanStart(transaction, structs, id2.clock)];
4114    };
4115    var getItemCleanEnd = (transaction, store, id2) => {
4116      const structs = store.clients.get(id2.client);
4117      const index = findIndexSS(structs, id2.clock);
4118      const struct = structs[index];
4119      if (id2.clock !== struct.id.clock + struct.length - 1 && struct.constructor !== GC) {
4120        structs.splice(index + 1, 0, splitItem(transaction, struct, id2.clock - struct.id.clock + 1));
4121      }
4122      return struct;
4123    };
4124    var replaceStruct = (store, struct, newStruct) => {
4125      const structs = (
4126        /** @type {Array<GC|Item>} */
4127        store.clients.get(struct.id.client)
4128      );
4129      structs[findIndexSS(structs, struct.id.clock)] = newStruct;
4130    };
4131    var iterateStructs = (transaction, structs, clockStart, len, f) => {
4132      if (len === 0) {
4133        return;
4134      }
4135      const clockEnd = clockStart + len;
4136      let index = findIndexCleanStart(transaction, structs, clockStart);
4137      let struct;
4138      do {
4139        struct = structs[index++];
4140        if (clockEnd < struct.id.clock + struct.length) {
4141          findIndexCleanStart(transaction, structs, clockEnd);
4142        }
4143        f(struct);
4144      } while (index < structs.length && structs[index].id.clock < clockEnd);
4145    };
4146    var Transaction = class {
4147      /**
4148       * @param {Doc} doc
4149       * @param {any} origin
4150       * @param {boolean} local
4151       */
4152      constructor(doc2, origin2, local) {
4153        this.doc = doc2;
4154        this.deleteSet = new DeleteSet();
4155        this.beforeState = getStateVector(doc2.store);
4156        this.afterState = /* @__PURE__ */ new Map();
4157        this.changed = /* @__PURE__ */ new Map();
4158        this.changedParentTypes = /* @__PURE__ */ new Map();
4159        this._mergeStructs = [];
4160        this.origin = origin2;
4161        this.meta = /* @__PURE__ */ new Map();
4162        this.local = local;
4163        this.subdocsAdded = /* @__PURE__ */ new Set();
4164        this.subdocsRemoved = /* @__PURE__ */ new Set();
4165        this.subdocsLoaded = /* @__PURE__ */ new Set();
4166        this._needFormattingCleanup = false;
4167      }
4168    };
4169    var writeUpdateMessageFromTransaction = (encoder, transaction) => {
4170      if (transaction.deleteSet.clients.size === 0 && !any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {
4171        return false;
4172      }
4173      sortAndMergeDeleteSet(transaction.deleteSet);
4174      writeStructsFromTransaction(encoder, transaction);
4175      writeDeleteSet(encoder, transaction.deleteSet);
4176      return true;
4177    };
4178    var addChangedTypeToTransaction = (transaction, type, parentSub) => {
4179      const item = type._item;
4180      if (item === null || item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted) {
4181        setIfUndefined(transaction.changed, type, create2).add(parentSub);
4182      }
4183    };
4184    var tryToMergeWithLefts = (structs, pos) => {
4185      let right = structs[pos];
4186      let left = structs[pos - 1];
4187      let i = pos;
4188      for (; i > 0; right = left, left = structs[--i - 1]) {
4189        if (left.deleted === right.deleted && left.constructor === right.constructor) {
4190          if (left.mergeWith(right)) {
4191            if (right instanceof Item && right.parentSub !== null && /** @type {AbstractType<any>} */
4192            right.parent._map.get(right.parentSub) === right) {
4193              right.parent._map.set(
4194                right.parentSub,
4195                /** @type {Item} */
4196                left
4197              );
4198            }
4199            continue;
4200          }
4201        }
4202        break;
4203      }
4204      const merged = pos - i;
4205      if (merged) {
4206        structs.splice(pos + 1 - merged, merged);
4207      }
4208      return merged;
4209    };
4210    var tryGcDeleteSet = (ds, store, gcFilter) => {
4211      for (const [client, deleteItems] of ds.clients.entries()) {
4212        const structs = (
4213          /** @type {Array<GC|Item>} */
4214          store.clients.get(client)
4215        );
4216        for (let di = deleteItems.length - 1; di >= 0; di--) {
4217          const deleteItem = deleteItems[di];
4218          const endDeleteItemClock = deleteItem.clock + deleteItem.len;
4219          for (let si = findIndexSS(structs, deleteItem.clock), struct = structs[si]; si < structs.length && struct.id.clock < endDeleteItemClock; struct = structs[++si]) {
4220            const struct2 = structs[si];
4221            if (deleteItem.clock + deleteItem.len <= struct2.id.clock) {
4222              break;
4223            }
4224            if (struct2 instanceof Item && struct2.deleted && !struct2.keep && gcFilter(struct2)) {
4225              struct2.gc(store, false);
4226            }
4227          }
4228        }
4229      }
4230    };
4231    var tryMergeDeleteSet = (ds, store) => {
4232      ds.clients.forEach((deleteItems, client) => {
4233        const structs = (
4234          /** @type {Array<GC|Item>} */
4235          store.clients.get(client)
4236        );
4237        for (let di = deleteItems.length - 1; di >= 0; di--) {
4238          const deleteItem = deleteItems[di];
4239          const mostRightIndexToCheck = min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));
4240          for (let si = mostRightIndexToCheck, struct = structs[si]; si > 0 && struct.id.clock >= deleteItem.clock; struct = structs[si]) {
4241            si -= 1 + tryToMergeWithLefts(structs, si);
4242          }
4243        }
4244      });
4245    };
4246    var tryGc = (ds, store, gcFilter) => {
4247      tryGcDeleteSet(ds, store, gcFilter);
4248      tryMergeDeleteSet(ds, store);
4249    };
4250    var cleanupTransactions = (transactionCleanups, i) => {
4251      if (i < transactionCleanups.length) {
4252        const transaction = transactionCleanups[i];
4253        const doc2 = transaction.doc;
4254        const store = doc2.store;
4255        const ds = transaction.deleteSet;
4256        const mergeStructs = transaction._mergeStructs;
4257        try {
4258          sortAndMergeDeleteSet(ds);
4259          transaction.afterState = getStateVector(transaction.doc.store);
4260          doc2.emit("beforeObserverCalls", [transaction, doc2]);
4261          const fs = [];
4262          transaction.changed.forEach(
4263            (subs, itemtype) => fs.push(() => {
4264              if (itemtype._item === null || !itemtype._item.deleted) {
4265                itemtype._callObserver(transaction, subs);
4266              }
4267            })
4268          );
4269          fs.push(() => {
4270            transaction.changedParentTypes.forEach((events, type) => {
4271              if (type._dEH.l.length > 0 && (type._item === null || !type._item.deleted)) {
4272                events = events.filter(
4273                  (event) => event.target._item === null || !event.target._item.deleted
4274                );
4275                events.forEach((event) => {
4276                  event.currentTarget = type;
4277                  event._path = null;
4278                });
4279                events.sort((event1, event2) => event1.path.length - event2.path.length);
4280                fs.push(() => {
4281                  callEventHandlerListeners(type._dEH, events, transaction);
4282                });
4283              }
4284            });
4285            fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
4286            fs.push(() => {
4287              if (transaction._needFormattingCleanup) {
4288                cleanupYTextAfterTransaction(transaction);
4289              }
4290            });
4291          });
4292          callAll(fs, []);
4293        } finally {
4294          if (doc2.gc) {
4295            tryGcDeleteSet(ds, store, doc2.gcFilter);
4296          }
4297          tryMergeDeleteSet(ds, store);
4298          transaction.afterState.forEach((clock, client) => {
4299            const beforeClock = transaction.beforeState.get(client) || 0;
4300            if (beforeClock !== clock) {
4301              const structs = (
4302                /** @type {Array<GC|Item>} */
4303                store.clients.get(client)
4304              );
4305              const firstChangePos = max(findIndexSS(structs, beforeClock), 1);
4306              for (let i2 = structs.length - 1; i2 >= firstChangePos; ) {
4307                i2 -= 1 + tryToMergeWithLefts(structs, i2);
4308              }
4309            }
4310          });
4311          for (let i2 = mergeStructs.length - 1; i2 >= 0; i2--) {
4312            const { client, clock } = mergeStructs[i2].id;
4313            const structs = (
4314              /** @type {Array<GC|Item>} */
4315              store.clients.get(client)
4316            );
4317            const replacedStructPos = findIndexSS(structs, clock);
4318            if (replacedStructPos + 1 < structs.length) {
4319              if (tryToMergeWithLefts(structs, replacedStructPos + 1) > 1) {
4320                continue;
4321              }
4322            }
4323            if (replacedStructPos > 0) {
4324              tryToMergeWithLefts(structs, replacedStructPos);
4325            }
4326          }
4327          if (!transaction.local && transaction.afterState.get(doc2.clientID) !== transaction.beforeState.get(doc2.clientID)) {
4328            print(ORANGE, BOLD, "[yjs] ", UNBOLD, RED, "Changed the client-id because another client seems to be using it.");
4329            doc2.clientID = generateNewClientId();
4330          }
4331          doc2.emit("afterTransactionCleanup", [transaction, doc2]);
4332          if (doc2._observers.has("update")) {
4333            const encoder = new UpdateEncoderV1();
4334            const hasContent2 = writeUpdateMessageFromTransaction(encoder, transaction);
4335            if (hasContent2) {
4336              doc2.emit("update", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
4337            }
4338          }
4339          if (doc2._observers.has("updateV2")) {
4340            const encoder = new UpdateEncoderV2();
4341            const hasContent2 = writeUpdateMessageFromTransaction(encoder, transaction);
4342            if (hasContent2) {
4343              doc2.emit("updateV2", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
4344            }
4345          }
4346          const { subdocsAdded, subdocsLoaded, subdocsRemoved } = transaction;
4347          if (subdocsAdded.size > 0 || subdocsRemoved.size > 0 || subdocsLoaded.size > 0) {
4348            subdocsAdded.forEach((subdoc) => {
4349              subdoc.clientID = doc2.clientID;
4350              if (subdoc.collectionid == null) {
4351                subdoc.collectionid = doc2.collectionid;
4352              }
4353              doc2.subdocs.add(subdoc);
4354            });
4355            subdocsRemoved.forEach((subdoc) => doc2.subdocs.delete(subdoc));
4356            doc2.emit("subdocs", [{ loaded: subdocsLoaded, added: subdocsAdded, removed: subdocsRemoved }, doc2, transaction]);
4357            subdocsRemoved.forEach((subdoc) => subdoc.destroy());
4358          }
4359          if (transactionCleanups.length <= i + 1) {
4360            doc2._transactionCleanups = [];
4361            doc2.emit("afterAllTransactions", [doc2, transactionCleanups]);
4362          } else {
4363            cleanupTransactions(transactionCleanups, i + 1);
4364          }
4365        }
4366      }
4367    };
4368    var transact = (doc2, f, origin2 = null, local = true) => {
4369      const transactionCleanups = doc2._transactionCleanups;
4370      let initialCall = false;
4371      let result = null;
4372      if (doc2._transaction === null) {
4373        initialCall = true;
4374        doc2._transaction = new Transaction(doc2, origin2, local);
4375        transactionCleanups.push(doc2._transaction);
4376        if (transactionCleanups.length === 1) {
4377          doc2.emit("beforeAllTransactions", [doc2]);
4378        }
4379        doc2.emit("beforeTransaction", [doc2._transaction, doc2]);
4380      }
4381      try {
4382        result = f(doc2._transaction);
4383      } finally {
4384        if (initialCall) {
4385          const finishCleanup = doc2._transaction === transactionCleanups[0];
4386          doc2._transaction = null;
4387          if (finishCleanup) {
4388            cleanupTransactions(transactionCleanups, 0);
4389          }
4390        }
4391      }
4392      return result;
4393    };
4394    var StackItem = class {
4395      /**
4396       * @param {DeleteSet} deletions
4397       * @param {DeleteSet} insertions
4398       */
4399      constructor(deletions, insertions) {
4400        this.insertions = insertions;
4401        this.deletions = deletions;
4402        this.meta = /* @__PURE__ */ new Map();
4403      }
4404    };
4405    var clearUndoManagerStackItem = (tr, um, stackItem) => {
4406      iterateDeletedStructs(tr, stackItem.deletions, (item) => {
4407        if (item instanceof Item && um.scope.some((type) => type === tr.doc || isParentOf(
4408          /** @type {AbstractType<any>} */
4409          type,
4410          item
4411        ))) {
4412          keepItem(item, false);
4413        }
4414      });
4415    };
4416    var popStackItem = (undoManager, stack, eventType) => {
4417      let _tr = null;
4418      const doc2 = undoManager.doc;
4419      const scope = undoManager.scope;
4420      transact(doc2, (transaction) => {
4421        while (stack.length > 0 && undoManager.currStackItem === null) {
4422          const store = doc2.store;
4423          const stackItem = (
4424            /** @type {StackItem} */
4425            stack.pop()
4426          );
4427          const itemsToRedo = /* @__PURE__ */ new Set();
4428          const itemsToDelete = [];
4429          let performedChange = false;
4430          iterateDeletedStructs(transaction, stackItem.insertions, (struct) => {
4431            if (struct instanceof Item) {
4432              if (struct.redone !== null) {
4433                let { item, diff } = followRedone(store, struct.id);
4434                if (diff > 0) {
4435                  item = getItemCleanStart(transaction, createID(item.id.client, item.id.clock + diff));
4436                }
4437                struct = item;
4438              }
4439              if (!struct.deleted && scope.some((type) => type === transaction.doc || isParentOf(
4440                /** @type {AbstractType<any>} */
4441                type,
4442                /** @type {Item} */
4443                struct
4444              ))) {
4445                itemsToDelete.push(struct);
4446              }
4447            }
4448          });
4449          iterateDeletedStructs(transaction, stackItem.deletions, (struct) => {
4450            if (struct instanceof Item && scope.some((type) => type === transaction.doc || isParentOf(
4451              /** @type {AbstractType<any>} */
4452              type,
4453              struct
4454            )) && // Never redo structs in stackItem.insertions because they were created and deleted in the same capture interval.
4455            !isDeleted(stackItem.insertions, struct.id)) {
4456              itemsToRedo.add(struct);
4457            }
4458          });
4459          itemsToRedo.forEach((struct) => {
4460            performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.insertions, undoManager.ignoreRemoteMapChanges, undoManager) !== null || performedChange;
4461          });
4462          for (let i = itemsToDelete.length - 1; i >= 0; i--) {
4463            const item = itemsToDelete[i];
4464            if (undoManager.deleteFilter(item)) {
4465              item.delete(transaction);
4466              performedChange = true;
4467            }
4468          }
4469          undoManager.currStackItem = performedChange ? stackItem : null;
4470        }
4471        transaction.changed.forEach((subProps, type) => {
4472          if (subProps.has(null) && type._searchMarker) {
4473            type._searchMarker.length = 0;
4474          }
4475        });
4476        _tr = transaction;
4477      }, undoManager);
4478      const res = undoManager.currStackItem;
4479      if (res != null) {
4480        const changedParentTypes = _tr.changedParentTypes;
4481        undoManager.emit("stack-item-popped", [{ stackItem: res, type: eventType, changedParentTypes, origin: undoManager }, undoManager]);
4482        undoManager.currStackItem = null;
4483      }
4484      return res;
4485    };
4486    var UndoManager = class extends ObservableV2 {
4487      /**
4488       * @param {Doc|AbstractType<any>|Array<AbstractType<any>>} typeScope Limits the scope of the UndoManager. If this is set to a ydoc instance, all changes on that ydoc will be undone. If set to a specific type, only changes on that type or its children will be undone. Also accepts an array of types.
4489       * @param {UndoManagerOptions} options
4490       */
4491      constructor(typeScope, {
4492        captureTimeout = 500,
4493        captureTransaction = (_tr) => true,
4494        deleteFilter = () => true,
4495        trackedOrigins = /* @__PURE__ */ new Set([null]),
4496        ignoreRemoteMapChanges = false,
4497        doc: doc2 = (
4498          /** @type {Doc} */
4499          isArray(typeScope) ? typeScope[0].doc : typeScope instanceof Doc ? typeScope : typeScope.doc
4500        )
4501      } = {}) {
4502        super();
4503        this.scope = [];
4504        this.doc = doc2;
4505        this.addToScope(typeScope);
4506        this.deleteFilter = deleteFilter;
4507        trackedOrigins.add(this);
4508        this.trackedOrigins = trackedOrigins;
4509        this.captureTransaction = captureTransaction;
4510        this.undoStack = [];
4511        this.redoStack = [];
4512        this.undoing = false;
4513        this.redoing = false;
4514        this.currStackItem = null;
4515        this.lastChange = 0;
4516        this.ignoreRemoteMapChanges = ignoreRemoteMapChanges;
4517        this.captureTimeout = captureTimeout;
4518        this.afterTransactionHandler = (transaction) => {
4519          if (!this.captureTransaction(transaction) || !this.scope.some((type) => transaction.changedParentTypes.has(
4520            /** @type {AbstractType<any>} */
4521            type
4522          ) || type === this.doc) || !this.trackedOrigins.has(transaction.origin) && (!transaction.origin || !this.trackedOrigins.has(transaction.origin.constructor))) {
4523            return;
4524          }
4525          const undoing = this.undoing;
4526          const redoing = this.redoing;
4527          const stack = undoing ? this.redoStack : this.undoStack;
4528          if (undoing) {
4529            this.stopCapturing();
4530          } else if (!redoing) {
4531            this.clear(false, true);
4532          }
4533          const insertions = new DeleteSet();
4534          transaction.afterState.forEach((endClock, client) => {
4535            const startClock = transaction.beforeState.get(client) || 0;
4536            const len = endClock - startClock;
4537            if (len > 0) {
4538              addToDeleteSet(insertions, client, startClock, len);
4539            }
4540          });
4541          const now = getUnixTime();
4542          let didAdd = false;
4543          if (this.lastChange > 0 && now - this.lastChange < this.captureTimeout && stack.length > 0 && !undoing && !redoing) {
4544            const lastOp = stack[stack.length - 1];
4545            lastOp.deletions = mergeDeleteSets([lastOp.deletions, transaction.deleteSet]);
4546            lastOp.insertions = mergeDeleteSets([lastOp.insertions, insertions]);
4547          } else {
4548            stack.push(new StackItem(transaction.deleteSet, insertions));
4549            didAdd = true;
4550          }
4551          if (!undoing && !redoing) {
4552            this.lastChange = now;
4553          }
4554          iterateDeletedStructs(
4555            transaction,
4556            transaction.deleteSet,
4557            /** @param {Item|GC} item */
4558            (item) => {
4559              if (item instanceof Item && this.scope.some((type) => type === transaction.doc || isParentOf(
4560                /** @type {AbstractType<any>} */
4561                type,
4562                item
4563              ))) {
4564                keepItem(item, true);
4565              }
4566            }
4567          );
4568          const changeEvent = [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? "redo" : "undo", changedParentTypes: transaction.changedParentTypes }, this];
4569          if (didAdd) {
4570            this.emit("stack-item-added", changeEvent);
4571          } else {
4572            this.emit("stack-item-updated", changeEvent);
4573          }
4574        };
4575        this.doc.on("afterTransaction", this.afterTransactionHandler);
4576        this.doc.on("destroy", () => {
4577          this.destroy();
4578        });
4579      }
4580      /**
4581       * Extend the scope.
4582       *
4583       * @param {Array<AbstractType<any> | Doc> | AbstractType<any> | Doc} ytypes
4584       */
4585      addToScope(ytypes) {
4586        const tmpSet = new Set(this.scope);
4587        ytypes = isArray(ytypes) ? ytypes : [ytypes];
4588        ytypes.forEach((ytype) => {
4589          if (!tmpSet.has(ytype)) {
4590            tmpSet.add(ytype);
4591            if (ytype instanceof AbstractType ? ytype.doc !== this.doc : ytype !== this.doc) warn("[yjs#509] Not same Y.Doc");
4592            this.scope.push(ytype);
4593          }
4594        });
4595      }
4596      /**
4597       * @param {any} origin
4598       */
4599      addTrackedOrigin(origin2) {
4600        this.trackedOrigins.add(origin2);
4601      }
4602      /**
4603       * @param {any} origin
4604       */
4605      removeTrackedOrigin(origin2) {
4606        this.trackedOrigins.delete(origin2);
4607      }
4608      clear(clearUndoStack = true, clearRedoStack = true) {
4609        if (clearUndoStack && this.canUndo() || clearRedoStack && this.canRedo()) {
4610          this.doc.transact((tr) => {
4611            if (clearUndoStack) {
4612              this.undoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
4613              this.undoStack = [];
4614            }
4615            if (clearRedoStack) {
4616              this.redoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
4617              this.redoStack = [];
4618            }
4619            this.emit("stack-cleared", [{ undoStackCleared: clearUndoStack, redoStackCleared: clearRedoStack }]);
4620          });
4621        }
4622      }
4623      /**
4624       * UndoManager merges Undo-StackItem if they are created within time-gap
4625       * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
4626       * StackItem won't be merged.
4627       *
4628       *
4629       * @example
4630       *     // without stopCapturing
4631       *     ytext.insert(0, 'a')
4632       *     ytext.insert(1, 'b')
4633       *     um.undo()
4634       *     ytext.toString() // => '' (note that 'ab' was removed)
4635       *     // with stopCapturing
4636       *     ytext.insert(0, 'a')
4637       *     um.stopCapturing()
4638       *     ytext.insert(0, 'b')
4639       *     um.undo()
4640       *     ytext.toString() // => 'a' (note that only 'b' was removed)
4641       *
4642       */
4643      stopCapturing() {
4644        this.lastChange = 0;
4645      }
4646      /**
4647       * Undo last changes on type.
4648       *
4649       * @return {StackItem?} Returns StackItem if a change was applied
4650       */
4651      undo() {
4652        this.undoing = true;
4653        let res;
4654        try {
4655          res = popStackItem(this, this.undoStack, "undo");
4656        } finally {
4657          this.undoing = false;
4658        }
4659        return res;
4660      }
4661      /**
4662       * Redo last undo operation.
4663       *
4664       * @return {StackItem?} Returns StackItem if a change was applied
4665       */
4666      redo() {
4667        this.redoing = true;
4668        let res;
4669        try {
4670          res = popStackItem(this, this.redoStack, "redo");
4671        } finally {
4672          this.redoing = false;
4673        }
4674        return res;
4675      }
4676      /**
4677       * Are undo steps available?
4678       *
4679       * @return {boolean} `true` if undo is possible
4680       */
4681      canUndo() {
4682        return this.undoStack.length > 0;
4683      }
4684      /**
4685       * Are redo steps available?
4686       *
4687       * @return {boolean} `true` if redo is possible
4688       */
4689      canRedo() {
4690        return this.redoStack.length > 0;
4691      }
4692      destroy() {
4693        this.trackedOrigins.delete(this);
4694        this.doc.off("afterTransaction", this.afterTransactionHandler);
4695        super.destroy();
4696      }
4697    };
4698    function* lazyStructReaderGenerator(decoder) {
4699      const numOfStateUpdates = readVarUint(decoder.restDecoder);
4700      for (let i = 0; i < numOfStateUpdates; i++) {
4701        const numberOfStructs = readVarUint(decoder.restDecoder);
4702        const client = decoder.readClient();
4703        let clock = readVarUint(decoder.restDecoder);
4704        for (let i2 = 0; i2 < numberOfStructs; i2++) {
4705          const info = decoder.readInfo();
4706          if (info === 10) {
4707            const len = readVarUint(decoder.restDecoder);
4708            yield new Skip(createID(client, clock), len);
4709            clock += len;
4710          } else if ((BITS5 & info) !== 0) {
4711            const cantCopyParentInfo = (info & (BIT7 | BIT8)) === 0;
4712            const struct = new Item(
4713              createID(client, clock),
4714              null,
4715              // left
4716              (info & BIT8) === BIT8 ? decoder.readLeftID() : null,
4717              // origin
4718              null,
4719              // right
4720              (info & BIT7) === BIT7 ? decoder.readRightID() : null,
4721              // right origin
4722              // @ts-ignore Force writing a string here.
4723              cantCopyParentInfo ? decoder.readParentInfo() ? decoder.readString() : decoder.readLeftID() : null,
4724              // parent
4725              cantCopyParentInfo && (info & BIT6) === BIT6 ? decoder.readString() : null,
4726              // parentSub
4727              readItemContent(decoder, info)
4728              // item content
4729            );
4730            yield struct;
4731            clock += struct.length;
4732          } else {
4733            const len = decoder.readLen();
4734            yield new GC(createID(client, clock), len);
4735            clock += len;
4736          }
4737        }
4738      }
4739    }
4740    var LazyStructReader = class {
4741      /**
4742       * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
4743       * @param {boolean} filterSkips
4744       */
4745      constructor(decoder, filterSkips) {
4746        this.gen = lazyStructReaderGenerator(decoder);
4747        this.curr = null;
4748        this.done = false;
4749        this.filterSkips = filterSkips;
4750        this.next();
4751      }
4752      /**
4753       * @return {Item | GC | Skip |null}
4754       */
4755      next() {
4756        do {
4757          this.curr = this.gen.next().value || null;
4758        } while (this.filterSkips && this.curr !== null && this.curr.constructor === Skip);
4759        return this.curr;
4760      }
4761    };
4762    var logUpdate = (update) => logUpdateV2(update, UpdateDecoderV1);
4763    var logUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
4764      const structs = [];
4765      const updateDecoder = new YDecoder(createDecoder(update));
4766      const lazyDecoder = new LazyStructReader(updateDecoder, false);
4767      for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4768        structs.push(curr);
4769      }
4770      print("Structs: ", structs);
4771      const ds = readDeleteSet(updateDecoder);
4772      print("DeleteSet: ", ds);
4773    };
4774    var decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1);
4775    var decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
4776      const structs = [];
4777      const updateDecoder = new YDecoder(createDecoder(update));
4778      const lazyDecoder = new LazyStructReader(updateDecoder, false);
4779      for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
4780        structs.push(curr);
4781      }
4782      return {
4783        structs,
4784        ds: readDeleteSet(updateDecoder)
4785      };
4786    };
4787    var LazyStructWriter = class {
4788      /**
4789       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
4790       */
4791      constructor(encoder) {
4792        this.currClient = 0;
4793        this.startClock = 0;
4794        this.written = 0;
4795        this.encoder = encoder;
4796        this.clientStructs = [];
4797      }
4798    };
4799    var mergeUpdates = (updates) => mergeUpdatesV2(updates, UpdateDecoderV1, UpdateEncoderV1);
4800    var encodeStateVectorFromUpdateV2 = (update, YEncoder = DSEncoderV2, YDecoder = UpdateDecoderV2) => {
4801      const encoder = new YEncoder();
4802      const updateDecoder = new LazyStructReader(new YDecoder(createDecoder(update)), false);
4803      let curr = updateDecoder.curr;
4804      if (curr !== null) {
4805        let size2 = 0;
4806        let currClient = curr.id.client;
4807        let stopCounting = curr.id.clock !== 0;
4808        let currClock = stopCounting ? 0 : curr.id.clock + curr.length;
4809        for (; curr !== null; curr = updateDecoder.next()) {
4810          if (currClient !== curr.id.client) {
4811            if (currClock !== 0) {
4812              size2++;
4813              writeVarUint(encoder.restEncoder, currClient);
4814              writeVarUint(encoder.restEncoder, currClock);
4815            }
4816            currClient = curr.id.client;
4817            currClock = 0;
4818            stopCounting = curr.id.clock !== 0;
4819          }
4820          if (curr.constructor === Skip) {
4821            stopCounting = true;
4822          }
4823          if (!stopCounting) {
4824            currClock = curr.id.clock + curr.length;
4825          }
4826        }
4827        if (currClock !== 0) {
4828          size2++;
4829          writeVarUint(encoder.restEncoder, currClient);
4830          writeVarUint(encoder.restEncoder, currClock);
4831        }
4832        const enc = createEncoder();
4833        writeVarUint(enc, size2);
4834        writeBinaryEncoder(enc, encoder.restEncoder);
4835        encoder.restEncoder = enc;
4836        return encoder.toUint8Array();
4837      } else {
4838        writeVarUint(encoder.restEncoder, 0);
4839        return encoder.toUint8Array();
4840      }
4841    };
4842    var encodeStateVectorFromUpdate = (update) => encodeStateVectorFromUpdateV2(update, DSEncoderV1, UpdateDecoderV1);
4843    var parseUpdateMetaV2 = (update, YDecoder = UpdateDecoderV2) => {
4844      const from2 = /* @__PURE__ */ new Map();
4845      const to = /* @__PURE__ */ new Map();
4846      const updateDecoder = new LazyStructReader(new YDecoder(createDecoder(update)), false);
4847      let curr = updateDecoder.curr;
4848      if (curr !== null) {
4849        let currClient = curr.id.client;
4850        let currClock = curr.id.clock;
4851        from2.set(currClient, currClock);
4852        for (; curr !== null; curr = updateDecoder.next()) {
4853          if (currClient !== curr.id.client) {
4854            to.set(currClient, currClock);
4855            from2.set(curr.id.client, curr.id.clock);
4856            currClient = curr.id.client;
4857          }
4858          currClock = curr.id.clock + curr.length;
4859        }
4860        to.set(currClient, currClock);
4861      }
4862      return { from: from2, to };
4863    };
4864    var parseUpdateMeta = (update) => parseUpdateMetaV2(update, UpdateDecoderV1);
4865    var sliceStruct = (left, diff) => {
4866      if (left.constructor === GC) {
4867        const { client, clock } = left.id;
4868        return new GC(createID(client, clock + diff), left.length - diff);
4869      } else if (left.constructor === Skip) {
4870        const { client, clock } = left.id;
4871        return new Skip(createID(client, clock + diff), left.length - diff);
4872      } else {
4873        const leftItem = (
4874          /** @type {Item} */
4875          left
4876        );
4877        const { client, clock } = leftItem.id;
4878        return new Item(
4879          createID(client, clock + diff),
4880          null,
4881          createID(client, clock + diff - 1),
4882          null,
4883          leftItem.rightOrigin,
4884          leftItem.parent,
4885          leftItem.parentSub,
4886          leftItem.content.splice(diff)
4887        );
4888      }
4889    };
4890    var mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
4891      if (updates.length === 1) {
4892        return updates[0];
4893      }
4894      const updateDecoders = updates.map((update) => new YDecoder(createDecoder(update)));
4895      let lazyStructDecoders = updateDecoders.map((decoder) => new LazyStructReader(decoder, true));
4896      let currWrite = null;
4897      const updateEncoder = new YEncoder();
4898      const lazyStructEncoder = new LazyStructWriter(updateEncoder);
4899      while (true) {
4900        lazyStructDecoders = lazyStructDecoders.filter((dec) => dec.curr !== null);
4901        lazyStructDecoders.sort(
4902          /** @type {function(any,any):number} */
4903          (dec1, dec2) => {
4904            if (dec1.curr.id.client === dec2.curr.id.client) {
4905              const clockDiff = dec1.curr.id.clock - dec2.curr.id.clock;
4906              if (clockDiff === 0) {
4907                return dec1.curr.constructor === dec2.curr.constructor ? 0 : dec1.curr.constructor === Skip ? 1 : -1;
4908              } else {
4909                return clockDiff;
4910              }
4911            } else {
4912              return dec2.curr.id.client - dec1.curr.id.client;
4913            }
4914          }
4915        );
4916        if (lazyStructDecoders.length === 0) {
4917          break;
4918        }
4919        const currDecoder = lazyStructDecoders[0];
4920        const firstClient = (
4921          /** @type {Item | GC} */
4922          currDecoder.curr.id.client
4923        );
4924        if (currWrite !== null) {
4925          let curr = (
4926            /** @type {Item | GC | null} */
4927            currDecoder.curr
4928          );
4929          let iterated = false;
4930          while (curr !== null && curr.id.clock + curr.length <= currWrite.struct.id.clock + currWrite.struct.length && curr.id.client >= currWrite.struct.id.client) {
4931            curr = currDecoder.next();
4932            iterated = true;
4933          }
4934          if (curr === null || // current decoder is empty
4935          curr.id.client !== firstClient || // check whether there is another decoder that has has updates from `firstClient`
4936          iterated && curr.id.clock > currWrite.struct.id.clock + currWrite.struct.length) {
4937            continue;
4938          }
4939          if (firstClient !== currWrite.struct.id.client) {
4940            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4941            currWrite = { struct: curr, offset: 0 };
4942            currDecoder.next();
4943          } else {
4944            if (currWrite.struct.id.clock + currWrite.struct.length < curr.id.clock) {
4945              if (currWrite.struct.constructor === Skip) {
4946                currWrite.struct.length = curr.id.clock + curr.length - currWrite.struct.id.clock;
4947              } else {
4948                writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4949                const diff = curr.id.clock - currWrite.struct.id.clock - currWrite.struct.length;
4950                const struct = new Skip(createID(firstClient, currWrite.struct.id.clock + currWrite.struct.length), diff);
4951                currWrite = { struct, offset: 0 };
4952              }
4953            } else {
4954              const diff = currWrite.struct.id.clock + currWrite.struct.length - curr.id.clock;
4955              if (diff > 0) {
4956                if (currWrite.struct.constructor === Skip) {
4957                  currWrite.struct.length -= diff;
4958                } else {
4959                  curr = sliceStruct(curr, diff);
4960                }
4961              }
4962              if (!currWrite.struct.mergeWith(
4963                /** @type {any} */
4964                curr
4965              )) {
4966                writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4967                currWrite = { struct: curr, offset: 0 };
4968                currDecoder.next();
4969              }
4970            }
4971          }
4972        } else {
4973          currWrite = { struct: (
4974            /** @type {Item | GC} */
4975            currDecoder.curr
4976          ), offset: 0 };
4977          currDecoder.next();
4978        }
4979        for (let next = currDecoder.curr; next !== null && next.id.client === firstClient && next.id.clock === currWrite.struct.id.clock + currWrite.struct.length && next.constructor !== Skip; next = currDecoder.next()) {
4980          writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4981          currWrite = { struct: next, offset: 0 };
4982        }
4983      }
4984      if (currWrite !== null) {
4985        writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset);
4986        currWrite = null;
4987      }
4988      finishLazyStructWriting(lazyStructEncoder);
4989      const dss = updateDecoders.map((decoder) => readDeleteSet(decoder));
4990      const ds = mergeDeleteSets(dss);
4991      writeDeleteSet(updateEncoder, ds);
4992      return updateEncoder.toUint8Array();
4993    };
4994    var diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
4995      const state = decodeStateVector(sv);
4996      const encoder = new YEncoder();
4997      const lazyStructWriter = new LazyStructWriter(encoder);
4998      const decoder = new YDecoder(createDecoder(update));
4999      const reader = new LazyStructReader(decoder, false);
5000      while (reader.curr) {
5001        const curr = reader.curr;
5002        const currClient = curr.id.client;
5003        const svClock = state.get(currClient) || 0;
5004        if (reader.curr.constructor === Skip) {
5005          reader.next();
5006          continue;
5007        }
5008        if (curr.id.clock + curr.length > svClock) {
5009          writeStructToLazyStructWriter(lazyStructWriter, curr, max(svClock - curr.id.clock, 0));
5010          reader.next();
5011          while (reader.curr && reader.curr.id.client === currClient) {
5012            writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0);
5013            reader.next();
5014          }
5015        } else {
5016          while (reader.curr && reader.curr.id.client === currClient && reader.curr.id.clock + reader.curr.length <= svClock) {
5017            reader.next();
5018          }
5019        }
5020      }
5021      finishLazyStructWriting(lazyStructWriter);
5022      const ds = readDeleteSet(decoder);
5023      writeDeleteSet(encoder, ds);
5024      return encoder.toUint8Array();
5025    };
5026    var diffUpdate = (update, sv) => diffUpdateV2(update, sv, UpdateDecoderV1, UpdateEncoderV1);
5027    var flushLazyStructWriter = (lazyWriter) => {
5028      if (lazyWriter.written > 0) {
5029        lazyWriter.clientStructs.push({ written: lazyWriter.written, restEncoder: toUint8Array(lazyWriter.encoder.restEncoder) });
5030        lazyWriter.encoder.restEncoder = createEncoder();
5031        lazyWriter.written = 0;
5032      }
5033    };
5034    var writeStructToLazyStructWriter = (lazyWriter, struct, offset) => {
5035      if (lazyWriter.written > 0 && lazyWriter.currClient !== struct.id.client) {
5036        flushLazyStructWriter(lazyWriter);
5037      }
5038      if (lazyWriter.written === 0) {
5039        lazyWriter.currClient = struct.id.client;
5040        lazyWriter.encoder.writeClient(struct.id.client);
5041        writeVarUint(lazyWriter.encoder.restEncoder, struct.id.clock + offset);
5042      }
5043      struct.write(lazyWriter.encoder, offset);
5044      lazyWriter.written++;
5045    };
5046    var finishLazyStructWriting = (lazyWriter) => {
5047      flushLazyStructWriter(lazyWriter);
5048      const restEncoder = lazyWriter.encoder.restEncoder;
5049      writeVarUint(restEncoder, lazyWriter.clientStructs.length);
5050      for (let i = 0; i < lazyWriter.clientStructs.length; i++) {
5051        const partStructs = lazyWriter.clientStructs[i];
5052        writeVarUint(restEncoder, partStructs.written);
5053        writeUint8Array(restEncoder, partStructs.restEncoder);
5054      }
5055    };
5056    var convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder) => {
5057      const updateDecoder = new YDecoder(createDecoder(update));
5058      const lazyDecoder = new LazyStructReader(updateDecoder, false);
5059      const updateEncoder = new YEncoder();
5060      const lazyWriter = new LazyStructWriter(updateEncoder);
5061      for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
5062        writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0);
5063      }
5064      finishLazyStructWriting(lazyWriter);
5065      const ds = readDeleteSet(updateDecoder);
5066      writeDeleteSet(updateEncoder, ds);
5067      return updateEncoder.toUint8Array();
5068    };
5069    var createObfuscator = ({ formatting = true, subdocs = true, yxml = true } = {}) => {
5070      let i = 0;
5071      const mapKeyCache = create();
5072      const nodeNameCache = create();
5073      const formattingKeyCache = create();
5074      const formattingValueCache = create();
5075      formattingValueCache.set(null, null);
5076      return (block) => {
5077        switch (block.constructor) {
5078          case GC:
5079          case Skip:
5080            return block;
5081          case Item: {
5082            const item = (
5083              /** @type {Item} */
5084              block
5085            );
5086            const content = item.content;
5087            switch (content.constructor) {
5088              case ContentDeleted:
5089                break;
5090              case ContentType: {
5091                if (yxml) {
5092                  const type = (
5093                    /** @type {ContentType} */
5094                    content.type
5095                  );
5096                  if (type instanceof YXmlElement) {
5097                    type.nodeName = setIfUndefined(nodeNameCache, type.nodeName, () => "node-" + i);
5098                  }
5099                  if (type instanceof YXmlHook) {
5100                    type.hookName = setIfUndefined(nodeNameCache, type.hookName, () => "hook-" + i);
5101                  }
5102                }
5103                break;
5104              }
5105              case ContentAny: {
5106                const c = (
5107                  /** @type {ContentAny} */
5108                  content
5109                );
5110                c.arr = c.arr.map(() => i);
5111                break;
5112              }
5113              case ContentBinary: {
5114                const c = (
5115                  /** @type {ContentBinary} */
5116                  content
5117                );
5118                c.content = new Uint8Array([i]);
5119                break;
5120              }
5121              case ContentDoc: {
5122                const c = (
5123                  /** @type {ContentDoc} */
5124                  content
5125                );
5126                if (subdocs) {
5127                  c.opts = {};
5128                  c.doc.guid = i + "";
5129                }
5130                break;
5131              }
5132              case ContentEmbed: {
5133                const c = (
5134                  /** @type {ContentEmbed} */
5135                  content
5136                );
5137                c.embed = {};
5138                break;
5139              }
5140              case ContentFormat: {
5141                const c = (
5142                  /** @type {ContentFormat} */
5143                  content
5144                );
5145                if (formatting) {
5146                  c.key = setIfUndefined(formattingKeyCache, c.key, () => i + "");
5147                  c.value = setIfUndefined(formattingValueCache, c.value, () => ({ i }));
5148                }
5149                break;
5150              }
5151              case ContentJSON: {
5152                const c = (
5153                  /** @type {ContentJSON} */
5154                  content
5155                );
5156                c.arr = c.arr.map(() => i);
5157                break;
5158              }
5159              case ContentString: {
5160                const c = (
5161                  /** @type {ContentString} */
5162                  content
5163                );
5164                c.str = repeat(i % 10 + "", c.str.length);
5165                break;
5166              }
5167              default:
5168                unexpectedCase();
5169            }
5170            if (item.parentSub) {
5171              item.parentSub = setIfUndefined(mapKeyCache, item.parentSub, () => i + "");
5172            }
5173            i++;
5174            return block;
5175          }
5176          default:
5177            unexpectedCase();
5178        }
5179      };
5180    };
5181    var obfuscateUpdate = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV1, UpdateEncoderV1);
5182    var obfuscateUpdateV2 = (update, opts) => convertUpdateFormat(update, createObfuscator(opts), UpdateDecoderV2, UpdateEncoderV2);
5183    var convertUpdateFormatV1ToV2 = (update) => convertUpdateFormat(update, id, UpdateDecoderV1, UpdateEncoderV2);
5184    var convertUpdateFormatV2ToV1 = (update) => convertUpdateFormat(update, id, UpdateDecoderV2, UpdateEncoderV1);
5185    var errorComputeChanges = "You must not compute changes after the event-handler fired.";
5186    var YEvent = class {
5187      /**
5188       * @param {T} target The changed type.
5189       * @param {Transaction} transaction
5190       */
5191      constructor(target, transaction) {
5192        this.target = target;
5193        this.currentTarget = target;
5194        this.transaction = transaction;
5195        this._changes = null;
5196        this._keys = null;
5197        this._delta = null;
5198        this._path = null;
5199      }
5200      /**
5201       * Computes the path from `y` to the changed type.
5202       *
5203       * @todo v14 should standardize on path: Array<{parent, index}> because that is easier to work with.
5204       *
5205       * The following property holds:
5206       * @example
5207       *   let type = y
5208       *   event.path.forEach(dir => {
5209       *     type = type.get(dir)
5210       *   })
5211       *   type === event.target // => true
5212       */
5213      get path() {
5214        return this._path || (this._path = getPathTo(this.currentTarget, this.target));
5215      }
5216      /**
5217       * Check if a struct is deleted by this event.
5218       *
5219       * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
5220       *
5221       * @param {AbstractStruct} struct
5222       * @return {boolean}
5223       */
5224      deletes(struct) {
5225        return isDeleted(this.transaction.deleteSet, struct.id);
5226      }
5227      /**
5228       * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
5229       */
5230      get keys() {
5231        if (this._keys === null) {
5232          if (this.transaction.doc._transactionCleanups.length === 0) {
5233            throw create3(errorComputeChanges);
5234          }
5235          const keys2 = /* @__PURE__ */ new Map();
5236          const target = this.target;
5237          const changed = (
5238            /** @type Set<string|null> */
5239            this.transaction.changed.get(target)
5240          );
5241          changed.forEach((key) => {
5242            if (key !== null) {
5243              const item = (
5244                /** @type {Item} */
5245                target._map.get(key)
5246              );
5247              let action;
5248              let oldValue;
5249              if (this.adds(item)) {
5250                let prev = item.left;
5251                while (prev !== null && this.adds(prev)) {
5252                  prev = prev.left;
5253                }
5254                if (this.deletes(item)) {
5255                  if (prev !== null && this.deletes(prev)) {
5256                    action = "delete";
5257                    oldValue = last(prev.content.getContent());
5258                  } else {
5259                    return;
5260                  }
5261                } else {
5262                  if (prev !== null && this.deletes(prev)) {
5263                    action = "update";
5264                    oldValue = last(prev.content.getContent());
5265                  } else {
5266                    action = "add";
5267                    oldValue = void 0;
5268                  }
5269                }
5270              } else {
5271                if (this.deletes(item)) {
5272                  action = "delete";
5273                  oldValue = last(
5274                    /** @type {Item} */
5275                    item.content.getContent()
5276                  );
5277                } else {
5278                  return;
5279                }
5280              }
5281              keys2.set(key, { action, oldValue });
5282            }
5283          });
5284          this._keys = keys2;
5285        }
5286        return this._keys;
5287      }
5288      /**
5289       * This is a computed property. Note that this can only be safely computed during the
5290       * event call. Computing this property after other changes happened might result in
5291       * unexpected behavior (incorrect computation of deltas). A safe way to collect changes
5292       * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
5293       *
5294       * @type {Array<{insert?: string | Array<any> | object | AbstractType<any>, retain?: number, delete?: number, attributes?: Object<string, any>}>}
5295       */
5296      get delta() {
5297        return this.changes.delta;
5298      }
5299      /**
5300       * Check if a struct is added by this event.
5301       *
5302       * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
5303       *
5304       * @param {AbstractStruct} struct
5305       * @return {boolean}
5306       */
5307      adds(struct) {
5308        return struct.id.clock >= (this.transaction.beforeState.get(struct.id.client) || 0);
5309      }
5310      /**
5311       * This is a computed property. Note that this can only be safely computed during the
5312       * event call. Computing this property after other changes happened might result in
5313       * unexpected behavior (incorrect computation of deltas). A safe way to collect changes
5314       * is to store the `changes` or the `delta` object. Avoid storing the `transaction` object.
5315       *
5316       * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string, delete?:number, retain?:number}>}}
5317       */
5318      get changes() {
5319        let changes = this._changes;
5320        if (changes === null) {
5321          if (this.transaction.doc._transactionCleanups.length === 0) {
5322            throw create3(errorComputeChanges);
5323          }
5324          const target = this.target;
5325          const added = create2();
5326          const deleted = create2();
5327          const delta = [];
5328          changes = {
5329            added,
5330            deleted,
5331            delta,
5332            keys: this.keys
5333          };
5334          const changed = (
5335            /** @type Set<string|null> */
5336            this.transaction.changed.get(target)
5337          );
5338          if (changed.has(null)) {
5339            let lastOp = null;
5340            const packOp = () => {
5341              if (lastOp) {
5342                delta.push(lastOp);
5343              }
5344            };
5345            for (let item = target._start; item !== null; item = item.right) {
5346              if (item.deleted) {
5347                if (this.deletes(item) && !this.adds(item)) {
5348                  if (lastOp === null || lastOp.delete === void 0) {
5349                    packOp();
5350                    lastOp = { delete: 0 };
5351                  }
5352                  lastOp.delete += item.length;
5353                  deleted.add(item);
5354                }
5355              } else {
5356                if (this.adds(item)) {
5357                  if (lastOp === null || lastOp.insert === void 0) {
5358                    packOp();
5359                    lastOp = { insert: [] };
5360                  }
5361                  lastOp.insert = lastOp.insert.concat(item.content.getContent());
5362                  added.add(item);
5363                } else {
5364                  if (lastOp === null || lastOp.retain === void 0) {
5365                    packOp();
5366                    lastOp = { retain: 0 };
5367                  }
5368                  lastOp.retain += item.length;
5369                }
5370              }
5371            }
5372            if (lastOp !== null && lastOp.retain === void 0) {
5373              packOp();
5374            }
5375          }
5376          this._changes = changes;
5377        }
5378        return (
5379          /** @type {any} */
5380          changes
5381        );
5382      }
5383    };
5384    var getPathTo = (parent, child) => {
5385      const path = [];
5386      while (child._item !== null && child !== parent) {
5387        if (child._item.parentSub !== null) {
5388          path.unshift(child._item.parentSub);
5389        } else {
5390          let i = 0;
5391          let c = (
5392            /** @type {AbstractType<any>} */
5393            child._item.parent._start
5394          );
5395          while (c !== child._item && c !== null) {
5396            if (!c.deleted && c.countable) {
5397              i += c.length;
5398            }
5399            c = c.right;
5400          }
5401          path.unshift(i);
5402        }
5403        child = /** @type {AbstractType<any>} */
5404        child._item.parent;
5405      }
5406      return path;
5407    };
5408    var warnPrematureAccess = () => {
5409      warn("Invalid access: Add Yjs type to a document before reading data.");
5410    };
5411    var maxSearchMarker = 80;
5412    var globalSearchMarkerTimestamp = 0;
5413    var ArraySearchMarker = class {
5414      /**
5415       * @param {Item} p
5416       * @param {number} index
5417       */
5418      constructor(p, index) {
5419        p.marker = true;
5420        this.p = p;
5421        this.index = index;
5422        this.timestamp = globalSearchMarkerTimestamp++;
5423      }
5424    };
5425    var refreshMarkerTimestamp = (marker) => {
5426      marker.timestamp = globalSearchMarkerTimestamp++;
5427    };
5428    var overwriteMarker = (marker, p, index) => {
5429      marker.p.marker = false;
5430      marker.p = p;
5431      p.marker = true;
5432      marker.index = index;
5433      marker.timestamp = globalSearchMarkerTimestamp++;
5434    };
5435    var markPosition = (searchMarker, p, index) => {
5436      if (searchMarker.length >= maxSearchMarker) {
5437        const marker = searchMarker.reduce((a, b) => a.timestamp < b.timestamp ? a : b);
5438        overwriteMarker(marker, p, index);
5439        return marker;
5440      } else {
5441        const pm = new ArraySearchMarker(p, index);
5442        searchMarker.push(pm);
5443        return pm;
5444      }
5445    };
5446    var findMarker = (yarray, index) => {
5447      if (yarray._start === null || index === 0 || yarray._searchMarker === null) {
5448        return null;
5449      }
5450      const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => abs(index - a.index) < abs(index - b.index) ? a : b);
5451      let p = yarray._start;
5452      let pindex = 0;
5453      if (marker !== null) {
5454        p = marker.p;
5455        pindex = marker.index;
5456        refreshMarkerTimestamp(marker);
5457      }
5458      while (p.right !== null && pindex < index) {
5459        if (!p.deleted && p.countable) {
5460          if (index < pindex + p.length) {
5461            break;
5462          }
5463          pindex += p.length;
5464        }
5465        p = p.right;
5466      }
5467      while (p.left !== null && pindex > index) {
5468        p = p.left;
5469        if (!p.deleted && p.countable) {
5470          pindex -= p.length;
5471        }
5472      }
5473      while (p.left !== null && p.left.id.client === p.id.client && p.left.id.clock + p.left.length === p.id.clock) {
5474        p = p.left;
5475        if (!p.deleted && p.countable) {
5476          pindex -= p.length;
5477        }
5478      }
5479      if (marker !== null && abs(marker.index - pindex) < /** @type {YText|YArray<any>} */
5480      p.parent.length / maxSearchMarker) {
5481        overwriteMarker(marker, p, pindex);
5482        return marker;
5483      } else {
5484        return markPosition(yarray._searchMarker, p, pindex);
5485      }
5486    };
5487    var updateMarkerChanges = (searchMarker, index, len) => {
5488      for (let i = searchMarker.length - 1; i >= 0; i--) {
5489        const m = searchMarker[i];
5490        if (len > 0) {
5491          let p = m.p;
5492          p.marker = false;
5493          while (p && (p.deleted || !p.countable)) {
5494            p = p.left;
5495            if (p && !p.deleted && p.countable) {
5496              m.index -= p.length;
5497            }
5498          }
5499          if (p === null || p.marker === true) {
5500            searchMarker.splice(i, 1);
5501            continue;
5502          }
5503          m.p = p;
5504          p.marker = true;
5505        }
5506        if (index < m.index || len > 0 && index === m.index) {
5507          m.index = max(index, m.index + len);
5508        }
5509      }
5510    };
5511    var getTypeChildren = (t) => {
5512      t.doc ?? warnPrematureAccess();
5513      let s = t._start;
5514      const arr = [];
5515      while (s) {
5516        arr.push(s);
5517        s = s.right;
5518      }
5519      return arr;
5520    };
5521    var callTypeObservers = (type, transaction, event) => {
5522      const changedType = type;
5523      const changedParentTypes = transaction.changedParentTypes;
5524      while (true) {
5525        setIfUndefined(changedParentTypes, type, () => []).push(event);
5526        if (type._item === null) {
5527          break;
5528        }
5529        type = /** @type {AbstractType<any>} */
5530        type._item.parent;
5531      }
5532      callEventHandlerListeners(changedType._eH, event, transaction);
5533    };
5534    var AbstractType = class {
5535      constructor() {
5536        this._item = null;
5537        this._map = /* @__PURE__ */ new Map();
5538        this._start = null;
5539        this.doc = null;
5540        this._length = 0;
5541        this._eH = createEventHandler();
5542        this._dEH = createEventHandler();
5543        this._searchMarker = null;
5544      }
5545      /**
5546       * @return {AbstractType<any>|null}
5547       */
5548      get parent() {
5549        return this._item ? (
5550          /** @type {AbstractType<any>} */
5551          this._item.parent
5552        ) : null;
5553      }
5554      /**
5555       * Integrate this type into the Yjs instance.
5556       *
5557       * * Save this struct in the os
5558       * * This type is sent to other client
5559       * * Observer functions are fired
5560       *
5561       * @param {Doc} y The Yjs instance
5562       * @param {Item|null} item
5563       */
5564      _integrate(y, item) {
5565        this.doc = y;
5566        this._item = item;
5567      }
5568      /**
5569       * @return {AbstractType<EventType>}
5570       */
5571      _copy() {
5572        throw methodUnimplemented();
5573      }
5574      /**
5575       * Makes a copy of this data type that can be included somewhere else.
5576       *
5577       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
5578       *
5579       * @return {AbstractType<EventType>}
5580       */
5581      clone() {
5582        throw methodUnimplemented();
5583      }
5584      /**
5585       * @param {UpdateEncoderV1 | UpdateEncoderV2} _encoder
5586       */
5587      _write(_encoder) {
5588      }
5589      /**
5590       * The first non-deleted item
5591       */
5592      get _first() {
5593        let n = this._start;
5594        while (n !== null && n.deleted) {
5595          n = n.right;
5596        }
5597        return n;
5598      }
5599      /**
5600       * Creates YEvent and calls all type observers.
5601       * Must be implemented by each type.
5602       *
5603       * @param {Transaction} transaction
5604       * @param {Set<null|string>} _parentSubs Keys changed on this type. `null` if list was modified.
5605       */
5606      _callObserver(transaction, _parentSubs) {
5607        if (!transaction.local && this._searchMarker) {
5608          this._searchMarker.length = 0;
5609        }
5610      }
5611      /**
5612       * Observe all events that are created on this type.
5613       *
5614       * @param {function(EventType, Transaction):void} f Observer function
5615       */
5616      observe(f) {
5617        addEventHandlerListener(this._eH, f);
5618      }
5619      /**
5620       * Observe all events that are created by this type and its children.
5621       *
5622       * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
5623       */
5624      observeDeep(f) {
5625        addEventHandlerListener(this._dEH, f);
5626      }
5627      /**
5628       * Unregister an observer function.
5629       *
5630       * @param {function(EventType,Transaction):void} f Observer function
5631       */
5632      unobserve(f) {
5633        removeEventHandlerListener(this._eH, f);
5634      }
5635      /**
5636       * Unregister an observer function.
5637       *
5638       * @param {function(Array<YEvent<any>>,Transaction):void} f Observer function
5639       */
5640      unobserveDeep(f) {
5641        removeEventHandlerListener(this._dEH, f);
5642      }
5643      /**
5644       * @abstract
5645       * @return {any}
5646       */
5647      toJSON() {
5648      }
5649    };
5650    var typeListSlice = (type, start, end) => {
5651      type.doc ?? warnPrematureAccess();
5652      if (start < 0) {
5653        start = type._length + start;
5654      }
5655      if (end < 0) {
5656        end = type._length + end;
5657      }
5658      let len = end - start;
5659      const cs = [];
5660      let n = type._start;
5661      while (n !== null && len > 0) {
5662        if (n.countable && !n.deleted) {
5663          const c = n.content.getContent();
5664          if (c.length <= start) {
5665            start -= c.length;
5666          } else {
5667            for (let i = start; i < c.length && len > 0; i++) {
5668              cs.push(c[i]);
5669              len--;
5670            }
5671            start = 0;
5672          }
5673        }
5674        n = n.right;
5675      }
5676      return cs;
5677    };
5678    var typeListToArray = (type) => {
5679      type.doc ?? warnPrematureAccess();
5680      const cs = [];
5681      let n = type._start;
5682      while (n !== null) {
5683        if (n.countable && !n.deleted) {
5684          const c = n.content.getContent();
5685          for (let i = 0; i < c.length; i++) {
5686            cs.push(c[i]);
5687          }
5688        }
5689        n = n.right;
5690      }
5691      return cs;
5692    };
5693    var typeListToArraySnapshot = (type, snapshot2) => {
5694      const cs = [];
5695      let n = type._start;
5696      while (n !== null) {
5697        if (n.countable && isVisible(n, snapshot2)) {
5698          const c = n.content.getContent();
5699          for (let i = 0; i < c.length; i++) {
5700            cs.push(c[i]);
5701          }
5702        }
5703        n = n.right;
5704      }
5705      return cs;
5706    };
5707    var typeListForEach = (type, f) => {
5708      let index = 0;
5709      let n = type._start;
5710      type.doc ?? warnPrematureAccess();
5711      while (n !== null) {
5712        if (n.countable && !n.deleted) {
5713          const c = n.content.getContent();
5714          for (let i = 0; i < c.length; i++) {
5715            f(c[i], index++, type);
5716          }
5717        }
5718        n = n.right;
5719      }
5720    };
5721    var typeListMap = (type, f) => {
5722      const result = [];
5723      typeListForEach(type, (c, i) => {
5724        result.push(f(c, i, type));
5725      });
5726      return result;
5727    };
5728    var typeListCreateIterator = (type) => {
5729      let n = type._start;
5730      let currentContent = null;
5731      let currentContentIndex = 0;
5732      return {
5733        [Symbol.iterator]() {
5734          return this;
5735        },
5736        next: () => {
5737          if (currentContent === null) {
5738            while (n !== null && n.deleted) {
5739              n = n.right;
5740            }
5741            if (n === null) {
5742              return {
5743                done: true,
5744                value: void 0
5745              };
5746            }
5747            currentContent = n.content.getContent();
5748            currentContentIndex = 0;
5749            n = n.right;
5750          }
5751          const value = currentContent[currentContentIndex++];
5752          if (currentContent.length <= currentContentIndex) {
5753            currentContent = null;
5754          }
5755          return {
5756            done: false,
5757            value
5758          };
5759        }
5760      };
5761    };
5762    var typeListGet = (type, index) => {
5763      type.doc ?? warnPrematureAccess();
5764      const marker = findMarker(type, index);
5765      let n = type._start;
5766      if (marker !== null) {
5767        n = marker.p;
5768        index -= marker.index;
5769      }
5770      for (; n !== null; n = n.right) {
5771        if (!n.deleted && n.countable) {
5772          if (index < n.length) {
5773            return n.content.getContent()[index];
5774          }
5775          index -= n.length;
5776        }
5777      }
5778    };
5779    var typeListInsertGenericsAfter = (transaction, parent, referenceItem, content) => {
5780      let left = referenceItem;
5781      const doc2 = transaction.doc;
5782      const ownClientId = doc2.clientID;
5783      const store = doc2.store;
5784      const right = referenceItem === null ? parent._start : referenceItem.right;
5785      let jsonContent = [];
5786      const packJsonContent = () => {
5787        if (jsonContent.length > 0) {
5788          left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentAny(jsonContent));
5789          left.integrate(transaction, 0);
5790          jsonContent = [];
5791        }
5792      };
5793      content.forEach((c) => {
5794        if (c === null) {
5795          jsonContent.push(c);
5796        } else {
5797          switch (c.constructor) {
5798            case Number:
5799            case Object:
5800            case Boolean:
5801            case Array:
5802            case String:
5803              jsonContent.push(c);
5804              break;
5805            default:
5806              packJsonContent();
5807              switch (c.constructor) {
5808                case Uint8Array:
5809                case ArrayBuffer:
5810                  left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentBinary(new Uint8Array(
5811                    /** @type {Uint8Array} */
5812                    c
5813                  )));
5814                  left.integrate(transaction, 0);
5815                  break;
5816                case Doc:
5817                  left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentDoc(
5818                    /** @type {Doc} */
5819                    c
5820                  ));
5821                  left.integrate(transaction, 0);
5822                  break;
5823                default:
5824                  if (c instanceof AbstractType) {
5825                    left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentType(c));
5826                    left.integrate(transaction, 0);
5827                  } else {
5828                    throw new Error("Unexpected content type in insert operation");
5829                  }
5830              }
5831          }
5832        }
5833      });
5834      packJsonContent();
5835    };
5836    var lengthExceeded = () => create3("Length exceeded!");
5837    var typeListInsertGenerics = (transaction, parent, index, content) => {
5838      if (index > parent._length) {
5839        throw lengthExceeded();
5840      }
5841      if (index === 0) {
5842        if (parent._searchMarker) {
5843          updateMarkerChanges(parent._searchMarker, index, content.length);
5844        }
5845        return typeListInsertGenericsAfter(transaction, parent, null, content);
5846      }
5847      const startIndex = index;
5848      const marker = findMarker(parent, index);
5849      let n = parent._start;
5850      if (marker !== null) {
5851        n = marker.p;
5852        index -= marker.index;
5853        if (index === 0) {
5854          n = n.prev;
5855          index += n && n.countable && !n.deleted ? n.length : 0;
5856        }
5857      }
5858      for (; n !== null; n = n.right) {
5859        if (!n.deleted && n.countable) {
5860          if (index <= n.length) {
5861            if (index < n.length) {
5862              getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));
5863            }
5864            break;
5865          }
5866          index -= n.length;
5867        }
5868      }
5869      if (parent._searchMarker) {
5870        updateMarkerChanges(parent._searchMarker, startIndex, content.length);
5871      }
5872      return typeListInsertGenericsAfter(transaction, parent, n, content);
5873    };
5874    var typeListPushGenerics = (transaction, parent, content) => {
5875      const marker = (parent._searchMarker || []).reduce((maxMarker, currMarker) => currMarker.index > maxMarker.index ? currMarker : maxMarker, { index: 0, p: parent._start });
5876      let n = marker.p;
5877      if (n) {
5878        while (n.right) {
5879          n = n.right;
5880        }
5881      }
5882      return typeListInsertGenericsAfter(transaction, parent, n, content);
5883    };
5884    var typeListDelete = (transaction, parent, index, length2) => {
5885      if (length2 === 0) {
5886        return;
5887      }
5888      const startIndex = index;
5889      const startLength = length2;
5890      const marker = findMarker(parent, index);
5891      let n = parent._start;
5892      if (marker !== null) {
5893        n = marker.p;
5894        index -= marker.index;
5895      }
5896      for (; n !== null && index > 0; n = n.right) {
5897        if (!n.deleted && n.countable) {
5898          if (index < n.length) {
5899            getItemCleanStart(transaction, createID(n.id.client, n.id.clock + index));
5900          }
5901          index -= n.length;
5902        }
5903      }
5904      while (length2 > 0 && n !== null) {
5905        if (!n.deleted) {
5906          if (length2 < n.length) {
5907            getItemCleanStart(transaction, createID(n.id.client, n.id.clock + length2));
5908          }
5909          n.delete(transaction);
5910          length2 -= n.length;
5911        }
5912        n = n.right;
5913      }
5914      if (length2 > 0) {
5915        throw lengthExceeded();
5916      }
5917      if (parent._searchMarker) {
5918        updateMarkerChanges(
5919          parent._searchMarker,
5920          startIndex,
5921          -startLength + length2
5922          /* in case we remove the above exception */
5923        );
5924      }
5925    };
5926    var typeMapDelete = (transaction, parent, key) => {
5927      const c = parent._map.get(key);
5928      if (c !== void 0) {
5929        c.delete(transaction);
5930      }
5931    };
5932    var typeMapSet = (transaction, parent, key, value) => {
5933      const left = parent._map.get(key) || null;
5934      const doc2 = transaction.doc;
5935      const ownClientId = doc2.clientID;
5936      let content;
5937      if (value == null) {
5938        content = new ContentAny([value]);
5939      } else {
5940        switch (value.constructor) {
5941          case Number:
5942          case Object:
5943          case Boolean:
5944          case Array:
5945          case String:
5946          case Date:
5947          case BigInt:
5948            content = new ContentAny([value]);
5949            break;
5950          case Uint8Array:
5951            content = new ContentBinary(
5952              /** @type {Uint8Array} */
5953              value
5954            );
5955            break;
5956          case Doc:
5957            content = new ContentDoc(
5958              /** @type {Doc} */
5959              value
5960            );
5961            break;
5962          default:
5963            if (value instanceof AbstractType) {
5964              content = new ContentType(value);
5965            } else {
5966              throw new Error("Unexpected content type");
5967            }
5968        }
5969      }
5970      new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, null, null, parent, key, content).integrate(transaction, 0);
5971    };
5972    var typeMapGet = (parent, key) => {
5973      parent.doc ?? warnPrematureAccess();
5974      const val = parent._map.get(key);
5975      return val !== void 0 && !val.deleted ? val.content.getContent()[val.length - 1] : void 0;
5976    };
5977    var typeMapGetAll = (parent) => {
5978      const res = {};
5979      parent.doc ?? warnPrematureAccess();
5980      parent._map.forEach((value, key) => {
5981        if (!value.deleted) {
5982          res[key] = value.content.getContent()[value.length - 1];
5983        }
5984      });
5985      return res;
5986    };
5987    var typeMapHas = (parent, key) => {
5988      parent.doc ?? warnPrematureAccess();
5989      const val = parent._map.get(key);
5990      return val !== void 0 && !val.deleted;
5991    };
5992    var typeMapGetSnapshot = (parent, key, snapshot2) => {
5993      let v = parent._map.get(key) || null;
5994      while (v !== null && (!snapshot2.sv.has(v.id.client) || v.id.clock >= (snapshot2.sv.get(v.id.client) || 0))) {
5995        v = v.left;
5996      }
5997      return v !== null && isVisible(v, snapshot2) ? v.content.getContent()[v.length - 1] : void 0;
5998    };
5999    var typeMapGetAllSnapshot = (parent, snapshot2) => {
6000      const res = {};
6001      parent._map.forEach((value, key) => {
6002        let v = value;
6003        while (v !== null && (!snapshot2.sv.has(v.id.client) || v.id.clock >= (snapshot2.sv.get(v.id.client) || 0))) {
6004          v = v.left;
6005        }
6006        if (v !== null && isVisible(v, snapshot2)) {
6007          res[key] = v.content.getContent()[v.length - 1];
6008        }
6009      });
6010      return res;
6011    };
6012    var createMapIterator = (type) => {
6013      type.doc ?? warnPrematureAccess();
6014      return iteratorFilter(
6015        type._map.entries(),
6016        /** @param {any} entry */
6017        (entry) => !entry[1].deleted
6018      );
6019    };
6020    var YArrayEvent = class extends YEvent {
6021    };
6022    var YArray = class _YArray extends AbstractType {
6023      constructor() {
6024        super();
6025        this._prelimContent = [];
6026        this._searchMarker = [];
6027      }
6028      /**
6029       * Construct a new YArray containing the specified items.
6030       * @template {Object<string,any>|Array<any>|number|null|string|Uint8Array} T
6031       * @param {Array<T>} items
6032       * @return {YArray<T>}
6033       */
6034      static from(items) {
6035        const a = new _YArray();
6036        a.push(items);
6037        return a;
6038      }
6039      /**
6040       * Integrate this type into the Yjs instance.
6041       *
6042       * * Save this struct in the os
6043       * * This type is sent to other client
6044       * * Observer functions are fired
6045       *
6046       * @param {Doc} y The Yjs instance
6047       * @param {Item} item
6048       */
6049      _integrate(y, item) {
6050        super._integrate(y, item);
6051        this.insert(
6052          0,
6053          /** @type {Array<any>} */
6054          this._prelimContent
6055        );
6056        this._prelimContent = null;
6057      }
6058      /**
6059       * @return {YArray<T>}
6060       */
6061      _copy() {
6062        return new _YArray();
6063      }
6064      /**
6065       * Makes a copy of this data type that can be included somewhere else.
6066       *
6067       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
6068       *
6069       * @return {YArray<T>}
6070       */
6071      clone() {
6072        const arr = new _YArray();
6073        arr.insert(0, this.toArray().map(
6074          (el) => el instanceof AbstractType ? (
6075            /** @type {typeof el} */
6076            el.clone()
6077          ) : el
6078        ));
6079        return arr;
6080      }
6081      get length() {
6082        this.doc ?? warnPrematureAccess();
6083        return this._length;
6084      }
6085      /**
6086       * Creates YArrayEvent and calls observers.
6087       *
6088       * @param {Transaction} transaction
6089       * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
6090       */
6091      _callObserver(transaction, parentSubs) {
6092        super._callObserver(transaction, parentSubs);
6093        callTypeObservers(this, transaction, new YArrayEvent(this, transaction));
6094      }
6095      /**
6096       * Inserts new content at an index.
6097       *
6098       * Important: This function expects an array of content. Not just a content
6099       * object. The reason for this "weirdness" is that inserting several elements
6100       * is very efficient when it is done as a single operation.
6101       *
6102       * @example
6103       *  // Insert character 'a' at position 0
6104       *  yarray.insert(0, ['a'])
6105       *  // Insert numbers 1, 2 at position 1
6106       *  yarray.insert(1, [1, 2])
6107       *
6108       * @param {number} index The index to insert content at.
6109       * @param {Array<T>} content The array of content
6110       */
6111      insert(index, content) {
6112        if (this.doc !== null) {
6113          transact(this.doc, (transaction) => {
6114            typeListInsertGenerics(
6115              transaction,
6116              this,
6117              index,
6118              /** @type {any} */
6119              content
6120            );
6121          });
6122        } else {
6123          this._prelimContent.splice(index, 0, ...content);
6124        }
6125      }
6126      /**
6127       * Appends content to this YArray.
6128       *
6129       * @param {Array<T>} content Array of content to append.
6130       *
6131       * @todo Use the following implementation in all types.
6132       */
6133      push(content) {
6134        if (this.doc !== null) {
6135          transact(this.doc, (transaction) => {
6136            typeListPushGenerics(
6137              transaction,
6138              this,
6139              /** @type {any} */
6140              content
6141            );
6142          });
6143        } else {
6144          this._prelimContent.push(...content);
6145        }
6146      }
6147      /**
6148       * Prepends content to this YArray.
6149       *
6150       * @param {Array<T>} content Array of content to prepend.
6151       */
6152      unshift(content) {
6153        this.insert(0, content);
6154      }
6155      /**
6156       * Deletes elements starting from an index.
6157       *
6158       * @param {number} index Index at which to start deleting elements
6159       * @param {number} length The number of elements to remove. Defaults to 1.
6160       */
6161      delete(index, length2 = 1) {
6162        if (this.doc !== null) {
6163          transact(this.doc, (transaction) => {
6164            typeListDelete(transaction, this, index, length2);
6165          });
6166        } else {
6167          this._prelimContent.splice(index, length2);
6168        }
6169      }
6170      /**
6171       * Returns the i-th element from a YArray.
6172       *
6173       * @param {number} index The index of the element to return from the YArray
6174       * @return {T}
6175       */
6176      get(index) {
6177        return typeListGet(this, index);
6178      }
6179      /**
6180       * Transforms this YArray to a JavaScript Array.
6181       *
6182       * @return {Array<T>}
6183       */
6184      toArray() {
6185        return typeListToArray(this);
6186      }
6187      /**
6188       * Returns a portion of this YArray into a JavaScript Array selected
6189       * from start to end (end not included).
6190       *
6191       * @param {number} [start]
6192       * @param {number} [end]
6193       * @return {Array<T>}
6194       */
6195      slice(start = 0, end = this.length) {
6196        return typeListSlice(this, start, end);
6197      }
6198      /**
6199       * Transforms this Shared Type to a JSON object.
6200       *
6201       * @return {Array<any>}
6202       */
6203      toJSON() {
6204        return this.map((c) => c instanceof AbstractType ? c.toJSON() : c);
6205      }
6206      /**
6207       * Returns an Array with the result of calling a provided function on every
6208       * element of this YArray.
6209       *
6210       * @template M
6211       * @param {function(T,number,YArray<T>):M} f Function that produces an element of the new Array
6212       * @return {Array<M>} A new array with each element being the result of the
6213       *                 callback function
6214       */
6215      map(f) {
6216        return typeListMap(
6217          this,
6218          /** @type {any} */
6219          f
6220        );
6221      }
6222      /**
6223       * Executes a provided function once on every element of this YArray.
6224       *
6225       * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
6226       */
6227      forEach(f) {
6228        typeListForEach(this, f);
6229      }
6230      /**
6231       * @return {IterableIterator<T>}
6232       */
6233      [Symbol.iterator]() {
6234        return typeListCreateIterator(this);
6235      }
6236      /**
6237       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
6238       */
6239      _write(encoder) {
6240        encoder.writeTypeRef(YArrayRefID);
6241      }
6242    };
6243    var readYArray = (_decoder) => new YArray();
6244    var YMapEvent = class extends YEvent {
6245      /**
6246       * @param {YMap<T>} ymap The YArray that changed.
6247       * @param {Transaction} transaction
6248       * @param {Set<any>} subs The keys that changed.
6249       */
6250      constructor(ymap, transaction, subs) {
6251        super(ymap, transaction);
6252        this.keysChanged = subs;
6253      }
6254    };
6255    var YMap = class _YMap extends AbstractType {
6256      /**
6257       *
6258       * @param {Iterable<readonly [string, any]>=} entries - an optional iterable to initialize the YMap
6259       */
6260      constructor(entries) {
6261        super();
6262        this._prelimContent = null;
6263        if (entries === void 0) {
6264          this._prelimContent = /* @__PURE__ */ new Map();
6265        } else {
6266          this._prelimContent = new Map(entries);
6267        }
6268      }
6269      /**
6270       * Integrate this type into the Yjs instance.
6271       *
6272       * * Save this struct in the os
6273       * * This type is sent to other client
6274       * * Observer functions are fired
6275       *
6276       * @param {Doc} y The Yjs instance
6277       * @param {Item} item
6278       */
6279      _integrate(y, item) {
6280        super._integrate(y, item);
6281        this._prelimContent.forEach((value, key) => {
6282          this.set(key, value);
6283        });
6284        this._prelimContent = null;
6285      }
6286      /**
6287       * @return {YMap<MapType>}
6288       */
6289      _copy() {
6290        return new _YMap();
6291      }
6292      /**
6293       * Makes a copy of this data type that can be included somewhere else.
6294       *
6295       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
6296       *
6297       * @return {YMap<MapType>}
6298       */
6299      clone() {
6300        const map2 = new _YMap();
6301        this.forEach((value, key) => {
6302          map2.set(key, value instanceof AbstractType ? (
6303            /** @type {typeof value} */
6304            value.clone()
6305          ) : value);
6306        });
6307        return map2;
6308      }
6309      /**
6310       * Creates YMapEvent and calls observers.
6311       *
6312       * @param {Transaction} transaction
6313       * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
6314       */
6315      _callObserver(transaction, parentSubs) {
6316        callTypeObservers(this, transaction, new YMapEvent(this, transaction, parentSubs));
6317      }
6318      /**
6319       * Transforms this Shared Type to a JSON object.
6320       *
6321       * @return {Object<string,any>}
6322       */
6323      toJSON() {
6324        this.doc ?? warnPrematureAccess();
6325        const map2 = {};
6326        this._map.forEach((item, key) => {
6327          if (!item.deleted) {
6328            const v = item.content.getContent()[item.length - 1];
6329            map2[key] = v instanceof AbstractType ? v.toJSON() : v;
6330          }
6331        });
6332        return map2;
6333      }
6334      /**
6335       * Returns the size of the YMap (count of key/value pairs)
6336       *
6337       * @return {number}
6338       */
6339      get size() {
6340        return [...createMapIterator(this)].length;
6341      }
6342      /**
6343       * Returns the keys for each element in the YMap Type.
6344       *
6345       * @return {IterableIterator<string>}
6346       */
6347      keys() {
6348        return iteratorMap(
6349          createMapIterator(this),
6350          /** @param {any} v */
6351          (v) => v[0]
6352        );
6353      }
6354      /**
6355       * Returns the values for each element in the YMap Type.
6356       *
6357       * @return {IterableIterator<MapType>}
6358       */
6359      values() {
6360        return iteratorMap(
6361          createMapIterator(this),
6362          /** @param {any} v */
6363          (v) => v[1].content.getContent()[v[1].length - 1]
6364        );
6365      }
6366      /**
6367       * Returns an Iterator of [key, value] pairs
6368       *
6369       * @return {IterableIterator<[string, MapType]>}
6370       */
6371      entries() {
6372        return iteratorMap(
6373          createMapIterator(this),
6374          /** @param {any} v */
6375          (v) => (
6376            /** @type {any} */
6377            [v[0], v[1].content.getContent()[v[1].length - 1]]
6378          )
6379        );
6380      }
6381      /**
6382       * Executes a provided function on once on every key-value pair.
6383       *
6384       * @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.
6385       */
6386      forEach(f) {
6387        this.doc ?? warnPrematureAccess();
6388        this._map.forEach((item, key) => {
6389          if (!item.deleted) {
6390            f(item.content.getContent()[item.length - 1], key, this);
6391          }
6392        });
6393      }
6394      /**
6395       * Returns an Iterator of [key, value] pairs
6396       *
6397       * @return {IterableIterator<[string, MapType]>}
6398       */
6399      [Symbol.iterator]() {
6400        return this.entries();
6401      }
6402      /**
6403       * Remove a specified element from this YMap.
6404       *
6405       * @param {string} key The key of the element to remove.
6406       */
6407      delete(key) {
6408        if (this.doc !== null) {
6409          transact(this.doc, (transaction) => {
6410            typeMapDelete(transaction, this, key);
6411          });
6412        } else {
6413          this._prelimContent.delete(key);
6414        }
6415      }
6416      /**
6417       * Adds or updates an element with a specified key and value.
6418       * @template {MapType} VAL
6419       *
6420       * @param {string} key The key of the element to add to this YMap
6421       * @param {VAL} value The value of the element to add
6422       * @return {VAL}
6423       */
6424      set(key, value) {
6425        if (this.doc !== null) {
6426          transact(this.doc, (transaction) => {
6427            typeMapSet(
6428              transaction,
6429              this,
6430              key,
6431              /** @type {any} */
6432              value
6433            );
6434          });
6435        } else {
6436          this._prelimContent.set(key, value);
6437        }
6438        return value;
6439      }
6440      /**
6441       * Returns a specified element from this YMap.
6442       *
6443       * @param {string} key
6444       * @return {MapType|undefined}
6445       */
6446      get(key) {
6447        return (
6448          /** @type {any} */
6449          typeMapGet(this, key)
6450        );
6451      }
6452      /**
6453       * Returns a boolean indicating whether the specified key exists or not.
6454       *
6455       * @param {string} key The key to test.
6456       * @return {boolean}
6457       */
6458      has(key) {
6459        return typeMapHas(this, key);
6460      }
6461      /**
6462       * Removes all elements from this YMap.
6463       */
6464      clear() {
6465        if (this.doc !== null) {
6466          transact(this.doc, (transaction) => {
6467            this.forEach(function(_value, key, map2) {
6468              typeMapDelete(transaction, map2, key);
6469            });
6470          });
6471        } else {
6472          this._prelimContent.clear();
6473        }
6474      }
6475      /**
6476       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
6477       */
6478      _write(encoder) {
6479        encoder.writeTypeRef(YMapRefID);
6480      }
6481    };
6482    var readYMap = (_decoder) => new YMap();
6483    var equalAttrs = (a, b) => a === b || typeof a === "object" && typeof b === "object" && a && b && equalFlat(a, b);
6484    var ItemTextListPosition = class {
6485      /**
6486       * @param {Item|null} left
6487       * @param {Item|null} right
6488       * @param {number} index
6489       * @param {Map<string,any>} currentAttributes
6490       */
6491      constructor(left, right, index, currentAttributes) {
6492        this.left = left;
6493        this.right = right;
6494        this.index = index;
6495        this.currentAttributes = currentAttributes;
6496      }
6497      /**
6498       * Only call this if you know that this.right is defined
6499       */
6500      forward() {
6501        if (this.right === null) {
6502          unexpectedCase();
6503        }
6504        switch (this.right.content.constructor) {
6505          case ContentFormat:
6506            if (!this.right.deleted) {
6507              updateCurrentAttributes(
6508                this.currentAttributes,
6509                /** @type {ContentFormat} */
6510                this.right.content
6511              );
6512            }
6513            break;
6514          default:
6515            if (!this.right.deleted) {
6516              this.index += this.right.length;
6517            }
6518            break;
6519        }
6520        this.left = this.right;
6521        this.right = this.right.right;
6522      }
6523    };
6524    var findNextPosition = (transaction, pos, count) => {
6525      while (pos.right !== null && count > 0) {
6526        switch (pos.right.content.constructor) {
6527          case ContentFormat:
6528            if (!pos.right.deleted) {
6529              updateCurrentAttributes(
6530                pos.currentAttributes,
6531                /** @type {ContentFormat} */
6532                pos.right.content
6533              );
6534            }
6535            break;
6536          default:
6537            if (!pos.right.deleted) {
6538              if (count < pos.right.length) {
6539                getItemCleanStart(transaction, createID(pos.right.id.client, pos.right.id.clock + count));
6540              }
6541              pos.index += pos.right.length;
6542              count -= pos.right.length;
6543            }
6544            break;
6545        }
6546        pos.left = pos.right;
6547        pos.right = pos.right.right;
6548      }
6549      return pos;
6550    };
6551    var findPosition = (transaction, parent, index, useSearchMarker) => {
6552      const currentAttributes = /* @__PURE__ */ new Map();
6553      const marker = useSearchMarker ? findMarker(parent, index) : null;
6554      if (marker) {
6555        const pos = new ItemTextListPosition(marker.p.left, marker.p, marker.index, currentAttributes);
6556        return findNextPosition(transaction, pos, index - marker.index);
6557      } else {
6558        const pos = new ItemTextListPosition(null, parent._start, 0, currentAttributes);
6559        return findNextPosition(transaction, pos, index);
6560      }
6561    };
6562    var insertNegatedAttributes = (transaction, parent, currPos, negatedAttributes) => {
6563      while (currPos.right !== null && (currPos.right.deleted === true || currPos.right.content.constructor === ContentFormat && equalAttrs(
6564        negatedAttributes.get(
6565          /** @type {ContentFormat} */
6566          currPos.right.content.key
6567        ),
6568        /** @type {ContentFormat} */
6569        currPos.right.content.value
6570      ))) {
6571        if (!currPos.right.deleted) {
6572          negatedAttributes.delete(
6573            /** @type {ContentFormat} */
6574            currPos.right.content.key
6575          );
6576        }
6577        currPos.forward();
6578      }
6579      const doc2 = transaction.doc;
6580      const ownClientId = doc2.clientID;
6581      negatedAttributes.forEach((val, key) => {
6582        const left = currPos.left;
6583        const right = currPos.right;
6584        const nextFormat = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));
6585        nextFormat.integrate(transaction, 0);
6586        currPos.right = nextFormat;
6587        currPos.forward();
6588      });
6589    };
6590    var updateCurrentAttributes = (currentAttributes, format) => {
6591      const { key, value } = format;
6592      if (value === null) {
6593        currentAttributes.delete(key);
6594      } else {
6595        currentAttributes.set(key, value);
6596      }
6597    };
6598    var minimizeAttributeChanges = (currPos, attributes) => {
6599      while (true) {
6600        if (currPos.right === null) {
6601          break;
6602        } else if (currPos.right.deleted || currPos.right.content.constructor === ContentFormat && equalAttrs(
6603          attributes[
6604            /** @type {ContentFormat} */
6605            currPos.right.content.key
6606          ] ?? null,
6607          /** @type {ContentFormat} */
6608          currPos.right.content.value
6609        )) ;
6610        else {
6611          break;
6612        }
6613        currPos.forward();
6614      }
6615    };
6616    var insertAttributes = (transaction, parent, currPos, attributes) => {
6617      const doc2 = transaction.doc;
6618      const ownClientId = doc2.clientID;
6619      const negatedAttributes = /* @__PURE__ */ new Map();
6620      for (const key in attributes) {
6621        const val = attributes[key];
6622        const currentVal = currPos.currentAttributes.get(key) ?? null;
6623        if (!equalAttrs(currentVal, val)) {
6624          negatedAttributes.set(key, currentVal);
6625          const { left, right } = currPos;
6626          currPos.right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, new ContentFormat(key, val));
6627          currPos.right.integrate(transaction, 0);
6628          currPos.forward();
6629        }
6630      }
6631      return negatedAttributes;
6632    };
6633    var insertText = (transaction, parent, currPos, text2, attributes) => {
6634      currPos.currentAttributes.forEach((_val, key) => {
6635        if (attributes[key] === void 0) {
6636          attributes[key] = null;
6637        }
6638      });
6639      const doc2 = transaction.doc;
6640      const ownClientId = doc2.clientID;
6641      minimizeAttributeChanges(currPos, attributes);
6642      const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);
6643      const content = text2.constructor === String ? new ContentString(
6644        /** @type {string} */
6645        text2
6646      ) : text2 instanceof AbstractType ? new ContentType(text2) : new ContentEmbed(text2);
6647      let { left, right, index } = currPos;
6648      if (parent._searchMarker) {
6649        updateMarkerChanges(parent._searchMarker, currPos.index, content.getLength());
6650      }
6651      right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, content);
6652      right.integrate(transaction, 0);
6653      currPos.right = right;
6654      currPos.index = index;
6655      currPos.forward();
6656      insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);
6657    };
6658    var formatText = (transaction, parent, currPos, length2, attributes) => {
6659      const doc2 = transaction.doc;
6660      const ownClientId = doc2.clientID;
6661      minimizeAttributeChanges(currPos, attributes);
6662      const negatedAttributes = insertAttributes(transaction, parent, currPos, attributes);
6663      iterationLoop: while (currPos.right !== null && (length2 > 0 || negatedAttributes.size > 0 && (currPos.right.deleted || currPos.right.content.constructor === ContentFormat))) {
6664        if (!currPos.right.deleted) {
6665          switch (currPos.right.content.constructor) {
6666            case ContentFormat: {
6667              const { key, value } = (
6668                /** @type {ContentFormat} */
6669                currPos.right.content
6670              );
6671              const attr = attributes[key];
6672              if (attr !== void 0) {
6673                if (equalAttrs(attr, value)) {
6674                  negatedAttributes.delete(key);
6675                } else {
6676                  if (length2 === 0) {
6677                    break iterationLoop;
6678                  }
6679                  negatedAttributes.set(key, value);
6680                }
6681                currPos.right.delete(transaction);
6682              } else {
6683                currPos.currentAttributes.set(key, value);
6684              }
6685              break;
6686            }
6687            default:
6688              if (length2 < currPos.right.length) {
6689                getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length2));
6690              }
6691              length2 -= currPos.right.length;
6692              break;
6693          }
6694        }
6695        currPos.forward();
6696      }
6697      if (length2 > 0) {
6698        let newlines = "";
6699        for (; length2 > 0; length2--) {
6700          newlines += "\n";
6701        }
6702        currPos.right = new Item(createID(ownClientId, getState(doc2.store, ownClientId)), currPos.left, currPos.left && currPos.left.lastId, currPos.right, currPos.right && currPos.right.id, parent, null, new ContentString(newlines));
6703        currPos.right.integrate(transaction, 0);
6704        currPos.forward();
6705      }
6706      insertNegatedAttributes(transaction, parent, currPos, negatedAttributes);
6707    };
6708    var cleanupFormattingGap = (transaction, start, curr, startAttributes, currAttributes) => {
6709      let end = start;
6710      const endFormats = create();
6711      while (end && (!end.countable || end.deleted)) {
6712        if (!end.deleted && end.content.constructor === ContentFormat) {
6713          const cf = (
6714            /** @type {ContentFormat} */
6715            end.content
6716          );
6717          endFormats.set(cf.key, cf);
6718        }
6719        end = end.right;
6720      }
6721      let cleanups = 0;
6722      let reachedCurr = false;
6723      while (start !== end) {
6724        if (curr === start) {
6725          reachedCurr = true;
6726        }
6727        if (!start.deleted) {
6728          const content = start.content;
6729          switch (content.constructor) {
6730            case ContentFormat: {
6731              const { key, value } = (
6732                /** @type {ContentFormat} */
6733                content
6734              );
6735              const startAttrValue = startAttributes.get(key) ?? null;
6736              if (endFormats.get(key) !== content || startAttrValue === value) {
6737                start.delete(transaction);
6738                cleanups++;
6739                if (!reachedCurr && (currAttributes.get(key) ?? null) === value && startAttrValue !== value) {
6740                  if (startAttrValue === null) {
6741                    currAttributes.delete(key);
6742                  } else {
6743                    currAttributes.set(key, startAttrValue);
6744                  }
6745                }
6746              }
6747              if (!reachedCurr && !start.deleted) {
6748                updateCurrentAttributes(
6749                  currAttributes,
6750                  /** @type {ContentFormat} */
6751                  content
6752                );
6753              }
6754              break;
6755            }
6756          }
6757        }
6758        start = /** @type {Item} */
6759        start.right;
6760      }
6761      return cleanups;
6762    };
6763    var cleanupContextlessFormattingGap = (transaction, item) => {
6764      while (item && item.right && (item.right.deleted || !item.right.countable)) {
6765        item = item.right;
6766      }
6767      const attrs = /* @__PURE__ */ new Set();
6768      while (item && (item.deleted || !item.countable)) {
6769        if (!item.deleted && item.content.constructor === ContentFormat) {
6770          const key = (
6771            /** @type {ContentFormat} */
6772            item.content.key
6773          );
6774          if (attrs.has(key)) {
6775            item.delete(transaction);
6776          } else {
6777            attrs.add(key);
6778          }
6779        }
6780        item = item.left;
6781      }
6782    };
6783    var cleanupYTextFormatting = (type) => {
6784      let res = 0;
6785      transact(
6786        /** @type {Doc} */
6787        type.doc,
6788        (transaction) => {
6789          let start = (
6790            /** @type {Item} */
6791            type._start
6792          );
6793          let end = type._start;
6794          let startAttributes = create();
6795          const currentAttributes = copy(startAttributes);
6796          while (end) {
6797            if (end.deleted === false) {
6798              switch (end.content.constructor) {
6799                case ContentFormat:
6800                  updateCurrentAttributes(
6801                    currentAttributes,
6802                    /** @type {ContentFormat} */
6803                    end.content
6804                  );
6805                  break;
6806                default:
6807                  res += cleanupFormattingGap(transaction, start, end, startAttributes, currentAttributes);
6808                  startAttributes = copy(currentAttributes);
6809                  start = end;
6810                  break;
6811              }
6812            }
6813            end = end.right;
6814          }
6815        }
6816      );
6817      return res;
6818    };
6819    var cleanupYTextAfterTransaction = (transaction) => {
6820      const needFullCleanup = /* @__PURE__ */ new Set();
6821      const doc2 = transaction.doc;
6822      for (const [client, afterClock] of transaction.afterState.entries()) {
6823        const clock = transaction.beforeState.get(client) || 0;
6824        if (afterClock === clock) {
6825          continue;
6826        }
6827        iterateStructs(
6828          transaction,
6829          /** @type {Array<Item|GC>} */
6830          doc2.store.clients.get(client),
6831          clock,
6832          afterClock,
6833          (item) => {
6834            if (!item.deleted && /** @type {Item} */
6835            item.content.constructor === ContentFormat && item.constructor !== GC) {
6836              needFullCleanup.add(
6837                /** @type {any} */
6838                item.parent
6839              );
6840            }
6841          }
6842        );
6843      }
6844      transact(doc2, (t) => {
6845        iterateDeletedStructs(transaction, transaction.deleteSet, (item) => {
6846          if (item instanceof GC || !/** @type {YText} */
6847          item.parent._hasFormatting || needFullCleanup.has(
6848            /** @type {YText} */
6849            item.parent
6850          )) {
6851            return;
6852          }
6853          const parent = (
6854            /** @type {YText} */
6855            item.parent
6856          );
6857          if (item.content.constructor === ContentFormat) {
6858            needFullCleanup.add(parent);
6859          } else {
6860            cleanupContextlessFormattingGap(t, item);
6861          }
6862        });
6863        for (const yText of needFullCleanup) {
6864          cleanupYTextFormatting(yText);
6865        }
6866      });
6867    };
6868    var deleteText = (transaction, currPos, length2) => {
6869      const startLength = length2;
6870      const startAttrs = copy(currPos.currentAttributes);
6871      const start = currPos.right;
6872      while (length2 > 0 && currPos.right !== null) {
6873        if (currPos.right.deleted === false) {
6874          switch (currPos.right.content.constructor) {
6875            case ContentType:
6876            case ContentEmbed:
6877            case ContentString:
6878              if (length2 < currPos.right.length) {
6879                getItemCleanStart(transaction, createID(currPos.right.id.client, currPos.right.id.clock + length2));
6880              }
6881              length2 -= currPos.right.length;
6882              currPos.right.delete(transaction);
6883              break;
6884          }
6885        }
6886        currPos.forward();
6887      }
6888      if (start) {
6889        cleanupFormattingGap(transaction, start, currPos.right, startAttrs, currPos.currentAttributes);
6890      }
6891      const parent = (
6892        /** @type {AbstractType<any>} */
6893        /** @type {Item} */
6894        (currPos.left || currPos.right).parent
6895      );
6896      if (parent._searchMarker) {
6897        updateMarkerChanges(parent._searchMarker, currPos.index, -startLength + length2);
6898      }
6899      return currPos;
6900    };
6901    var YTextEvent = class extends YEvent {
6902      /**
6903       * @param {YText} ytext
6904       * @param {Transaction} transaction
6905       * @param {Set<any>} subs The keys that changed
6906       */
6907      constructor(ytext, transaction, subs) {
6908        super(ytext, transaction);
6909        this.childListChanged = false;
6910        this.keysChanged = /* @__PURE__ */ new Set();
6911        subs.forEach((sub) => {
6912          if (sub === null) {
6913            this.childListChanged = true;
6914          } else {
6915            this.keysChanged.add(sub);
6916          }
6917        });
6918      }
6919      /**
6920       * @type {{added:Set<Item>,deleted:Set<Item>,keys:Map<string,{action:'add'|'update'|'delete',oldValue:any}>,delta:Array<{insert?:Array<any>|string, delete?:number, retain?:number}>}}
6921       */
6922      get changes() {
6923        if (this._changes === null) {
6924          const changes = {
6925            keys: this.keys,
6926            delta: this.delta,
6927            added: /* @__PURE__ */ new Set(),
6928            deleted: /* @__PURE__ */ new Set()
6929          };
6930          this._changes = changes;
6931        }
6932        return (
6933          /** @type {any} */
6934          this._changes
6935        );
6936      }
6937      /**
6938       * Compute the changes in the delta format.
6939       * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
6940       *
6941       * @type {Array<{insert?:string|object|AbstractType<any>, delete?:number, retain?:number, attributes?: Object<string,any>}>}
6942       *
6943       * @public
6944       */
6945      get delta() {
6946        if (this._delta === null) {
6947          const y = (
6948            /** @type {Doc} */
6949            this.target.doc
6950          );
6951          const delta = [];
6952          transact(y, (transaction) => {
6953            const currentAttributes = /* @__PURE__ */ new Map();
6954            const oldAttributes = /* @__PURE__ */ new Map();
6955            let item = this.target._start;
6956            let action = null;
6957            const attributes = {};
6958            let insert = "";
6959            let retain = 0;
6960            let deleteLen = 0;
6961            const addOp = () => {
6962              if (action !== null) {
6963                let op = null;
6964                switch (action) {
6965                  case "delete":
6966                    if (deleteLen > 0) {
6967                      op = { delete: deleteLen };
6968                    }
6969                    deleteLen = 0;
6970                    break;
6971                  case "insert":
6972                    if (typeof insert === "object" || insert.length > 0) {
6973                      op = { insert };
6974                      if (currentAttributes.size > 0) {
6975                        op.attributes = {};
6976                        currentAttributes.forEach((value, key) => {
6977                          if (value !== null) {
6978                            op.attributes[key] = value;
6979                          }
6980                        });
6981                      }
6982                    }
6983                    insert = "";
6984                    break;
6985                  case "retain":
6986                    if (retain > 0) {
6987                      op = { retain };
6988                      if (!isEmpty(attributes)) {
6989                        op.attributes = assign({}, attributes);
6990                      }
6991                    }
6992                    retain = 0;
6993                    break;
6994                }
6995                if (op) delta.push(op);
6996                action = null;
6997              }
6998            };
6999            while (item !== null) {
7000              switch (item.content.constructor) {
7001                case ContentType:
7002                case ContentEmbed:
7003                  if (this.adds(item)) {
7004                    if (!this.deletes(item)) {
7005                      addOp();
7006                      action = "insert";
7007                      insert = item.content.getContent()[0];
7008                      addOp();
7009                    }
7010                  } else if (this.deletes(item)) {
7011                    if (action !== "delete") {
7012                      addOp();
7013                      action = "delete";
7014                    }
7015                    deleteLen += 1;
7016                  } else if (!item.deleted) {
7017                    if (action !== "retain") {
7018                      addOp();
7019                      action = "retain";
7020                    }
7021                    retain += 1;
7022                  }
7023                  break;
7024                case ContentString:
7025                  if (this.adds(item)) {
7026                    if (!this.deletes(item)) {
7027                      if (action !== "insert") {
7028                        addOp();
7029                        action = "insert";
7030                      }
7031                      insert += /** @type {ContentString} */
7032                      item.content.str;
7033                    }
7034                  } else if (this.deletes(item)) {
7035                    if (action !== "delete") {
7036                      addOp();
7037                      action = "delete";
7038                    }
7039                    deleteLen += item.length;
7040                  } else if (!item.deleted) {
7041                    if (action !== "retain") {
7042                      addOp();
7043                      action = "retain";
7044                    }
7045                    retain += item.length;
7046                  }
7047                  break;
7048                case ContentFormat: {
7049                  const { key, value } = (
7050                    /** @type {ContentFormat} */
7051                    item.content
7052                  );
7053                  if (this.adds(item)) {
7054                    if (!this.deletes(item)) {
7055                      const curVal = currentAttributes.get(key) ?? null;
7056                      if (!equalAttrs(curVal, value)) {
7057                        if (action === "retain") {
7058                          addOp();
7059                        }
7060                        if (equalAttrs(value, oldAttributes.get(key) ?? null)) {
7061                          delete attributes[key];
7062                        } else {
7063                          attributes[key] = value;
7064                        }
7065                      } else if (value !== null) {
7066                        item.delete(transaction);
7067                      }
7068                    }
7069                  } else if (this.deletes(item)) {
7070                    oldAttributes.set(key, value);
7071                    const curVal = currentAttributes.get(key) ?? null;
7072                    if (!equalAttrs(curVal, value)) {
7073                      if (action === "retain") {
7074                        addOp();
7075                      }
7076                      attributes[key] = curVal;
7077                    }
7078                  } else if (!item.deleted) {
7079                    oldAttributes.set(key, value);
7080                    const attr = attributes[key];
7081                    if (attr !== void 0) {
7082                      if (!equalAttrs(attr, value)) {
7083                        if (action === "retain") {
7084                          addOp();
7085                        }
7086                        if (value === null) {
7087                          delete attributes[key];
7088                        } else {
7089                          attributes[key] = value;
7090                        }
7091                      } else if (attr !== null) {
7092                        item.delete(transaction);
7093                      }
7094                    }
7095                  }
7096                  if (!item.deleted) {
7097                    if (action === "insert") {
7098                      addOp();
7099                    }
7100                    updateCurrentAttributes(
7101                      currentAttributes,
7102                      /** @type {ContentFormat} */
7103                      item.content
7104                    );
7105                  }
7106                  break;
7107                }
7108              }
7109              item = item.right;
7110            }
7111            addOp();
7112            while (delta.length > 0) {
7113              const lastOp = delta[delta.length - 1];
7114              if (lastOp.retain !== void 0 && lastOp.attributes === void 0) {
7115                delta.pop();
7116              } else {
7117                break;
7118              }
7119            }
7120          });
7121          this._delta = delta;
7122        }
7123        return (
7124          /** @type {any} */
7125          this._delta
7126        );
7127      }
7128    };
7129    var YText = class _YText extends AbstractType {
7130      /**
7131       * @param {String} [string] The initial value of the YText.
7132       */
7133      constructor(string) {
7134        super();
7135        this._pending = string !== void 0 ? [() => this.insert(0, string)] : [];
7136        this._searchMarker = [];
7137        this._hasFormatting = false;
7138      }
7139      /**
7140       * Number of characters of this text type.
7141       *
7142       * @type {number}
7143       */
7144      get length() {
7145        this.doc ?? warnPrematureAccess();
7146        return this._length;
7147      }
7148      /**
7149       * @param {Doc} y
7150       * @param {Item} item
7151       */
7152      _integrate(y, item) {
7153        super._integrate(y, item);
7154        try {
7155          this._pending.forEach((f) => f());
7156        } catch (e) {
7157          console.error(e);
7158        }
7159        this._pending = null;
7160      }
7161      _copy() {
7162        return new _YText();
7163      }
7164      /**
7165       * Makes a copy of this data type that can be included somewhere else.
7166       *
7167       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7168       *
7169       * @return {YText}
7170       */
7171      clone() {
7172        const text2 = new _YText();
7173        text2.applyDelta(this.toDelta());
7174        return text2;
7175      }
7176      /**
7177       * Creates YTextEvent and calls observers.
7178       *
7179       * @param {Transaction} transaction
7180       * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
7181       */
7182      _callObserver(transaction, parentSubs) {
7183        super._callObserver(transaction, parentSubs);
7184        const event = new YTextEvent(this, transaction, parentSubs);
7185        callTypeObservers(this, transaction, event);
7186        if (!transaction.local && this._hasFormatting) {
7187          transaction._needFormattingCleanup = true;
7188        }
7189      }
7190      /**
7191       * Returns the unformatted string representation of this YText type.
7192       *
7193       * @public
7194       */
7195      toString() {
7196        this.doc ?? warnPrematureAccess();
7197        let str = "";
7198        let n = this._start;
7199        while (n !== null) {
7200          if (!n.deleted && n.countable && n.content.constructor === ContentString) {
7201            str += /** @type {ContentString} */
7202            n.content.str;
7203          }
7204          n = n.right;
7205        }
7206        return str;
7207      }
7208      /**
7209       * Returns the unformatted string representation of this YText type.
7210       *
7211       * @return {string}
7212       * @public
7213       */
7214      toJSON() {
7215        return this.toString();
7216      }
7217      /**
7218       * Apply a {@link Delta} on this shared YText type.
7219       *
7220       * @param {Array<any>} delta The changes to apply on this element.
7221       * @param {object}  opts
7222       * @param {boolean} [opts.sanitize] Sanitize input delta. Removes ending newlines if set to true.
7223       *
7224       *
7225       * @public
7226       */
7227      applyDelta(delta, { sanitize = true } = {}) {
7228        if (this.doc !== null) {
7229          transact(this.doc, (transaction) => {
7230            const currPos = new ItemTextListPosition(null, this._start, 0, /* @__PURE__ */ new Map());
7231            for (let i = 0; i < delta.length; i++) {
7232              const op = delta[i];
7233              if (op.insert !== void 0) {
7234                const ins = !sanitize && typeof op.insert === "string" && i === delta.length - 1 && currPos.right === null && op.insert.slice(-1) === "\n" ? op.insert.slice(0, -1) : op.insert;
7235                if (typeof ins !== "string" || ins.length > 0) {
7236                  insertText(transaction, this, currPos, ins, op.attributes || {});
7237                }
7238              } else if (op.retain !== void 0) {
7239                formatText(transaction, this, currPos, op.retain, op.attributes || {});
7240              } else if (op.delete !== void 0) {
7241                deleteText(transaction, currPos, op.delete);
7242              }
7243            }
7244          });
7245        } else {
7246          this._pending.push(() => this.applyDelta(delta));
7247        }
7248      }
7249      /**
7250       * Returns the Delta representation of this YText type.
7251       *
7252       * @param {Snapshot} [snapshot]
7253       * @param {Snapshot} [prevSnapshot]
7254       * @param {function('removed' | 'added', ID):any} [computeYChange]
7255       * @return {any} The Delta representation of this type.
7256       *
7257       * @public
7258       */
7259      toDelta(snapshot2, prevSnapshot, computeYChange) {
7260        this.doc ?? warnPrematureAccess();
7261        const ops = [];
7262        const currentAttributes = /* @__PURE__ */ new Map();
7263        const doc2 = (
7264          /** @type {Doc} */
7265          this.doc
7266        );
7267        let str = "";
7268        let n = this._start;
7269        function packStr() {
7270          if (str.length > 0) {
7271            const attributes = {};
7272            let addAttributes = false;
7273            currentAttributes.forEach((value, key) => {
7274              addAttributes = true;
7275              attributes[key] = value;
7276            });
7277            const op = { insert: str };
7278            if (addAttributes) {
7279              op.attributes = attributes;
7280            }
7281            ops.push(op);
7282            str = "";
7283          }
7284        }
7285        const computeDelta = () => {
7286          while (n !== null) {
7287            if (isVisible(n, snapshot2) || prevSnapshot !== void 0 && isVisible(n, prevSnapshot)) {
7288              switch (n.content.constructor) {
7289                case ContentString: {
7290                  const cur = currentAttributes.get("ychange");
7291                  if (snapshot2 !== void 0 && !isVisible(n, snapshot2)) {
7292                    if (cur === void 0 || cur.user !== n.id.client || cur.type !== "removed") {
7293                      packStr();
7294                      currentAttributes.set("ychange", computeYChange ? computeYChange("removed", n.id) : { type: "removed" });
7295                    }
7296                  } else if (prevSnapshot !== void 0 && !isVisible(n, prevSnapshot)) {
7297                    if (cur === void 0 || cur.user !== n.id.client || cur.type !== "added") {
7298                      packStr();
7299                      currentAttributes.set("ychange", computeYChange ? computeYChange("added", n.id) : { type: "added" });
7300                    }
7301                  } else if (cur !== void 0) {
7302                    packStr();
7303                    currentAttributes.delete("ychange");
7304                  }
7305                  str += /** @type {ContentString} */
7306                  n.content.str;
7307                  break;
7308                }
7309                case ContentType:
7310                case ContentEmbed: {
7311                  packStr();
7312                  const op = {
7313                    insert: n.content.getContent()[0]
7314                  };
7315                  if (currentAttributes.size > 0) {
7316                    const attrs = (
7317                      /** @type {Object<string,any>} */
7318                      {}
7319                    );
7320                    op.attributes = attrs;
7321                    currentAttributes.forEach((value, key) => {
7322                      attrs[key] = value;
7323                    });
7324                  }
7325                  ops.push(op);
7326                  break;
7327                }
7328                case ContentFormat:
7329                  if (isVisible(n, snapshot2)) {
7330                    packStr();
7331                    updateCurrentAttributes(
7332                      currentAttributes,
7333                      /** @type {ContentFormat} */
7334                      n.content
7335                    );
7336                  }
7337                  break;
7338              }
7339            }
7340            n = n.right;
7341          }
7342          packStr();
7343        };
7344        if (snapshot2 || prevSnapshot) {
7345          transact(doc2, (transaction) => {
7346            if (snapshot2) {
7347              splitSnapshotAffectedStructs(transaction, snapshot2);
7348            }
7349            if (prevSnapshot) {
7350              splitSnapshotAffectedStructs(transaction, prevSnapshot);
7351            }
7352            computeDelta();
7353          }, "cleanup");
7354        } else {
7355          computeDelta();
7356        }
7357        return ops;
7358      }
7359      /**
7360       * Insert text at a given index.
7361       *
7362       * @param {number} index The index at which to start inserting.
7363       * @param {String} text The text to insert at the specified position.
7364       * @param {TextAttributes} [attributes] Optionally define some formatting
7365       *                                    information to apply on the inserted
7366       *                                    Text.
7367       * @public
7368       */
7369      insert(index, text2, attributes) {
7370        if (text2.length <= 0) {
7371          return;
7372        }
7373        const y = this.doc;
7374        if (y !== null) {
7375          transact(y, (transaction) => {
7376            const pos = findPosition(transaction, this, index, !attributes);
7377            if (!attributes) {
7378              attributes = {};
7379              pos.currentAttributes.forEach((v, k) => {
7380                attributes[k] = v;
7381              });
7382            }
7383            insertText(transaction, this, pos, text2, attributes);
7384          });
7385        } else {
7386          this._pending.push(() => this.insert(index, text2, attributes));
7387        }
7388      }
7389      /**
7390       * Inserts an embed at a index.
7391       *
7392       * @param {number} index The index to insert the embed at.
7393       * @param {Object | AbstractType<any>} embed The Object that represents the embed.
7394       * @param {TextAttributes} [attributes] Attribute information to apply on the
7395       *                                    embed
7396       *
7397       * @public
7398       */
7399      insertEmbed(index, embed, attributes) {
7400        const y = this.doc;
7401        if (y !== null) {
7402          transact(y, (transaction) => {
7403            const pos = findPosition(transaction, this, index, !attributes);
7404            insertText(transaction, this, pos, embed, attributes || {});
7405          });
7406        } else {
7407          this._pending.push(() => this.insertEmbed(index, embed, attributes || {}));
7408        }
7409      }
7410      /**
7411       * Deletes text starting from an index.
7412       *
7413       * @param {number} index Index at which to start deleting.
7414       * @param {number} length The number of characters to remove. Defaults to 1.
7415       *
7416       * @public
7417       */
7418      delete(index, length2) {
7419        if (length2 === 0) {
7420          return;
7421        }
7422        const y = this.doc;
7423        if (y !== null) {
7424          transact(y, (transaction) => {
7425            deleteText(transaction, findPosition(transaction, this, index, true), length2);
7426          });
7427        } else {
7428          this._pending.push(() => this.delete(index, length2));
7429        }
7430      }
7431      /**
7432       * Assigns properties to a range of text.
7433       *
7434       * @param {number} index The position where to start formatting.
7435       * @param {number} length The amount of characters to assign properties to.
7436       * @param {TextAttributes} attributes Attribute information to apply on the
7437       *                                    text.
7438       *
7439       * @public
7440       */
7441      format(index, length2, attributes) {
7442        if (length2 === 0) {
7443          return;
7444        }
7445        const y = this.doc;
7446        if (y !== null) {
7447          transact(y, (transaction) => {
7448            const pos = findPosition(transaction, this, index, false);
7449            if (pos.right === null) {
7450              return;
7451            }
7452            formatText(transaction, this, pos, length2, attributes);
7453          });
7454        } else {
7455          this._pending.push(() => this.format(index, length2, attributes));
7456        }
7457      }
7458      /**
7459       * Removes an attribute.
7460       *
7461       * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7462       *
7463       * @param {String} attributeName The attribute name that is to be removed.
7464       *
7465       * @public
7466       */
7467      removeAttribute(attributeName) {
7468        if (this.doc !== null) {
7469          transact(this.doc, (transaction) => {
7470            typeMapDelete(transaction, this, attributeName);
7471          });
7472        } else {
7473          this._pending.push(() => this.removeAttribute(attributeName));
7474        }
7475      }
7476      /**
7477       * Sets or updates an attribute.
7478       *
7479       * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7480       *
7481       * @param {String} attributeName The attribute name that is to be set.
7482       * @param {any} attributeValue The attribute value that is to be set.
7483       *
7484       * @public
7485       */
7486      setAttribute(attributeName, attributeValue) {
7487        if (this.doc !== null) {
7488          transact(this.doc, (transaction) => {
7489            typeMapSet(transaction, this, attributeName, attributeValue);
7490          });
7491        } else {
7492          this._pending.push(() => this.setAttribute(attributeName, attributeValue));
7493        }
7494      }
7495      /**
7496       * Returns an attribute value that belongs to the attribute name.
7497       *
7498       * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7499       *
7500       * @param {String} attributeName The attribute name that identifies the
7501       *                               queried value.
7502       * @return {any} The queried attribute value.
7503       *
7504       * @public
7505       */
7506      getAttribute(attributeName) {
7507        return (
7508          /** @type {any} */
7509          typeMapGet(this, attributeName)
7510        );
7511      }
7512      /**
7513       * Returns all attribute name/value pairs in a JSON Object.
7514       *
7515       * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
7516       *
7517       * @return {Object<string, any>} A JSON Object that describes the attributes.
7518       *
7519       * @public
7520       */
7521      getAttributes() {
7522        return typeMapGetAll(this);
7523      }
7524      /**
7525       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
7526       */
7527      _write(encoder) {
7528        encoder.writeTypeRef(YTextRefID);
7529      }
7530    };
7531    var readYText = (_decoder) => new YText();
7532    var YXmlTreeWalker = class {
7533      /**
7534       * @param {YXmlFragment | YXmlElement} root
7535       * @param {function(AbstractType<any>):boolean} [f]
7536       */
7537      constructor(root, f = () => true) {
7538        this._filter = f;
7539        this._root = root;
7540        this._currentNode = /** @type {Item} */
7541        root._start;
7542        this._firstCall = true;
7543        root.doc ?? warnPrematureAccess();
7544      }
7545      [Symbol.iterator]() {
7546        return this;
7547      }
7548      /**
7549       * Get the next node.
7550       *
7551       * @return {IteratorResult<YXmlElement|YXmlText|YXmlHook>} The next node.
7552       *
7553       * @public
7554       */
7555      next() {
7556        let n = this._currentNode;
7557        let type = n && n.content && /** @type {any} */
7558        n.content.type;
7559        if (n !== null && (!this._firstCall || n.deleted || !this._filter(type))) {
7560          do {
7561            type = /** @type {any} */
7562            n.content.type;
7563            if (!n.deleted && (type.constructor === YXmlElement || type.constructor === YXmlFragment) && type._start !== null) {
7564              n = type._start;
7565            } else {
7566              while (n !== null) {
7567                const nxt = n.next;
7568                if (nxt !== null) {
7569                  n = nxt;
7570                  break;
7571                } else if (n.parent === this._root) {
7572                  n = null;
7573                } else {
7574                  n = /** @type {AbstractType<any>} */
7575                  n.parent._item;
7576                }
7577              }
7578            }
7579          } while (n !== null && (n.deleted || !this._filter(
7580            /** @type {ContentType} */
7581            n.content.type
7582          )));
7583        }
7584        this._firstCall = false;
7585        if (n === null) {
7586          return { value: void 0, done: true };
7587        }
7588        this._currentNode = n;
7589        return { value: (
7590          /** @type {any} */
7591          n.content.type
7592        ), done: false };
7593      }
7594    };
7595    var YXmlFragment = class _YXmlFragment extends AbstractType {
7596      constructor() {
7597        super();
7598        this._prelimContent = [];
7599      }
7600      /**
7601       * @type {YXmlElement|YXmlText|null}
7602       */
7603      get firstChild() {
7604        const first = this._first;
7605        return first ? first.content.getContent()[0] : null;
7606      }
7607      /**
7608       * Integrate this type into the Yjs instance.
7609       *
7610       * * Save this struct in the os
7611       * * This type is sent to other client
7612       * * Observer functions are fired
7613       *
7614       * @param {Doc} y The Yjs instance
7615       * @param {Item} item
7616       */
7617      _integrate(y, item) {
7618        super._integrate(y, item);
7619        this.insert(
7620          0,
7621          /** @type {Array<any>} */
7622          this._prelimContent
7623        );
7624        this._prelimContent = null;
7625      }
7626      _copy() {
7627        return new _YXmlFragment();
7628      }
7629      /**
7630       * Makes a copy of this data type that can be included somewhere else.
7631       *
7632       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7633       *
7634       * @return {YXmlFragment}
7635       */
7636      clone() {
7637        const el = new _YXmlFragment();
7638        el.insert(0, this.toArray().map((item) => item instanceof AbstractType ? item.clone() : item));
7639        return el;
7640      }
7641      get length() {
7642        this.doc ?? warnPrematureAccess();
7643        return this._prelimContent === null ? this._length : this._prelimContent.length;
7644      }
7645      /**
7646       * Create a subtree of childNodes.
7647       *
7648       * @example
7649       * const walker = elem.createTreeWalker(dom => dom.nodeName === 'div')
7650       * for (let node in walker) {
7651       *   // `node` is a div node
7652       *   nop(node)
7653       * }
7654       *
7655       * @param {function(AbstractType<any>):boolean} filter Function that is called on each child element and
7656       *                          returns a Boolean indicating whether the child
7657       *                          is to be included in the subtree.
7658       * @return {YXmlTreeWalker} A subtree and a position within it.
7659       *
7660       * @public
7661       */
7662      createTreeWalker(filter) {
7663        return new YXmlTreeWalker(this, filter);
7664      }
7665      /**
7666       * Returns the first YXmlElement that matches the query.
7667       * Similar to DOM's {@link querySelector}.
7668       *
7669       * Query support:
7670       *   - tagname
7671       * TODO:
7672       *   - id
7673       *   - attribute
7674       *
7675       * @param {CSS_Selector} query The query on the children.
7676       * @return {YXmlElement|YXmlText|YXmlHook|null} The first element that matches the query or null.
7677       *
7678       * @public
7679       */
7680      querySelector(query) {
7681        query = query.toUpperCase();
7682        const iterator = new YXmlTreeWalker(this, (element2) => element2.nodeName && element2.nodeName.toUpperCase() === query);
7683        const next = iterator.next();
7684        if (next.done) {
7685          return null;
7686        } else {
7687          return next.value;
7688        }
7689      }
7690      /**
7691       * Returns all YXmlElements that match the query.
7692       * Similar to Dom's {@link querySelectorAll}.
7693       *
7694       * @todo Does not yet support all queries. Currently only query by tagName.
7695       *
7696       * @param {CSS_Selector} query The query on the children
7697       * @return {Array<YXmlElement|YXmlText|YXmlHook|null>} The elements that match this query.
7698       *
7699       * @public
7700       */
7701      querySelectorAll(query) {
7702        query = query.toUpperCase();
7703        return from(new YXmlTreeWalker(this, (element2) => element2.nodeName && element2.nodeName.toUpperCase() === query));
7704      }
7705      /**
7706       * Creates YXmlEvent and calls observers.
7707       *
7708       * @param {Transaction} transaction
7709       * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
7710       */
7711      _callObserver(transaction, parentSubs) {
7712        callTypeObservers(this, transaction, new YXmlEvent(this, parentSubs, transaction));
7713      }
7714      /**
7715       * Get the string representation of all the children of this YXmlFragment.
7716       *
7717       * @return {string} The string representation of all children.
7718       */
7719      toString() {
7720        return typeListMap(this, (xml) => xml.toString()).join("");
7721      }
7722      /**
7723       * @return {string}
7724       */
7725      toJSON() {
7726        return this.toString();
7727      }
7728      /**
7729       * Creates a Dom Element that mirrors this YXmlElement.
7730       *
7731       * @param {Document} [_document=document] The document object (you must define
7732       *                                        this when calling this method in
7733       *                                        nodejs)
7734       * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
7735       *                                             are presented in the DOM
7736       * @param {any} [binding] You should not set this property. This is
7737       *                               used if DomBinding wants to create a
7738       *                               association to the created DOM type.
7739       * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
7740       *
7741       * @public
7742       */
7743      toDOM(_document = document, hooks = {}, binding) {
7744        const fragment = _document.createDocumentFragment();
7745        if (binding !== void 0) {
7746          binding._createAssociation(fragment, this);
7747        }
7748        typeListForEach(this, (xmlType) => {
7749          fragment.insertBefore(xmlType.toDOM(_document, hooks, binding), null);
7750        });
7751        return fragment;
7752      }
7753      /**
7754       * Inserts new content at an index.
7755       *
7756       * @example
7757       *  // Insert character 'a' at position 0
7758       *  xml.insert(0, [new Y.XmlText('text')])
7759       *
7760       * @param {number} index The index to insert content at
7761       * @param {Array<YXmlElement|YXmlText>} content The array of content
7762       */
7763      insert(index, content) {
7764        if (this.doc !== null) {
7765          transact(this.doc, (transaction) => {
7766            typeListInsertGenerics(transaction, this, index, content);
7767          });
7768        } else {
7769          this._prelimContent.splice(index, 0, ...content);
7770        }
7771      }
7772      /**
7773       * Inserts new content at an index.
7774       *
7775       * @example
7776       *  // Insert character 'a' at position 0
7777       *  xml.insert(0, [new Y.XmlText('text')])
7778       *
7779       * @param {null|Item|YXmlElement|YXmlText} ref The index to insert content at
7780       * @param {Array<YXmlElement|YXmlText>} content The array of content
7781       */
7782      insertAfter(ref, content) {
7783        if (this.doc !== null) {
7784          transact(this.doc, (transaction) => {
7785            const refItem = ref && ref instanceof AbstractType ? ref._item : ref;
7786            typeListInsertGenericsAfter(transaction, this, refItem, content);
7787          });
7788        } else {
7789          const pc = (
7790            /** @type {Array<any>} */
7791            this._prelimContent
7792          );
7793          const index = ref === null ? 0 : pc.findIndex((el) => el === ref) + 1;
7794          if (index === 0 && ref !== null) {
7795            throw create3("Reference item not found");
7796          }
7797          pc.splice(index, 0, ...content);
7798        }
7799      }
7800      /**
7801       * Deletes elements starting from an index.
7802       *
7803       * @param {number} index Index at which to start deleting elements
7804       * @param {number} [length=1] The number of elements to remove. Defaults to 1.
7805       */
7806      delete(index, length2 = 1) {
7807        if (this.doc !== null) {
7808          transact(this.doc, (transaction) => {
7809            typeListDelete(transaction, this, index, length2);
7810          });
7811        } else {
7812          this._prelimContent.splice(index, length2);
7813        }
7814      }
7815      /**
7816       * Transforms this YArray to a JavaScript Array.
7817       *
7818       * @return {Array<YXmlElement|YXmlText|YXmlHook>}
7819       */
7820      toArray() {
7821        return typeListToArray(this);
7822      }
7823      /**
7824       * Appends content to this YArray.
7825       *
7826       * @param {Array<YXmlElement|YXmlText>} content Array of content to append.
7827       */
7828      push(content) {
7829        this.insert(this.length, content);
7830      }
7831      /**
7832       * Prepends content to this YArray.
7833       *
7834       * @param {Array<YXmlElement|YXmlText>} content Array of content to prepend.
7835       */
7836      unshift(content) {
7837        this.insert(0, content);
7838      }
7839      /**
7840       * Returns the i-th element from a YArray.
7841       *
7842       * @param {number} index The index of the element to return from the YArray
7843       * @return {YXmlElement|YXmlText}
7844       */
7845      get(index) {
7846        return typeListGet(this, index);
7847      }
7848      /**
7849       * Returns a portion of this YXmlFragment into a JavaScript Array selected
7850       * from start to end (end not included).
7851       *
7852       * @param {number} [start]
7853       * @param {number} [end]
7854       * @return {Array<YXmlElement|YXmlText>}
7855       */
7856      slice(start = 0, end = this.length) {
7857        return typeListSlice(this, start, end);
7858      }
7859      /**
7860       * Executes a provided function on once on every child element.
7861       *
7862       * @param {function(YXmlElement|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.
7863       */
7864      forEach(f) {
7865        typeListForEach(this, f);
7866      }
7867      /**
7868       * Transform the properties of this type to binary and write it to an
7869       * BinaryEncoder.
7870       *
7871       * This is called when this Item is sent to a remote peer.
7872       *
7873       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
7874       */
7875      _write(encoder) {
7876        encoder.writeTypeRef(YXmlFragmentRefID);
7877      }
7878    };
7879    var readYXmlFragment = (_decoder) => new YXmlFragment();
7880    var YXmlElement = class _YXmlElement extends YXmlFragment {
7881      constructor(nodeName = "UNDEFINED") {
7882        super();
7883        this.nodeName = nodeName;
7884        this._prelimAttrs = /* @__PURE__ */ new Map();
7885      }
7886      /**
7887       * @type {YXmlElement|YXmlText|null}
7888       */
7889      get nextSibling() {
7890        const n = this._item ? this._item.next : null;
7891        return n ? (
7892          /** @type {YXmlElement|YXmlText} */
7893          /** @type {ContentType} */
7894          n.content.type
7895        ) : null;
7896      }
7897      /**
7898       * @type {YXmlElement|YXmlText|null}
7899       */
7900      get prevSibling() {
7901        const n = this._item ? this._item.prev : null;
7902        return n ? (
7903          /** @type {YXmlElement|YXmlText} */
7904          /** @type {ContentType} */
7905          n.content.type
7906        ) : null;
7907      }
7908      /**
7909       * Integrate this type into the Yjs instance.
7910       *
7911       * * Save this struct in the os
7912       * * This type is sent to other client
7913       * * Observer functions are fired
7914       *
7915       * @param {Doc} y The Yjs instance
7916       * @param {Item} item
7917       */
7918      _integrate(y, item) {
7919        super._integrate(y, item);
7920        /** @type {Map<string, any>} */
7921        this._prelimAttrs.forEach((value, key) => {
7922          this.setAttribute(key, value);
7923        });
7924        this._prelimAttrs = null;
7925      }
7926      /**
7927       * Creates an Item with the same effect as this Item (without position effect)
7928       *
7929       * @return {YXmlElement}
7930       */
7931      _copy() {
7932        return new _YXmlElement(this.nodeName);
7933      }
7934      /**
7935       * Makes a copy of this data type that can be included somewhere else.
7936       *
7937       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
7938       *
7939       * @return {YXmlElement<KV>}
7940       */
7941      clone() {
7942        const el = new _YXmlElement(this.nodeName);
7943        const attrs = this.getAttributes();
7944        forEach(attrs, (value, key) => {
7945          el.setAttribute(
7946            key,
7947            /** @type {any} */
7948            value
7949          );
7950        });
7951        el.insert(0, this.toArray().map((v) => v instanceof AbstractType ? v.clone() : v));
7952        return el;
7953      }
7954      /**
7955       * Returns the XML serialization of this YXmlElement.
7956       * The attributes are ordered by attribute-name, so you can easily use this
7957       * method to compare YXmlElements
7958       *
7959       * @return {string} The string representation of this type.
7960       *
7961       * @public
7962       */
7963      toString() {
7964        const attrs = this.getAttributes();
7965        const stringBuilder = [];
7966        const keys2 = [];
7967        for (const key in attrs) {
7968          keys2.push(key);
7969        }
7970        keys2.sort();
7971        const keysLen = keys2.length;
7972        for (let i = 0; i < keysLen; i++) {
7973          const key = keys2[i];
7974          stringBuilder.push(key + '="' + attrs[key] + '"');
7975        }
7976        const nodeName = this.nodeName.toLocaleLowerCase();
7977        const attrsString = stringBuilder.length > 0 ? " " + stringBuilder.join(" ") : "";
7978        return `<$nodeName}$attrsString}>$super.toString()}</$nodeName}>`;
7979      }
7980      /**
7981       * Removes an attribute from this YXmlElement.
7982       *
7983       * @param {string} attributeName The attribute name that is to be removed.
7984       *
7985       * @public
7986       */
7987      removeAttribute(attributeName) {
7988        if (this.doc !== null) {
7989          transact(this.doc, (transaction) => {
7990            typeMapDelete(transaction, this, attributeName);
7991          });
7992        } else {
7993          this._prelimAttrs.delete(attributeName);
7994        }
7995      }
7996      /**
7997       * Sets or updates an attribute.
7998       *
7999       * @template {keyof KV & string} KEY
8000       *
8001       * @param {KEY} attributeName The attribute name that is to be set.
8002       * @param {KV[KEY]} attributeValue The attribute value that is to be set.
8003       *
8004       * @public
8005       */
8006      setAttribute(attributeName, attributeValue) {
8007        if (this.doc !== null) {
8008          transact(this.doc, (transaction) => {
8009            typeMapSet(transaction, this, attributeName, attributeValue);
8010          });
8011        } else {
8012          this._prelimAttrs.set(attributeName, attributeValue);
8013        }
8014      }
8015      /**
8016       * Returns an attribute value that belongs to the attribute name.
8017       *
8018       * @template {keyof KV & string} KEY
8019       *
8020       * @param {KEY} attributeName The attribute name that identifies the
8021       *                               queried value.
8022       * @return {KV[KEY]|undefined} The queried attribute value.
8023       *
8024       * @public
8025       */
8026      getAttribute(attributeName) {
8027        return (
8028          /** @type {any} */
8029          typeMapGet(this, attributeName)
8030        );
8031      }
8032      /**
8033       * Returns whether an attribute exists
8034       *
8035       * @param {string} attributeName The attribute name to check for existence.
8036       * @return {boolean} whether the attribute exists.
8037       *
8038       * @public
8039       */
8040      hasAttribute(attributeName) {
8041        return (
8042          /** @type {any} */
8043          typeMapHas(this, attributeName)
8044        );
8045      }
8046      /**
8047       * Returns all attribute name/value pairs in a JSON Object.
8048       *
8049       * @param {Snapshot} [snapshot]
8050       * @return {{ [Key in Extract<keyof KV,string>]?: KV[Key]}} A JSON Object that describes the attributes.
8051       *
8052       * @public
8053       */
8054      getAttributes(snapshot2) {
8055        return (
8056          /** @type {any} */
8057          snapshot2 ? typeMapGetAllSnapshot(this, snapshot2) : typeMapGetAll(this)
8058        );
8059      }
8060      /**
8061       * Creates a Dom Element that mirrors this YXmlElement.
8062       *
8063       * @param {Document} [_document=document] The document object (you must define
8064       *                                        this when calling this method in
8065       *                                        nodejs)
8066       * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
8067       *                                             are presented in the DOM
8068       * @param {any} [binding] You should not set this property. This is
8069       *                               used if DomBinding wants to create a
8070       *                               association to the created DOM type.
8071       * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
8072       *
8073       * @public
8074       */
8075      toDOM(_document = document, hooks = {}, binding) {
8076        const dom = _document.createElement(this.nodeName);
8077        const attrs = this.getAttributes();
8078        for (const key in attrs) {
8079          const value = attrs[key];
8080          if (typeof value === "string") {
8081            dom.setAttribute(key, value);
8082          }
8083        }
8084        typeListForEach(this, (yxml) => {
8085          dom.appendChild(yxml.toDOM(_document, hooks, binding));
8086        });
8087        if (binding !== void 0) {
8088          binding._createAssociation(dom, this);
8089        }
8090        return dom;
8091      }
8092      /**
8093       * Transform the properties of this type to binary and write it to an
8094       * BinaryEncoder.
8095       *
8096       * This is called when this Item is sent to a remote peer.
8097       *
8098       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
8099       */
8100      _write(encoder) {
8101        encoder.writeTypeRef(YXmlElementRefID);
8102        encoder.writeKey(this.nodeName);
8103      }
8104    };
8105    var readYXmlElement = (decoder) => new YXmlElement(decoder.readKey());
8106    var YXmlEvent = class extends YEvent {
8107      /**
8108       * @param {YXmlElement|YXmlText|YXmlFragment} target The target on which the event is created.
8109       * @param {Set<string|null>} subs The set of changed attributes. `null` is included if the
8110       *                   child list changed.
8111       * @param {Transaction} transaction The transaction instance with which the
8112       *                                  change was created.
8113       */
8114      constructor(target, subs, transaction) {
8115        super(target, transaction);
8116        this.childListChanged = false;
8117        this.attributesChanged = /* @__PURE__ */ new Set();
8118        subs.forEach((sub) => {
8119          if (sub === null) {
8120            this.childListChanged = true;
8121          } else {
8122            this.attributesChanged.add(sub);
8123          }
8124        });
8125      }
8126    };
8127    var YXmlHook = class _YXmlHook extends YMap {
8128      /**
8129       * @param {string} hookName nodeName of the Dom Node.
8130       */
8131      constructor(hookName) {
8132        super();
8133        this.hookName = hookName;
8134      }
8135      /**
8136       * Creates an Item with the same effect as this Item (without position effect)
8137       */
8138      _copy() {
8139        return new _YXmlHook(this.hookName);
8140      }
8141      /**
8142       * Makes a copy of this data type that can be included somewhere else.
8143       *
8144       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
8145       *
8146       * @return {YXmlHook}
8147       */
8148      clone() {
8149        const el = new _YXmlHook(this.hookName);
8150        this.forEach((value, key) => {
8151          el.set(key, value);
8152        });
8153        return el;
8154      }
8155      /**
8156       * Creates a Dom Element that mirrors this YXmlElement.
8157       *
8158       * @param {Document} [_document=document] The document object (you must define
8159       *                                        this when calling this method in
8160       *                                        nodejs)
8161       * @param {Object.<string, any>} [hooks] Optional property to customize how hooks
8162       *                                             are presented in the DOM
8163       * @param {any} [binding] You should not set this property. This is
8164       *                               used if DomBinding wants to create a
8165       *                               association to the created DOM type
8166       * @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
8167       *
8168       * @public
8169       */
8170      toDOM(_document = document, hooks = {}, binding) {
8171        const hook = hooks[this.hookName];
8172        let dom;
8173        if (hook !== void 0) {
8174          dom = hook.createDom(this);
8175        } else {
8176          dom = document.createElement(this.hookName);
8177        }
8178        dom.setAttribute("data-yjs-hook", this.hookName);
8179        if (binding !== void 0) {
8180          binding._createAssociation(dom, this);
8181        }
8182        return dom;
8183      }
8184      /**
8185       * Transform the properties of this type to binary and write it to an
8186       * BinaryEncoder.
8187       *
8188       * This is called when this Item is sent to a remote peer.
8189       *
8190       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
8191       */
8192      _write(encoder) {
8193        encoder.writeTypeRef(YXmlHookRefID);
8194        encoder.writeKey(this.hookName);
8195      }
8196    };
8197    var readYXmlHook = (decoder) => new YXmlHook(decoder.readKey());
8198    var YXmlText = class _YXmlText extends YText {
8199      /**
8200       * @type {YXmlElement|YXmlText|null}
8201       */
8202      get nextSibling() {
8203        const n = this._item ? this._item.next : null;
8204        return n ? (
8205          /** @type {YXmlElement|YXmlText} */
8206          /** @type {ContentType} */
8207          n.content.type
8208        ) : null;
8209      }
8210      /**
8211       * @type {YXmlElement|YXmlText|null}
8212       */
8213      get prevSibling() {
8214        const n = this._item ? this._item.prev : null;
8215        return n ? (
8216          /** @type {YXmlElement|YXmlText} */
8217          /** @type {ContentType} */
8218          n.content.type
8219        ) : null;
8220      }
8221      _copy() {
8222        return new _YXmlText();
8223      }
8224      /**
8225       * Makes a copy of this data type that can be included somewhere else.
8226       *
8227       * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
8228       *
8229       * @return {YXmlText}
8230       */
8231      clone() {
8232        const text2 = new _YXmlText();
8233        text2.applyDelta(this.toDelta());
8234        return text2;
8235      }
8236      /**
8237       * Creates a Dom Element that mirrors this YXmlText.
8238       *
8239       * @param {Document} [_document=document] The document object (you must define
8240       *                                        this when calling this method in
8241       *                                        nodejs)
8242       * @param {Object<string, any>} [hooks] Optional property to customize how hooks
8243       *                                             are presented in the DOM
8244       * @param {any} [binding] You should not set this property. This is
8245       *                               used if DomBinding wants to create a
8246       *                               association to the created DOM type.
8247       * @return {Text} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
8248       *
8249       * @public
8250       */
8251      toDOM(_document = document, hooks, binding) {
8252        const dom = _document.createTextNode(this.toString());
8253        if (binding !== void 0) {
8254          binding._createAssociation(dom, this);
8255        }
8256        return dom;
8257      }
8258      toString() {
8259        return this.toDelta().map((delta) => {
8260          const nestedNodes = [];
8261          for (const nodeName in delta.attributes) {
8262            const attrs = [];
8263            for (const key in delta.attributes[nodeName]) {
8264              attrs.push({ key, value: delta.attributes[nodeName][key] });
8265            }
8266            attrs.sort((a, b) => a.key < b.key ? -1 : 1);
8267            nestedNodes.push({ nodeName, attrs });
8268          }
8269          nestedNodes.sort((a, b) => a.nodeName < b.nodeName ? -1 : 1);
8270          let str = "";
8271          for (let i = 0; i < nestedNodes.length; i++) {
8272            const node = nestedNodes[i];
8273            str += `<$node.nodeName}`;
8274            for (let j = 0; j < node.attrs.length; j++) {
8275              const attr = node.attrs[j];
8276              str += ` $attr.key}="$attr.value}"`;
8277            }
8278            str += ">";
8279          }
8280          str += delta.insert;
8281          for (let i = nestedNodes.length - 1; i >= 0; i--) {
8282            str += `</$nestedNodes[i].nodeName}>`;
8283          }
8284          return str;
8285        }).join("");
8286      }
8287      /**
8288       * @return {string}
8289       */
8290      toJSON() {
8291        return this.toString();
8292      }
8293      /**
8294       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8295       */
8296      _write(encoder) {
8297        encoder.writeTypeRef(YXmlTextRefID);
8298      }
8299    };
8300    var readYXmlText = (decoder) => new YXmlText();
8301    var AbstractStruct = class {
8302      /**
8303       * @param {ID} id
8304       * @param {number} length
8305       */
8306      constructor(id2, length2) {
8307        this.id = id2;
8308        this.length = length2;
8309      }
8310      /**
8311       * @type {boolean}
8312       */
8313      get deleted() {
8314        throw methodUnimplemented();
8315      }
8316      /**
8317       * Merge this struct with the item to the right.
8318       * This method is already assuming that `this.id.clock + this.length === this.id.clock`.
8319       * Also this method does *not* remove right from StructStore!
8320       * @param {AbstractStruct} right
8321       * @return {boolean} whether this merged with right
8322       */
8323      mergeWith(right) {
8324        return false;
8325      }
8326      /**
8327       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
8328       * @param {number} offset
8329       * @param {number} encodingRef
8330       */
8331      write(encoder, offset, encodingRef) {
8332        throw methodUnimplemented();
8333      }
8334      /**
8335       * @param {Transaction} transaction
8336       * @param {number} offset
8337       */
8338      integrate(transaction, offset) {
8339        throw methodUnimplemented();
8340      }
8341    };
8342    var structGCRefNumber = 0;
8343    var GC = class extends AbstractStruct {
8344      get deleted() {
8345        return true;
8346      }
8347      delete() {
8348      }
8349      /**
8350       * @param {GC} right
8351       * @return {boolean}
8352       */
8353      mergeWith(right) {
8354        if (this.constructor !== right.constructor) {
8355          return false;
8356        }
8357        this.length += right.length;
8358        return true;
8359      }
8360      /**
8361       * @param {Transaction} transaction
8362       * @param {number} offset
8363       */
8364      integrate(transaction, offset) {
8365        if (offset > 0) {
8366          this.id.clock += offset;
8367          this.length -= offset;
8368        }
8369        addStruct(transaction.doc.store, this);
8370      }
8371      /**
8372       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8373       * @param {number} offset
8374       */
8375      write(encoder, offset) {
8376        encoder.writeInfo(structGCRefNumber);
8377        encoder.writeLen(this.length - offset);
8378      }
8379      /**
8380       * @param {Transaction} transaction
8381       * @param {StructStore} store
8382       * @return {null | number}
8383       */
8384      getMissing(transaction, store) {
8385        return null;
8386      }
8387    };
8388    var ContentBinary = class _ContentBinary {
8389      /**
8390       * @param {Uint8Array} content
8391       */
8392      constructor(content) {
8393        this.content = content;
8394      }
8395      /**
8396       * @return {number}
8397       */
8398      getLength() {
8399        return 1;
8400      }
8401      /**
8402       * @return {Array<any>}
8403       */
8404      getContent() {
8405        return [this.content];
8406      }
8407      /**
8408       * @return {boolean}
8409       */
8410      isCountable() {
8411        return true;
8412      }
8413      /**
8414       * @return {ContentBinary}
8415       */
8416      copy() {
8417        return new _ContentBinary(this.content);
8418      }
8419      /**
8420       * @param {number} offset
8421       * @return {ContentBinary}
8422       */
8423      splice(offset) {
8424        throw methodUnimplemented();
8425      }
8426      /**
8427       * @param {ContentBinary} right
8428       * @return {boolean}
8429       */
8430      mergeWith(right) {
8431        return false;
8432      }
8433      /**
8434       * @param {Transaction} transaction
8435       * @param {Item} item
8436       */
8437      integrate(transaction, item) {
8438      }
8439      /**
8440       * @param {Transaction} transaction
8441       */
8442      delete(transaction) {
8443      }
8444      /**
8445       * @param {StructStore} store
8446       */
8447      gc(store) {
8448      }
8449      /**
8450       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8451       * @param {number} offset
8452       */
8453      write(encoder, offset) {
8454        encoder.writeBuf(this.content);
8455      }
8456      /**
8457       * @return {number}
8458       */
8459      getRef() {
8460        return 3;
8461      }
8462    };
8463    var readContentBinary = (decoder) => new ContentBinary(decoder.readBuf());
8464    var ContentDeleted = class _ContentDeleted {
8465      /**
8466       * @param {number} len
8467       */
8468      constructor(len) {
8469        this.len = len;
8470      }
8471      /**
8472       * @return {number}
8473       */
8474      getLength() {
8475        return this.len;
8476      }
8477      /**
8478       * @return {Array<any>}
8479       */
8480      getContent() {
8481        return [];
8482      }
8483      /**
8484       * @return {boolean}
8485       */
8486      isCountable() {
8487        return false;
8488      }
8489      /**
8490       * @return {ContentDeleted}
8491       */
8492      copy() {
8493        return new _ContentDeleted(this.len);
8494      }
8495      /**
8496       * @param {number} offset
8497       * @return {ContentDeleted}
8498       */
8499      splice(offset) {
8500        const right = new _ContentDeleted(this.len - offset);
8501        this.len = offset;
8502        return right;
8503      }
8504      /**
8505       * @param {ContentDeleted} right
8506       * @return {boolean}
8507       */
8508      mergeWith(right) {
8509        this.len += right.len;
8510        return true;
8511      }
8512      /**
8513       * @param {Transaction} transaction
8514       * @param {Item} item
8515       */
8516      integrate(transaction, item) {
8517        addToDeleteSet(transaction.deleteSet, item.id.client, item.id.clock, this.len);
8518        item.markDeleted();
8519      }
8520      /**
8521       * @param {Transaction} transaction
8522       */
8523      delete(transaction) {
8524      }
8525      /**
8526       * @param {StructStore} store
8527       */
8528      gc(store) {
8529      }
8530      /**
8531       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8532       * @param {number} offset
8533       */
8534      write(encoder, offset) {
8535        encoder.writeLen(this.len - offset);
8536      }
8537      /**
8538       * @return {number}
8539       */
8540      getRef() {
8541        return 1;
8542      }
8543    };
8544    var readContentDeleted = (decoder) => new ContentDeleted(decoder.readLen());
8545    var createDocFromOpts = (guid, opts) => new Doc({ guid, ...opts, shouldLoad: opts.shouldLoad || opts.autoLoad || false });
8546    var ContentDoc = class _ContentDoc {
8547      /**
8548       * @param {Doc} doc
8549       */
8550      constructor(doc2) {
8551        if (doc2._item) {
8552          console.error("This document was already integrated as a sub-document. You should create a second instance instead with the same guid.");
8553        }
8554        this.doc = doc2;
8555        const opts = {};
8556        this.opts = opts;
8557        if (!doc2.gc) {
8558          opts.gc = false;
8559        }
8560        if (doc2.autoLoad) {
8561          opts.autoLoad = true;
8562        }
8563        if (doc2.meta !== null) {
8564          opts.meta = doc2.meta;
8565        }
8566      }
8567      /**
8568       * @return {number}
8569       */
8570      getLength() {
8571        return 1;
8572      }
8573      /**
8574       * @return {Array<any>}
8575       */
8576      getContent() {
8577        return [this.doc];
8578      }
8579      /**
8580       * @return {boolean}
8581       */
8582      isCountable() {
8583        return true;
8584      }
8585      /**
8586       * @return {ContentDoc}
8587       */
8588      copy() {
8589        return new _ContentDoc(createDocFromOpts(this.doc.guid, this.opts));
8590      }
8591      /**
8592       * @param {number} offset
8593       * @return {ContentDoc}
8594       */
8595      splice(offset) {
8596        throw methodUnimplemented();
8597      }
8598      /**
8599       * @param {ContentDoc} right
8600       * @return {boolean}
8601       */
8602      mergeWith(right) {
8603        return false;
8604      }
8605      /**
8606       * @param {Transaction} transaction
8607       * @param {Item} item
8608       */
8609      integrate(transaction, item) {
8610        this.doc._item = item;
8611        transaction.subdocsAdded.add(this.doc);
8612        if (this.doc.shouldLoad) {
8613          transaction.subdocsLoaded.add(this.doc);
8614        }
8615      }
8616      /**
8617       * @param {Transaction} transaction
8618       */
8619      delete(transaction) {
8620        if (transaction.subdocsAdded.has(this.doc)) {
8621          transaction.subdocsAdded.delete(this.doc);
8622        } else {
8623          transaction.subdocsRemoved.add(this.doc);
8624        }
8625      }
8626      /**
8627       * @param {StructStore} store
8628       */
8629      gc(store) {
8630      }
8631      /**
8632       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8633       * @param {number} offset
8634       */
8635      write(encoder, offset) {
8636        encoder.writeString(this.doc.guid);
8637        encoder.writeAny(this.opts);
8638      }
8639      /**
8640       * @return {number}
8641       */
8642      getRef() {
8643        return 9;
8644      }
8645    };
8646    var readContentDoc = (decoder) => new ContentDoc(createDocFromOpts(decoder.readString(), decoder.readAny()));
8647    var ContentEmbed = class _ContentEmbed {
8648      /**
8649       * @param {Object} embed
8650       */
8651      constructor(embed) {
8652        this.embed = embed;
8653      }
8654      /**
8655       * @return {number}
8656       */
8657      getLength() {
8658        return 1;
8659      }
8660      /**
8661       * @return {Array<any>}
8662       */
8663      getContent() {
8664        return [this.embed];
8665      }
8666      /**
8667       * @return {boolean}
8668       */
8669      isCountable() {
8670        return true;
8671      }
8672      /**
8673       * @return {ContentEmbed}
8674       */
8675      copy() {
8676        return new _ContentEmbed(this.embed);
8677      }
8678      /**
8679       * @param {number} offset
8680       * @return {ContentEmbed}
8681       */
8682      splice(offset) {
8683        throw methodUnimplemented();
8684      }
8685      /**
8686       * @param {ContentEmbed} right
8687       * @return {boolean}
8688       */
8689      mergeWith(right) {
8690        return false;
8691      }
8692      /**
8693       * @param {Transaction} transaction
8694       * @param {Item} item
8695       */
8696      integrate(transaction, item) {
8697      }
8698      /**
8699       * @param {Transaction} transaction
8700       */
8701      delete(transaction) {
8702      }
8703      /**
8704       * @param {StructStore} store
8705       */
8706      gc(store) {
8707      }
8708      /**
8709       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8710       * @param {number} offset
8711       */
8712      write(encoder, offset) {
8713        encoder.writeJSON(this.embed);
8714      }
8715      /**
8716       * @return {number}
8717       */
8718      getRef() {
8719        return 5;
8720      }
8721    };
8722    var readContentEmbed = (decoder) => new ContentEmbed(decoder.readJSON());
8723    var ContentFormat = class _ContentFormat {
8724      /**
8725       * @param {string} key
8726       * @param {Object} value
8727       */
8728      constructor(key, value) {
8729        this.key = key;
8730        this.value = value;
8731      }
8732      /**
8733       * @return {number}
8734       */
8735      getLength() {
8736        return 1;
8737      }
8738      /**
8739       * @return {Array<any>}
8740       */
8741      getContent() {
8742        return [];
8743      }
8744      /**
8745       * @return {boolean}
8746       */
8747      isCountable() {
8748        return false;
8749      }
8750      /**
8751       * @return {ContentFormat}
8752       */
8753      copy() {
8754        return new _ContentFormat(this.key, this.value);
8755      }
8756      /**
8757       * @param {number} _offset
8758       * @return {ContentFormat}
8759       */
8760      splice(_offset) {
8761        throw methodUnimplemented();
8762      }
8763      /**
8764       * @param {ContentFormat} _right
8765       * @return {boolean}
8766       */
8767      mergeWith(_right) {
8768        return false;
8769      }
8770      /**
8771       * @param {Transaction} _transaction
8772       * @param {Item} item
8773       */
8774      integrate(_transaction, item) {
8775        const p = (
8776          /** @type {YText} */
8777          item.parent
8778        );
8779        p._searchMarker = null;
8780        p._hasFormatting = true;
8781      }
8782      /**
8783       * @param {Transaction} transaction
8784       */
8785      delete(transaction) {
8786      }
8787      /**
8788       * @param {StructStore} store
8789       */
8790      gc(store) {
8791      }
8792      /**
8793       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8794       * @param {number} offset
8795       */
8796      write(encoder, offset) {
8797        encoder.writeKey(this.key);
8798        encoder.writeJSON(this.value);
8799      }
8800      /**
8801       * @return {number}
8802       */
8803      getRef() {
8804        return 6;
8805      }
8806    };
8807    var readContentFormat = (decoder) => new ContentFormat(decoder.readKey(), decoder.readJSON());
8808    var ContentJSON = class _ContentJSON {
8809      /**
8810       * @param {Array<any>} arr
8811       */
8812      constructor(arr) {
8813        this.arr = arr;
8814      }
8815      /**
8816       * @return {number}
8817       */
8818      getLength() {
8819        return this.arr.length;
8820      }
8821      /**
8822       * @return {Array<any>}
8823       */
8824      getContent() {
8825        return this.arr;
8826      }
8827      /**
8828       * @return {boolean}
8829       */
8830      isCountable() {
8831        return true;
8832      }
8833      /**
8834       * @return {ContentJSON}
8835       */
8836      copy() {
8837        return new _ContentJSON(this.arr);
8838      }
8839      /**
8840       * @param {number} offset
8841       * @return {ContentJSON}
8842       */
8843      splice(offset) {
8844        const right = new _ContentJSON(this.arr.slice(offset));
8845        this.arr = this.arr.slice(0, offset);
8846        return right;
8847      }
8848      /**
8849       * @param {ContentJSON} right
8850       * @return {boolean}
8851       */
8852      mergeWith(right) {
8853        this.arr = this.arr.concat(right.arr);
8854        return true;
8855      }
8856      /**
8857       * @param {Transaction} transaction
8858       * @param {Item} item
8859       */
8860      integrate(transaction, item) {
8861      }
8862      /**
8863       * @param {Transaction} transaction
8864       */
8865      delete(transaction) {
8866      }
8867      /**
8868       * @param {StructStore} store
8869       */
8870      gc(store) {
8871      }
8872      /**
8873       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8874       * @param {number} offset
8875       */
8876      write(encoder, offset) {
8877        const len = this.arr.length;
8878        encoder.writeLen(len - offset);
8879        for (let i = offset; i < len; i++) {
8880          const c = this.arr[i];
8881          encoder.writeString(c === void 0 ? "undefined" : JSON.stringify(c));
8882        }
8883      }
8884      /**
8885       * @return {number}
8886       */
8887      getRef() {
8888        return 2;
8889      }
8890    };
8891    var readContentJSON = (decoder) => {
8892      const len = decoder.readLen();
8893      const cs = [];
8894      for (let i = 0; i < len; i++) {
8895        const c = decoder.readString();
8896        if (c === "undefined") {
8897          cs.push(void 0);
8898        } else {
8899          cs.push(JSON.parse(c));
8900        }
8901      }
8902      return new ContentJSON(cs);
8903    };
8904    var isDevMode = getVariable("node_env") === "development";
8905    var ContentAny = class _ContentAny {
8906      /**
8907       * @param {Array<any>} arr
8908       */
8909      constructor(arr) {
8910        this.arr = arr;
8911        isDevMode && deepFreeze(arr);
8912      }
8913      /**
8914       * @return {number}
8915       */
8916      getLength() {
8917        return this.arr.length;
8918      }
8919      /**
8920       * @return {Array<any>}
8921       */
8922      getContent() {
8923        return this.arr;
8924      }
8925      /**
8926       * @return {boolean}
8927       */
8928      isCountable() {
8929        return true;
8930      }
8931      /**
8932       * @return {ContentAny}
8933       */
8934      copy() {
8935        return new _ContentAny(this.arr);
8936      }
8937      /**
8938       * @param {number} offset
8939       * @return {ContentAny}
8940       */
8941      splice(offset) {
8942        const right = new _ContentAny(this.arr.slice(offset));
8943        this.arr = this.arr.slice(0, offset);
8944        return right;
8945      }
8946      /**
8947       * @param {ContentAny} right
8948       * @return {boolean}
8949       */
8950      mergeWith(right) {
8951        this.arr = this.arr.concat(right.arr);
8952        return true;
8953      }
8954      /**
8955       * @param {Transaction} transaction
8956       * @param {Item} item
8957       */
8958      integrate(transaction, item) {
8959      }
8960      /**
8961       * @param {Transaction} transaction
8962       */
8963      delete(transaction) {
8964      }
8965      /**
8966       * @param {StructStore} store
8967       */
8968      gc(store) {
8969      }
8970      /**
8971       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
8972       * @param {number} offset
8973       */
8974      write(encoder, offset) {
8975        const len = this.arr.length;
8976        encoder.writeLen(len - offset);
8977        for (let i = offset; i < len; i++) {
8978          const c = this.arr[i];
8979          encoder.writeAny(c);
8980        }
8981      }
8982      /**
8983       * @return {number}
8984       */
8985      getRef() {
8986        return 8;
8987      }
8988    };
8989    var readContentAny = (decoder) => {
8990      const len = decoder.readLen();
8991      const cs = [];
8992      for (let i = 0; i < len; i++) {
8993        cs.push(decoder.readAny());
8994      }
8995      return new ContentAny(cs);
8996    };
8997    var ContentString = class _ContentString {
8998      /**
8999       * @param {string} str
9000       */
9001      constructor(str) {
9002        this.str = str;
9003      }
9004      /**
9005       * @return {number}
9006       */
9007      getLength() {
9008        return this.str.length;
9009      }
9010      /**
9011       * @return {Array<any>}
9012       */
9013      getContent() {
9014        return this.str.split("");
9015      }
9016      /**
9017       * @return {boolean}
9018       */
9019      isCountable() {
9020        return true;
9021      }
9022      /**
9023       * @return {ContentString}
9024       */
9025      copy() {
9026        return new _ContentString(this.str);
9027      }
9028      /**
9029       * @param {number} offset
9030       * @return {ContentString}
9031       */
9032      splice(offset) {
9033        const right = new _ContentString(this.str.slice(offset));
9034        this.str = this.str.slice(0, offset);
9035        const firstCharCode = this.str.charCodeAt(offset - 1);
9036        if (firstCharCode >= 55296 && firstCharCode <= 56319) {
9037          this.str = this.str.slice(0, offset - 1) + "\uFFFD";
9038          right.str = "\uFFFD" + right.str.slice(1);
9039        }
9040        return right;
9041      }
9042      /**
9043       * @param {ContentString} right
9044       * @return {boolean}
9045       */
9046      mergeWith(right) {
9047        this.str += right.str;
9048        return true;
9049      }
9050      /**
9051       * @param {Transaction} transaction
9052       * @param {Item} item
9053       */
9054      integrate(transaction, item) {
9055      }
9056      /**
9057       * @param {Transaction} transaction
9058       */
9059      delete(transaction) {
9060      }
9061      /**
9062       * @param {StructStore} store
9063       */
9064      gc(store) {
9065      }
9066      /**
9067       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
9068       * @param {number} offset
9069       */
9070      write(encoder, offset) {
9071        encoder.writeString(offset === 0 ? this.str : this.str.slice(offset));
9072      }
9073      /**
9074       * @return {number}
9075       */
9076      getRef() {
9077        return 4;
9078      }
9079    };
9080    var readContentString = (decoder) => new ContentString(decoder.readString());
9081    var typeRefs = [
9082      readYArray,
9083      readYMap,
9084      readYText,
9085      readYXmlElement,
9086      readYXmlFragment,
9087      readYXmlHook,
9088      readYXmlText
9089    ];
9090    var YArrayRefID = 0;
9091    var YMapRefID = 1;
9092    var YTextRefID = 2;
9093    var YXmlElementRefID = 3;
9094    var YXmlFragmentRefID = 4;
9095    var YXmlHookRefID = 5;
9096    var YXmlTextRefID = 6;
9097    var ContentType = class _ContentType {
9098      /**
9099       * @param {AbstractType<any>} type
9100       */
9101      constructor(type) {
9102        this.type = type;
9103      }
9104      /**
9105       * @return {number}
9106       */
9107      getLength() {
9108        return 1;
9109      }
9110      /**
9111       * @return {Array<any>}
9112       */
9113      getContent() {
9114        return [this.type];
9115      }
9116      /**
9117       * @return {boolean}
9118       */
9119      isCountable() {
9120        return true;
9121      }
9122      /**
9123       * @return {ContentType}
9124       */
9125      copy() {
9126        return new _ContentType(this.type._copy());
9127      }
9128      /**
9129       * @param {number} offset
9130       * @return {ContentType}
9131       */
9132      splice(offset) {
9133        throw methodUnimplemented();
9134      }
9135      /**
9136       * @param {ContentType} right
9137       * @return {boolean}
9138       */
9139      mergeWith(right) {
9140        return false;
9141      }
9142      /**
9143       * @param {Transaction} transaction
9144       * @param {Item} item
9145       */
9146      integrate(transaction, item) {
9147        this.type._integrate(transaction.doc, item);
9148      }
9149      /**
9150       * @param {Transaction} transaction
9151       */
9152      delete(transaction) {
9153        let item = this.type._start;
9154        while (item !== null) {
9155          if (!item.deleted) {
9156            item.delete(transaction);
9157          } else if (item.id.clock < (transaction.beforeState.get(item.id.client) || 0)) {
9158            transaction._mergeStructs.push(item);
9159          }
9160          item = item.right;
9161        }
9162        this.type._map.forEach((item2) => {
9163          if (!item2.deleted) {
9164            item2.delete(transaction);
9165          } else if (item2.id.clock < (transaction.beforeState.get(item2.id.client) || 0)) {
9166            transaction._mergeStructs.push(item2);
9167          }
9168        });
9169        transaction.changed.delete(this.type);
9170      }
9171      /**
9172       * @param {StructStore} store
9173       */
9174      gc(store) {
9175        let item = this.type._start;
9176        while (item !== null) {
9177          item.gc(store, true);
9178          item = item.right;
9179        }
9180        this.type._start = null;
9181        this.type._map.forEach(
9182          /** @param {Item | null} item */
9183          (item2) => {
9184            while (item2 !== null) {
9185              item2.gc(store, true);
9186              item2 = item2.left;
9187            }
9188          }
9189        );
9190        this.type._map = /* @__PURE__ */ new Map();
9191      }
9192      /**
9193       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
9194       * @param {number} offset
9195       */
9196      write(encoder, offset) {
9197        this.type._write(encoder);
9198      }
9199      /**
9200       * @return {number}
9201       */
9202      getRef() {
9203        return 7;
9204      }
9205    };
9206    var readContentType = (decoder) => new ContentType(typeRefs[decoder.readTypeRef()](decoder));
9207    var followRedone = (store, id2) => {
9208      let nextID = id2;
9209      let diff = 0;
9210      let item;
9211      do {
9212        if (diff > 0) {
9213          nextID = createID(nextID.client, nextID.clock + diff);
9214        }
9215        item = getItem(store, nextID);
9216        diff = nextID.clock - item.id.clock;
9217        nextID = item.redone;
9218      } while (nextID !== null && item instanceof Item);
9219      return {
9220        item,
9221        diff
9222      };
9223    };
9224    var keepItem = (item, keep) => {
9225      while (item !== null && item.keep !== keep) {
9226        item.keep = keep;
9227        item = /** @type {AbstractType<any>} */
9228        item.parent._item;
9229      }
9230    };
9231    var splitItem = (transaction, leftItem, diff) => {
9232      const { client, clock } = leftItem.id;
9233      const rightItem = new Item(
9234        createID(client, clock + diff),
9235        leftItem,
9236        createID(client, clock + diff - 1),
9237        leftItem.right,
9238        leftItem.rightOrigin,
9239        leftItem.parent,
9240        leftItem.parentSub,
9241        leftItem.content.splice(diff)
9242      );
9243      if (leftItem.deleted) {
9244        rightItem.markDeleted();
9245      }
9246      if (leftItem.keep) {
9247        rightItem.keep = true;
9248      }
9249      if (leftItem.redone !== null) {
9250        rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff);
9251      }
9252      leftItem.right = rightItem;
9253      if (rightItem.right !== null) {
9254        rightItem.right.left = rightItem;
9255      }
9256      transaction._mergeStructs.push(rightItem);
9257      if (rightItem.parentSub !== null && rightItem.right === null) {
9258        rightItem.parent._map.set(rightItem.parentSub, rightItem);
9259      }
9260      leftItem.length = diff;
9261      return rightItem;
9262    };
9263    var isDeletedByUndoStack = (stack, id2) => some(
9264      stack,
9265      /** @param {StackItem} s */
9266      (s) => isDeleted(s.deletions, id2)
9267    );
9268    var redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {
9269      const doc2 = transaction.doc;
9270      const store = doc2.store;
9271      const ownClientID = doc2.clientID;
9272      const redone = item.redone;
9273      if (redone !== null) {
9274        return getItemCleanStart(transaction, redone);
9275      }
9276      let parentItem = (
9277        /** @type {AbstractType<any>} */
9278        item.parent._item
9279      );
9280      let left = null;
9281      let right;
9282      if (parentItem !== null && parentItem.deleted === true) {
9283        if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) === null)) {
9284          return null;
9285        }
9286        while (parentItem.redone !== null) {
9287          parentItem = getItemCleanStart(transaction, parentItem.redone);
9288        }
9289      }
9290      const parentType = parentItem === null ? (
9291        /** @type {AbstractType<any>} */
9292        item.parent
9293      ) : (
9294        /** @type {ContentType} */
9295        parentItem.content.type
9296      );
9297      if (item.parentSub === null) {
9298        left = item.left;
9299        right = item;
9300        while (left !== null) {
9301          let leftTrace = left;
9302          while (leftTrace !== null && /** @type {AbstractType<any>} */
9303          leftTrace.parent._item !== parentItem) {
9304            leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone);
9305          }
9306          if (leftTrace !== null && /** @type {AbstractType<any>} */
9307          leftTrace.parent._item === parentItem) {
9308            left = leftTrace;
9309            break;
9310          }
9311          left = left.left;
9312        }
9313        while (right !== null) {
9314          let rightTrace = right;
9315          while (rightTrace !== null && /** @type {AbstractType<any>} */
9316          rightTrace.parent._item !== parentItem) {
9317            rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone);
9318          }
9319          if (rightTrace !== null && /** @type {AbstractType<any>} */
9320          rightTrace.parent._item === parentItem) {
9321            right = rightTrace;
9322            break;
9323          }
9324          right = right.right;
9325        }
9326      } else {
9327        right = null;
9328        if (item.right && !ignoreRemoteMapChanges) {
9329          left = item;
9330          while (left !== null && left.right !== null && (left.right.redone || isDeleted(itemsToDelete, left.right.id) || isDeletedByUndoStack(um.undoStack, left.right.id) || isDeletedByUndoStack(um.redoStack, left.right.id))) {
9331            left = left.right;
9332            while (left.redone) left = getItemCleanStart(transaction, left.redone);
9333          }
9334          if (left && left.right !== null) {
9335            return null;
9336          }
9337        } else {
9338          left = parentType._map.get(item.parentSub) || null;
9339        }
9340      }
9341      const nextClock = getState(store, ownClientID);
9342      const nextId = createID(ownClientID, nextClock);
9343      const redoneItem = new Item(
9344        nextId,
9345        left,
9346        left && left.lastId,
9347        right,
9348        right && right.id,
9349        parentType,
9350        item.parentSub,
9351        item.content.copy()
9352      );
9353      item.redone = nextId;
9354      keepItem(redoneItem, true);
9355      redoneItem.integrate(transaction, 0);
9356      return redoneItem;
9357    };
9358    var Item = class _Item extends AbstractStruct {
9359      /**
9360       * @param {ID} id
9361       * @param {Item | null} left
9362       * @param {ID | null} origin
9363       * @param {Item | null} right
9364       * @param {ID | null} rightOrigin
9365       * @param {AbstractType<any>|ID|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.
9366       * @param {string | null} parentSub
9367       * @param {AbstractContent} content
9368       */
9369      constructor(id2, left, origin2, right, rightOrigin, parent, parentSub, content) {
9370        super(id2, content.getLength());
9371        this.origin = origin2;
9372        this.left = left;
9373        this.right = right;
9374        this.rightOrigin = rightOrigin;
9375        this.parent = parent;
9376        this.parentSub = parentSub;
9377        this.redone = null;
9378        this.content = content;
9379        this.info = this.content.isCountable() ? BIT2 : 0;
9380      }
9381      /**
9382       * This is used to mark the item as an indexed fast-search marker
9383       *
9384       * @type {boolean}
9385       */
9386      set marker(isMarked) {
9387        if ((this.info & BIT4) > 0 !== isMarked) {
9388          this.info ^= BIT4;
9389        }
9390      }
9391      get marker() {
9392        return (this.info & BIT4) > 0;
9393      }
9394      /**
9395       * If true, do not garbage collect this Item.
9396       */
9397      get keep() {
9398        return (this.info & BIT1) > 0;
9399      }
9400      set keep(doKeep) {
9401        if (this.keep !== doKeep) {
9402          this.info ^= BIT1;
9403        }
9404      }
9405      get countable() {
9406        return (this.info & BIT2) > 0;
9407      }
9408      /**
9409       * Whether this item was deleted or not.
9410       * @type {Boolean}
9411       */
9412      get deleted() {
9413        return (this.info & BIT3) > 0;
9414      }
9415      set deleted(doDelete) {
9416        if (this.deleted !== doDelete) {
9417          this.info ^= BIT3;
9418        }
9419      }
9420      markDeleted() {
9421        this.info |= BIT3;
9422      }
9423      /**
9424       * Return the creator clientID of the missing op or define missing items and return null.
9425       *
9426       * @param {Transaction} transaction
9427       * @param {StructStore} store
9428       * @return {null | number}
9429       */
9430      getMissing(transaction, store) {
9431        if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= getState(store, this.origin.client)) {
9432          return this.origin.client;
9433        }
9434        if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= getState(store, this.rightOrigin.client)) {
9435          return this.rightOrigin.client;
9436        }
9437        if (this.parent && this.parent.constructor === ID && this.id.client !== this.parent.client && this.parent.clock >= getState(store, this.parent.client)) {
9438          return this.parent.client;
9439        }
9440        if (this.origin) {
9441          this.left = getItemCleanEnd(transaction, store, this.origin);
9442          this.origin = this.left.lastId;
9443        }
9444        if (this.rightOrigin) {
9445          this.right = getItemCleanStart(transaction, this.rightOrigin);
9446          this.rightOrigin = this.right.id;
9447        }
9448        if (this.left && this.left.constructor === GC || this.right && this.right.constructor === GC) {
9449          this.parent = null;
9450        } else if (!this.parent) {
9451          if (this.left && this.left.constructor === _Item) {
9452            this.parent = this.left.parent;
9453            this.parentSub = this.left.parentSub;
9454          } else if (this.right && this.right.constructor === _Item) {
9455            this.parent = this.right.parent;
9456            this.parentSub = this.right.parentSub;
9457          }
9458        } else if (this.parent.constructor === ID) {
9459          const parentItem = getItem(store, this.parent);
9460          if (parentItem.constructor === GC) {
9461            this.parent = null;
9462          } else {
9463            this.parent = /** @type {ContentType} */
9464            parentItem.content.type;
9465          }
9466        }
9467        return null;
9468      }
9469      /**
9470       * @param {Transaction} transaction
9471       * @param {number} offset
9472       */
9473      integrate(transaction, offset) {
9474        if (offset > 0) {
9475          this.id.clock += offset;
9476          this.left = getItemCleanEnd(transaction, transaction.doc.store, createID(this.id.client, this.id.clock - 1));
9477          this.origin = this.left.lastId;
9478          this.content = this.content.splice(offset);
9479          this.length -= offset;
9480        }
9481        if (this.parent) {
9482          if (!this.left && (!this.right || this.right.left !== null) || this.left && this.left.right !== this.right) {
9483            let left = this.left;
9484            let o;
9485            if (left !== null) {
9486              o = left.right;
9487            } else if (this.parentSub !== null) {
9488              o = /** @type {AbstractType<any>} */
9489              this.parent._map.get(this.parentSub) || null;
9490              while (o !== null && o.left !== null) {
9491                o = o.left;
9492              }
9493            } else {
9494              o = /** @type {AbstractType<any>} */
9495              this.parent._start;
9496            }
9497            const conflictingItems = /* @__PURE__ */ new Set();
9498            const itemsBeforeOrigin = /* @__PURE__ */ new Set();
9499            while (o !== null && o !== this.right) {
9500              itemsBeforeOrigin.add(o);
9501              conflictingItems.add(o);
9502              if (compareIDs(this.origin, o.origin)) {
9503                if (o.id.client < this.id.client) {
9504                  left = o;
9505                  conflictingItems.clear();
9506                } else if (compareIDs(this.rightOrigin, o.rightOrigin)) {
9507                  break;
9508                }
9509              } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) {
9510                if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {
9511                  left = o;
9512                  conflictingItems.clear();
9513                }
9514              } else {
9515                break;
9516              }
9517              o = o.right;
9518            }
9519            this.left = left;
9520          }
9521          if (this.left !== null) {
9522            const right = this.left.right;
9523            this.right = right;
9524            this.left.right = this;
9525          } else {
9526            let r;
9527            if (this.parentSub !== null) {
9528              r = /** @type {AbstractType<any>} */
9529              this.parent._map.get(this.parentSub) || null;
9530              while (r !== null && r.left !== null) {
9531                r = r.left;
9532              }
9533            } else {
9534              r = /** @type {AbstractType<any>} */
9535              this.parent._start;
9536              this.parent._start = this;
9537            }
9538            this.right = r;
9539          }
9540          if (this.right !== null) {
9541            this.right.left = this;
9542          } else if (this.parentSub !== null) {
9543            this.parent._map.set(this.parentSub, this);
9544            if (this.left !== null) {
9545              this.left.delete(transaction);
9546            }
9547          }
9548          if (this.parentSub === null && this.countable && !this.deleted) {
9549            this.parent._length += this.length;
9550          }
9551          addStruct(transaction.doc.store, this);
9552          this.content.integrate(transaction, this);
9553          addChangedTypeToTransaction(
9554            transaction,
9555            /** @type {AbstractType<any>} */
9556            this.parent,
9557            this.parentSub
9558          );
9559          if (
9560            /** @type {AbstractType<any>} */
9561            this.parent._item !== null && /** @type {AbstractType<any>} */
9562            this.parent._item.deleted || this.parentSub !== null && this.right !== null
9563          ) {
9564            this.delete(transaction);
9565          }
9566        } else {
9567          new GC(this.id, this.length).integrate(transaction, 0);
9568        }
9569      }
9570      /**
9571       * Returns the next non-deleted item
9572       */
9573      get next() {
9574        let n = this.right;
9575        while (n !== null && n.deleted) {
9576          n = n.right;
9577        }
9578        return n;
9579      }
9580      /**
9581       * Returns the previous non-deleted item
9582       */
9583      get prev() {
9584        let n = this.left;
9585        while (n !== null && n.deleted) {
9586          n = n.left;
9587        }
9588        return n;
9589      }
9590      /**
9591       * Computes the last content address of this Item.
9592       */
9593      get lastId() {
9594        return this.length === 1 ? this.id : createID(this.id.client, this.id.clock + this.length - 1);
9595      }
9596      /**
9597       * Try to merge two items
9598       *
9599       * @param {Item} right
9600       * @return {boolean}
9601       */
9602      mergeWith(right) {
9603        if (this.constructor === right.constructor && compareIDs(right.origin, this.lastId) && this.right === right && compareIDs(this.rightOrigin, right.rightOrigin) && this.id.client === right.id.client && this.id.clock + this.length === right.id.clock && this.deleted === right.deleted && this.redone === null && right.redone === null && this.content.constructor === right.content.constructor && this.content.mergeWith(right.content)) {
9604          const searchMarker = (
9605            /** @type {AbstractType<any>} */
9606            this.parent._searchMarker
9607          );
9608          if (searchMarker) {
9609            searchMarker.forEach((marker) => {
9610              if (marker.p === right) {
9611                marker.p = this;
9612                if (!this.deleted && this.countable) {
9613                  marker.index -= this.length;
9614                }
9615              }
9616            });
9617          }
9618          if (right.keep) {
9619            this.keep = true;
9620          }
9621          this.right = right.right;
9622          if (this.right !== null) {
9623            this.right.left = this;
9624          }
9625          this.length += right.length;
9626          return true;
9627        }
9628        return false;
9629      }
9630      /**
9631       * Mark this Item as deleted.
9632       *
9633       * @param {Transaction} transaction
9634       */
9635      delete(transaction) {
9636        if (!this.deleted) {
9637          const parent = (
9638            /** @type {AbstractType<any>} */
9639            this.parent
9640          );
9641          if (this.countable && this.parentSub === null) {
9642            parent._length -= this.length;
9643          }
9644          this.markDeleted();
9645          addToDeleteSet(transaction.deleteSet, this.id.client, this.id.clock, this.length);
9646          addChangedTypeToTransaction(transaction, parent, this.parentSub);
9647          this.content.delete(transaction);
9648        }
9649      }
9650      /**
9651       * @param {StructStore} store
9652       * @param {boolean} parentGCd
9653       */
9654      gc(store, parentGCd) {
9655        if (!this.deleted) {
9656          throw unexpectedCase();
9657        }
9658        this.content.gc(store);
9659        if (parentGCd) {
9660          replaceStruct(store, this, new GC(this.id, this.length));
9661        } else {
9662          this.content = new ContentDeleted(this.length);
9663        }
9664      }
9665      /**
9666       * Transform the properties of this type to binary and write it to an
9667       * BinaryEncoder.
9668       *
9669       * This is called when this Item is sent to a remote peer.
9670       *
9671       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
9672       * @param {number} offset
9673       */
9674      write(encoder, offset) {
9675        const origin2 = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin;
9676        const rightOrigin = this.rightOrigin;
9677        const parentSub = this.parentSub;
9678        const info = this.content.getRef() & BITS5 | (origin2 === null ? 0 : BIT8) | // origin is defined
9679        (rightOrigin === null ? 0 : BIT7) | // right origin is defined
9680        (parentSub === null ? 0 : BIT6);
9681        encoder.writeInfo(info);
9682        if (origin2 !== null) {
9683          encoder.writeLeftID(origin2);
9684        }
9685        if (rightOrigin !== null) {
9686          encoder.writeRightID(rightOrigin);
9687        }
9688        if (origin2 === null && rightOrigin === null) {
9689          const parent = (
9690            /** @type {AbstractType<any>} */
9691            this.parent
9692          );
9693          if (parent._item !== void 0) {
9694            const parentItem = parent._item;
9695            if (parentItem === null) {
9696              const ykey = findRootTypeKey(parent);
9697              encoder.writeParentInfo(true);
9698              encoder.writeString(ykey);
9699            } else {
9700              encoder.writeParentInfo(false);
9701              encoder.writeLeftID(parentItem.id);
9702            }
9703          } else if (parent.constructor === String) {
9704            encoder.writeParentInfo(true);
9705            encoder.writeString(parent);
9706          } else if (parent.constructor === ID) {
9707            encoder.writeParentInfo(false);
9708            encoder.writeLeftID(parent);
9709          } else {
9710            unexpectedCase();
9711          }
9712          if (parentSub !== null) {
9713            encoder.writeString(parentSub);
9714          }
9715        }
9716        this.content.write(encoder, offset);
9717      }
9718    };
9719    var readItemContent = (decoder, info) => contentRefs[info & BITS5](decoder);
9720    var contentRefs = [
9721      () => {
9722        unexpectedCase();
9723      },
9724      // GC is not ItemContent
9725      readContentDeleted,
9726      // 1
9727      readContentJSON,
9728      // 2
9729      readContentBinary,
9730      // 3
9731      readContentString,
9732      // 4
9733      readContentEmbed,
9734      // 5
9735      readContentFormat,
9736      // 6
9737      readContentType,
9738      // 7
9739      readContentAny,
9740      // 8
9741      readContentDoc,
9742      // 9
9743      () => {
9744        unexpectedCase();
9745      }
9746      // 10 - Skip is not ItemContent
9747    ];
9748    var structSkipRefNumber = 10;
9749    var Skip = class extends AbstractStruct {
9750      get deleted() {
9751        return true;
9752      }
9753      delete() {
9754      }
9755      /**
9756       * @param {Skip} right
9757       * @return {boolean}
9758       */
9759      mergeWith(right) {
9760        if (this.constructor !== right.constructor) {
9761          return false;
9762        }
9763        this.length += right.length;
9764        return true;
9765      }
9766      /**
9767       * @param {Transaction} transaction
9768       * @param {number} offset
9769       */
9770      integrate(transaction, offset) {
9771        unexpectedCase();
9772      }
9773      /**
9774       * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
9775       * @param {number} offset
9776       */
9777      write(encoder, offset) {
9778        encoder.writeInfo(structSkipRefNumber);
9779        writeVarUint(encoder.restEncoder, this.length - offset);
9780      }
9781      /**
9782       * @param {Transaction} transaction
9783       * @param {StructStore} store
9784       * @return {null | number}
9785       */
9786      getMissing(transaction, store) {
9787        return null;
9788      }
9789    };
9790    var glo = (
9791      /** @type {any} */
9792      typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}
9793    );
9794    var importIdentifier = "__ $YJS$ __";
9795    if (glo[importIdentifier] === true) {
9796      console.error("Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438");
9797    }
9798    glo[importIdentifier] = true;
9799  
9800    // node_modules/y-protocols/awareness.js
9801    var outdatedTimeout = 3e4;
9802    var Awareness = class extends Observable {
9803      /**
9804       * @param {Y.Doc} doc
9805       */
9806      constructor(doc2) {
9807        super();
9808        this.doc = doc2;
9809        this.clientID = doc2.clientID;
9810        this.states = /* @__PURE__ */ new Map();
9811        this.meta = /* @__PURE__ */ new Map();
9812        this._checkInterval = /** @type {any} */
9813        setInterval(() => {
9814          const now = getUnixTime();
9815          if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */
9816          this.meta.get(this.clientID).lastUpdated) {
9817            this.setLocalState(this.getLocalState());
9818          }
9819          const remove = [];
9820          this.meta.forEach((meta, clientid) => {
9821            if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
9822              remove.push(clientid);
9823            }
9824          });
9825          if (remove.length > 0) {
9826            removeAwarenessStates(this, remove, "timeout");
9827          }
9828        }, floor(outdatedTimeout / 10));
9829        doc2.on("destroy", () => {
9830          this.destroy();
9831        });
9832        this.setLocalState({});
9833      }
9834      destroy() {
9835        this.emit("destroy", [this]);
9836        this.setLocalState(null);
9837        super.destroy();
9838        clearInterval(this._checkInterval);
9839      }
9840      /**
9841       * @return {Object<string,any>|null}
9842       */
9843      getLocalState() {
9844        return this.states.get(this.clientID) || null;
9845      }
9846      /**
9847       * @param {Object<string,any>|null} state
9848       */
9849      setLocalState(state) {
9850        const clientID = this.clientID;
9851        const currLocalMeta = this.meta.get(clientID);
9852        const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
9853        const prevState = this.states.get(clientID);
9854        if (state === null) {
9855          this.states.delete(clientID);
9856        } else {
9857          this.states.set(clientID, state);
9858        }
9859        this.meta.set(clientID, {
9860          clock,
9861          lastUpdated: getUnixTime()
9862        });
9863        const added = [];
9864        const updated = [];
9865        const filteredUpdated = [];
9866        const removed = [];
9867        if (state === null) {
9868          removed.push(clientID);
9869        } else if (prevState == null) {
9870          if (state != null) {
9871            added.push(clientID);
9872          }
9873        } else {
9874          updated.push(clientID);
9875          if (!equalityDeep(prevState, state)) {
9876            filteredUpdated.push(clientID);
9877          }
9878        }
9879        if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
9880          this.emit("change", [{ added, updated: filteredUpdated, removed }, "local"]);
9881        }
9882        this.emit("update", [{ added, updated, removed }, "local"]);
9883      }
9884      /**
9885       * @param {string} field
9886       * @param {any} value
9887       */
9888      setLocalStateField(field, value) {
9889        const state = this.getLocalState();
9890        if (state !== null) {
9891          this.setLocalState({
9892            ...state,
9893            [field]: value
9894          });
9895        }
9896      }
9897      /**
9898       * @return {Map<number,Object<string,any>>}
9899       */
9900      getStates() {
9901        return this.states;
9902      }
9903    };
9904    var removeAwarenessStates = (awareness, clients, origin2) => {
9905      const removed = [];
9906      for (let i = 0; i < clients.length; i++) {
9907        const clientID = clients[i];
9908        if (awareness.states.has(clientID)) {
9909          awareness.states.delete(clientID);
9910          if (clientID === awareness.clientID) {
9911            const curMeta = (
9912              /** @type {MetaClientState} */
9913              awareness.meta.get(clientID)
9914            );
9915            awareness.meta.set(clientID, {
9916              clock: curMeta.clock + 1,
9917              lastUpdated: getUnixTime()
9918            });
9919          }
9920          removed.push(clientID);
9921        }
9922      }
9923      if (removed.length > 0) {
9924        awareness.emit("change", [{ added: [], updated: [], removed }, origin2]);
9925        awareness.emit("update", [{ added: [], updated: [], removed }, origin2]);
9926      }
9927    };
9928  
9929    // packages/sync/build-module/config.mjs
9930    var CRDT_DOC_VERSION = 1;
9931    var CRDT_DOC_META_PERSISTENCE_KEY = "fromPersistence";
9932    var CRDT_RECORD_MAP_KEY = "document";
9933    var CRDT_STATE_MAP_KEY = "state";
9934    var CRDT_STATE_MAP_SAVED_AT_KEY = "savedAt";
9935    var CRDT_STATE_MAP_SAVED_BY_KEY = "savedBy";
9936    var CRDT_STATE_MAP_VERSION_KEY = "version";
9937    var LOCAL_EDITOR_ORIGIN = "gutenberg";
9938    var LOCAL_SYNC_MANAGER_ORIGIN = "syncManager";
9939    var LOCAL_UNDO_IGNORED_ORIGIN = "gutenberg-undo-ignored";
9940  
9941    // packages/sync/build-module/errors.mjs
9942    var ConnectionErrorCode = /* @__PURE__ */ ((ConnectionErrorCode2) => {
9943      ConnectionErrorCode2["AUTHENTICATION_FAILED"] = "authentication-failed";
9944      ConnectionErrorCode2["CONNECTION_EXPIRED"] = "connection-expired";
9945      ConnectionErrorCode2["CONNECTION_LIMIT_EXCEEDED"] = "connection-limit-exceeded";
9946      ConnectionErrorCode2["DOCUMENT_SIZE_LIMIT_EXCEEDED"] = "document-size-limit-exceeded";
9947      ConnectionErrorCode2["PROTOCOL_MISMATCH"] = "protocol-mismatch";
9948      ConnectionErrorCode2["UNKNOWN_ERROR"] = "unknown-error";
9949      return ConnectionErrorCode2;
9950    })(ConnectionErrorCode || {});
9951    var ConnectionError = class extends Error {
9952      constructor(code = "unknown-error", message) {
9953        super(message);
9954        this.code = code;
9955        this.name = "ConnectionError";
9956      }
9957    };
9958  
9959    // packages/sync/build-module/lock-unlock.mjs
9960    var import_private_apis = __toESM(require_private_apis(), 1);
9961    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
9962      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
9963      "@wordpress/sync"
9964    );
9965  
9966    // packages/sync/build-module/performance.mjs
9967    function logPerformanceTiming(fn) {
9968      return function(...args2) {
9969        const start = performance.now();
9970        const result = fn.apply(this, args2);
9971        const end = performance.now();
9972        console.log(
9973          `[SyncManager][performance]: $fn.name} took ${(end - start).toFixed(2)} ms`
9974        );
9975        return result;
9976      };
9977    }
9978    function passThru(fn) {
9979      return ((...args2) => fn(...args2));
9980    }
9981  
9982    // packages/sync/build-module/providers/index.mjs
9983    var import_hooks3 = __toESM(require_hooks(), 1);
9984  
9985    // packages/sync/build-module/providers/http-polling/polling-manager.mjs
9986    var import_hooks2 = __toESM(require_hooks(), 1);
9987  
9988    // node_modules/y-protocols/sync.js
9989    var messageYjsSyncStep1 = 0;
9990    var messageYjsSyncStep2 = 1;
9991    var messageYjsUpdate = 2;
9992    var writeSyncStep1 = (encoder, doc2) => {
9993      writeVarUint(encoder, messageYjsSyncStep1);
9994      const sv = encodeStateVector(doc2);
9995      writeVarUint8Array(encoder, sv);
9996    };
9997    var writeSyncStep2 = (encoder, doc2, encodedStateVector) => {
9998      writeVarUint(encoder, messageYjsSyncStep2);
9999      writeVarUint8Array(encoder, encodeStateAsUpdate(doc2, encodedStateVector));
10000    };
10001    var readSyncStep1 = (decoder, encoder, doc2) => writeSyncStep2(encoder, doc2, readVarUint8Array(decoder));
10002    var readSyncStep2 = (decoder, doc2, transactionOrigin, errorHandler) => {
10003      try {
10004        applyUpdate(doc2, readVarUint8Array(decoder), transactionOrigin);
10005      } catch (error) {
10006        if (errorHandler != null) errorHandler(
10007          /** @type {Error} */
10008          error
10009        );
10010        console.error("Caught error while handling a Yjs update", error);
10011      }
10012    };
10013    var readUpdate2 = readSyncStep2;
10014    var readSyncMessage = (decoder, encoder, doc2, transactionOrigin, errorHandler) => {
10015      const messageType = readVarUint(decoder);
10016      switch (messageType) {
10017        case messageYjsSyncStep1:
10018          readSyncStep1(decoder, encoder, doc2);
10019          break;
10020        case messageYjsSyncStep2:
10021          readSyncStep2(decoder, doc2, transactionOrigin, errorHandler);
10022          break;
10023        case messageYjsUpdate:
10024          readUpdate2(decoder, doc2, transactionOrigin, errorHandler);
10025          break;
10026        default:
10027          throw new Error("Unknown message type");
10028      }
10029      return messageType;
10030    };
10031  
10032    // packages/sync/build-module/providers/http-polling/config.mjs
10033    var import_hooks = __toESM(require_hooks(), 1);
10034    var DEFAULT_CLIENT_LIMIT_PER_ROOM = 3;
10035    var ERROR_RETRY_DELAYS_SOLO_MS = [
10036      2e3,
10037      4e3,
10038      8e3,
10039      12e3
10040      // Solo: 26s total retry time solo before dialog
10041    ];
10042    var ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS = [
10043      1e3,
10044      2e3,
10045      4e3,
10046      8e3
10047      // With collaborators: 15s total retry time before dialog
10048    ];
10049    var DISCONNECT_DIALOG_RETRY_MS = 3e4;
10050    var MANUAL_RETRY_INTERVAL_MS = 15e3;
10051    var MAX_ENCODED_UPDATE_SIZE_IN_BYTES = 1 * 1024 * 1024;
10052    var MAX_UPDATE_SIZE_IN_BYTES = Math.floor(MAX_ENCODED_UPDATE_SIZE_IN_BYTES / 4) * 3;
10053    var MAX_ROOMS_PER_REQUEST = 50;
10054    var MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES = 15 * 1024 * 1024;
10055    var MIN_SYNC_REQUEST_BODY_SIZE_LIMIT_IN_BYTES = 2 * 1024 * 1024;
10056    var DEFAULT_POLLING_INTERVAL_IN_MS = 4e3;
10057    var DEFAULT_POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS = 1e3;
10058    function getFilteredPollingInterval(hookName, defaultInterval) {
10059      const filteredInterval = (0, import_hooks.applyFilters)(hookName, defaultInterval);
10060      if (typeof filteredInterval !== "number" || !Number.isFinite(filteredInterval) || filteredInterval <= 0) {
10061        return defaultInterval;
10062      }
10063      return Math.min(filteredInterval, defaultInterval);
10064    }
10065    var POLLING_INTERVAL_IN_MS = getFilteredPollingInterval(
10066      "sync.pollingManager.pollingInterval",
10067      DEFAULT_POLLING_INTERVAL_IN_MS
10068    );
10069    var POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS = getFilteredPollingInterval(
10070      "sync.pollingManager.pollingIntervalWithCollaborators",
10071      DEFAULT_POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS
10072    );
10073    var POLLING_INTERVAL_BACKGROUND_TAB_IN_MS = 25 * 1e3;
10074  
10075    // packages/sync/build-module/providers/http-polling/types.mjs
10076    var SyncUpdateType = /* @__PURE__ */ ((SyncUpdateType2) => {
10077      SyncUpdateType2["COMPACTION"] = "compaction";
10078      SyncUpdateType2["SYNC_STEP_1"] = "sync_step1";
10079      SyncUpdateType2["SYNC_STEP_2"] = "sync_step2";
10080      SyncUpdateType2["UPDATE"] = "update";
10081      return SyncUpdateType2;
10082    })(SyncUpdateType || {});
10083  
10084    // packages/sync/build-module/providers/http-polling/utils.mjs
10085    var import_api_fetch = __toESM(require_api_fetch(), 1);
10086    var SYNC_API_PATH = "/wp-sync/v1/updates";
10087    function uint8ArrayToBase64(data) {
10088      let binary = "";
10089      const len = data.byteLength;
10090      for (let i = 0; i < len; i++) {
10091        binary += String.fromCharCode(data[i]);
10092      }
10093      return globalThis.btoa(binary);
10094    }
10095    function base64ToUint8Array(base64) {
10096      const binaryString = globalThis.atob(base64);
10097      const len = binaryString.length;
10098      const bytes = new Uint8Array(len);
10099      for (let i = 0; i < len; i++) {
10100        bytes[i] = binaryString.charCodeAt(i);
10101      }
10102      return bytes;
10103    }
10104    function createSyncUpdate(data, type) {
10105      return {
10106        data: uint8ArrayToBase64(data),
10107        type
10108      };
10109    }
10110    function createUpdateQueue(initial = [], paused = true) {
10111      let isPaused = paused;
10112      const updates = [...initial];
10113      return {
10114        add(update) {
10115          updates.push(update);
10116        },
10117        addBulk(bulkUpdates) {
10118          if (0 === bulkUpdates.length) {
10119            return;
10120          }
10121          updates.push(...bulkUpdates);
10122        },
10123        clear() {
10124          updates.splice(0, updates.length);
10125        },
10126        get() {
10127          if (isPaused) {
10128            return [];
10129          }
10130          return updates.splice(0, updates.length);
10131        },
10132        pause() {
10133          isPaused = true;
10134        },
10135        peek() {
10136          if (isPaused) {
10137            return [];
10138          }
10139          return [...updates];
10140        },
10141        restore(restoredUpdates) {
10142          const filtered = restoredUpdates.filter(
10143            (u) => u.type !== SyncUpdateType.COMPACTION
10144          );
10145          if (0 === filtered.length) {
10146            return;
10147          }
10148          updates.unshift(...filtered);
10149        },
10150        restoreExact(restoredUpdates) {
10151          if (0 === restoredUpdates.length) {
10152            return;
10153          }
10154          updates.unshift(...restoredUpdates);
10155        },
10156        resume() {
10157          isPaused = false;
10158        },
10159        size() {
10160          return updates.length;
10161        },
10162        take(count) {
10163          if (isPaused || count <= 0) {
10164            return [];
10165          }
10166          return updates.splice(0, count);
10167        }
10168      };
10169    }
10170    function postSyncUpdate(payload) {
10171      return (0, import_api_fetch.default)({
10172        method: "POST",
10173        path: SYNC_API_PATH,
10174        data: payload
10175      });
10176    }
10177    function postSyncUpdateNonBlocking(payload) {
10178      if (payload.rooms.length === 0) {
10179        return;
10180      }
10181      (0, import_api_fetch.default)({
10182        method: "POST",
10183        path: SYNC_API_PATH,
10184        data: payload,
10185        keepalive: true
10186      }).catch(() => {
10187      });
10188    }
10189    function intValueOrDefault(value, defaultValue) {
10190      const intValue = parseInt(String(value), 10);
10191      return isNaN(intValue) ? defaultValue : intValue;
10192    }
10193    function rotateWindow(items, offset, size2) {
10194      if (items.length === 0) {
10195        return { window: [], nextOffset: 0 };
10196      }
10197      const start = (offset % items.length + items.length) % items.length;
10198      const wrapped = [...items.slice(start), ...items.slice(0, start)];
10199      return {
10200        window: wrapped.slice(0, Math.max(0, size2)),
10201        nextOffset: (start + Math.max(0, size2)) % items.length
10202      };
10203    }
10204  
10205    // packages/sync/build-module/providers/http-polling/polling-manager.mjs
10206    var POLLING_MANAGER_ORIGIN = "polling-manager";
10207    function isForbiddenError(error) {
10208      return error?.data?.status === 403;
10209    }
10210    function isRequestBodyTooLargeError(error) {
10211      return error?.data?.status === 413 && error?.code === "rest_sync_body_too_large";
10212    }
10213    function isProtocolMismatchError(error) {
10214      return error?.code === "rest_sync_protocol_mismatch";
10215    }
10216    function handleForbiddenError(error, requestedRooms) {
10217      const requestedRoomNames = new Set(
10218        requestedRooms.map((room) => room.room)
10219      );
10220      const forbiddenRooms = Array.isArray(error.data.rooms) ? error.data.rooms.filter((room) => requestedRoomNames.has(room)) : [];
10221      if (forbiddenRooms.length > 0) {
10222        for (const room of forbiddenRooms) {
10223          const state = roomStates.get(room);
10224          if (state) {
10225            state.log(
10226              "Permission denied, unregistering room",
10227              { error },
10228              "error",
10229              true
10230              // force
10231            );
10232            unregisterRoom(room, { sendDisconnectSignal: false });
10233          }
10234        }
10235        for (const room of requestedRooms) {
10236          if (forbiddenRooms.includes(room.room)) {
10237            continue;
10238          }
10239          if (!roomStates.has(room.room)) {
10240            continue;
10241          }
10242          const remainingState = roomStates.get(room.room);
10243          if (room.updates.length > 0) {
10244            remainingState.updateQueue.restore(room.updates);
10245          }
10246        }
10247      } else {
10248        const rooms = [...roomStates.keys()];
10249        for (const room of rooms) {
10250          const state = roomStates.get(room);
10251          if (state) {
10252            state.log(
10253              "Permission denied, unregistering room",
10254              { error },
10255              "error",
10256              true
10257              // force
10258            );
10259            unregisterRoom(room, { sendDisconnectSignal: false });
10260          }
10261        }
10262      }
10263    }
10264    var roomStates = /* @__PURE__ */ new Map();
10265    function createDeprecatedCompactionUpdate(updates) {
10266      const mergeable = updates.filter(
10267        (u) => [SyncUpdateType.COMPACTION, SyncUpdateType.UPDATE].includes(
10268          u.type
10269        )
10270      ).map((u) => base64ToUint8Array(u.data));
10271      return createSyncUpdate(
10272        mergeUpdatesV2(mergeable),
10273        SyncUpdateType.COMPACTION
10274      );
10275    }
10276    function createSyncStep1Update(doc2) {
10277      const encoder = createEncoder();
10278      writeSyncStep1(encoder, doc2);
10279      return createSyncUpdate(
10280        toUint8Array(encoder),
10281        SyncUpdateType.SYNC_STEP_1
10282      );
10283    }
10284    function createSyncStep2Update(doc2, step1) {
10285      const decoder = createDecoder(step1);
10286      const encoder = createEncoder();
10287      readSyncMessage(
10288        decoder,
10289        encoder,
10290        doc2,
10291        POLLING_MANAGER_ORIGIN
10292      );
10293      return createSyncUpdate(
10294        toUint8Array(encoder),
10295        SyncUpdateType.SYNC_STEP_2
10296      );
10297    }
10298    function processAwarenessUpdate(state, awareness) {
10299      const currentStates = awareness.getStates();
10300      const added = /* @__PURE__ */ new Set();
10301      const updated = /* @__PURE__ */ new Set();
10302      const removed = new Set(
10303        Array.from(currentStates.keys()).filter(
10304          (clientId) => !state[clientId]
10305        )
10306      );
10307      Object.entries(state).forEach(([clientIdString, awarenessState]) => {
10308        const clientId = Number(clientIdString);
10309        if (clientId === awareness.clientID) {
10310          return;
10311        }
10312        if (null === awarenessState) {
10313          currentStates.delete(clientId);
10314          removed.add(clientId);
10315          return;
10316        }
10317        if (!currentStates.has(clientId)) {
10318          currentStates.set(clientId, awarenessState);
10319          added.add(clientId);
10320          return;
10321        }
10322        const currentState = currentStates.get(clientId);
10323        if (JSON.stringify(currentState) !== JSON.stringify(awarenessState)) {
10324          currentStates.set(clientId, awarenessState);
10325          updated.add(clientId);
10326        }
10327      });
10328      if (added.size + updated.size > 0) {
10329        awareness.emit("change", [
10330          {
10331            added: Array.from(added),
10332            updated: Array.from(updated),
10333            // Left blank on purpose, as the removal of clients is handled in the if condition below.
10334            removed: []
10335          }
10336        ]);
10337      }
10338      if (removed.size > 0) {
10339        removeAwarenessStates(
10340          awareness,
10341          Array.from(removed),
10342          POLLING_MANAGER_ORIGIN
10343        );
10344      }
10345    }
10346    function processDocUpdate(update, doc2) {
10347      const data = base64ToUint8Array(update.data);
10348      switch (update.type) {
10349        case SyncUpdateType.SYNC_STEP_1: {
10350          return createSyncStep2Update(doc2, data);
10351        }
10352        case SyncUpdateType.SYNC_STEP_2: {
10353          const decoder = createDecoder(data);
10354          const encoder = createEncoder();
10355          readSyncMessage(
10356            decoder,
10357            encoder,
10358            doc2,
10359            POLLING_MANAGER_ORIGIN
10360          );
10361          return;
10362        }
10363        case SyncUpdateType.COMPACTION:
10364        case SyncUpdateType.UPDATE: {
10365          applyUpdateV2(doc2, data, POLLING_MANAGER_ORIGIN);
10366        }
10367      }
10368    }
10369    function checkConnectionLimit(awareness, roomState) {
10370      if (!roomState.isPrimaryRoom || hasCheckedConnectionLimit) {
10371        return false;
10372      }
10373      hasCheckedConnectionLimit = true;
10374      const maxClientsPerRoom = (0, import_hooks2.applyFilters)(
10375        "sync.pollingProvider.maxClientsPerRoom",
10376        DEFAULT_CLIENT_LIMIT_PER_ROOM,
10377        roomState.room
10378      );
10379      const clientCount = Object.keys(awareness).length;
10380      const validatedLimit = intValueOrDefault(
10381        maxClientsPerRoom,
10382        DEFAULT_CLIENT_LIMIT_PER_ROOM
10383      );
10384      if (clientCount > validatedLimit) {
10385        roomState.log("Connection limit exceeded", {
10386          clientCount,
10387          maxClientsPerRoom: validatedLimit,
10388          room: roomState.room
10389        });
10390        return true;
10391      }
10392      return false;
10393    }
10394    var areListenersRegistered = false;
10395    var consecutiveFailures = 0;
10396    var hasCheckedConnectionLimit = false;
10397    var isManualRetry = false;
10398    var hasCollaborators = false;
10399    var isActiveBrowser = "visible" === document.visibilityState;
10400    var isPolling = false;
10401    var isUnloadPending = false;
10402    var pollInterval = POLLING_INTERVAL_IN_MS;
10403    var pollingTimeoutId = null;
10404    var syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10405    var roomOverflowOffset = 0;
10406    function handleBeforeUnload() {
10407      isUnloadPending = true;
10408    }
10409    function handlePageHide() {
10410      const rooms = Array.from(roomStates.entries()).map(
10411        ([room, state]) => ({
10412          after: 0,
10413          awareness: null,
10414          client_id: state.clientId,
10415          room,
10416          updates: []
10417        })
10418      );
10419      for (let i = 0; i < rooms.length; i += MAX_ROOMS_PER_REQUEST) {
10420        postSyncUpdateNonBlocking({
10421          rooms: rooms.slice(i, i + MAX_ROOMS_PER_REQUEST)
10422        });
10423      }
10424    }
10425    function handleVisibilityChange() {
10426      const wasActive = isActiveBrowser;
10427      isActiveBrowser = document.visibilityState === "visible";
10428      if (isActiveBrowser && !wasActive) {
10429        if (pollingTimeoutId) {
10430          clearTimeout(pollingTimeoutId);
10431          pollingTimeoutId = null;
10432          poll();
10433        }
10434      }
10435    }
10436    function selectRoomsForRequest() {
10437      const allRooms = Array.from(roomStates.values());
10438      if (allRooms.length <= MAX_ROOMS_PER_REQUEST) {
10439        return allRooms;
10440      }
10441      const primaryRoom = allRooms.find((state) => state.isPrimaryRoom);
10442      const overflowRooms = allRooms.filter((state) => state !== primaryRoom);
10443      const overflowSlotsPerRequest = MAX_ROOMS_PER_REQUEST - (primaryRoom ? 1 : 0);
10444      const { window: overflowSlice, nextOffset } = rotateWindow(
10445        overflowRooms,
10446        roomOverflowOffset,
10447        overflowSlotsPerRequest
10448      );
10449      roomOverflowOffset = nextOffset;
10450      if (primaryRoom) {
10451        return [primaryRoom, ...overflowSlice];
10452      }
10453      return overflowSlice;
10454    }
10455    var textEncoder = new TextEncoder();
10456    function getJsonByteLength(value) {
10457      return textEncoder.encode(JSON.stringify(value)).byteLength;
10458    }
10459    function createPayloadRoom(state, updates = []) {
10460      return {
10461        after: state.endCursor ?? 0,
10462        awareness: state.localAwarenessState,
10463        client_id: state.clientId,
10464        room: state.room,
10465        updates
10466      };
10467    }
10468    function getUpdatePayloadSizeDelta(existingUpdateCount, update) {
10469      const commaSize = existingUpdateCount === 0 ? 0 : 1;
10470      return commaSize + getJsonByteLength(update);
10471    }
10472    function buildPayloadForRequest(selectedRoomStates) {
10473      const payload = { rooms: [] };
10474      const roomsInRequest = [];
10475      for (const state of selectedRoomStates) {
10476        const room = createPayloadRoom(state);
10477        const candidate = { rooms: [...payload.rooms, room] };
10478        if (payload.rooms.length > 0 && getJsonByteLength(candidate) > syncRequestBodySizeLimit) {
10479          break;
10480        }
10481        payload.rooms.push(room);
10482        roomsInRequest.push(state);
10483      }
10484      const pendingUpdates = roomsInRequest.map(
10485        (state) => state.updateQueue.peek()
10486      );
10487      const sentUpdateCounts = roomsInRequest.map(() => 0);
10488      let payloadSize = getJsonByteLength(payload);
10489      let addedUpdate = true;
10490      while (addedUpdate) {
10491        addedUpdate = false;
10492        for (let i = 0; i < roomsInRequest.length; i++) {
10493          const update = pendingUpdates[i][sentUpdateCounts[i]];
10494          if (!update) {
10495            continue;
10496          }
10497          const sizeDelta = getUpdatePayloadSizeDelta(
10498            sentUpdateCounts[i],
10499            update
10500          );
10501          if (payloadSize + sizeDelta > syncRequestBodySizeLimit) {
10502            continue;
10503          }
10504          sentUpdateCounts[i]++;
10505          payloadSize += sizeDelta;
10506          addedUpdate = true;
10507        }
10508      }
10509      for (let i = 0; i < roomsInRequest.length; i++) {
10510        payload.rooms[i].updates = roomsInRequest[i].updateQueue.take(
10511          sentUpdateCounts[i]
10512        );
10513      }
10514      return { payload, roomsInRequest };
10515    }
10516    function restoreExactUpdates(payload) {
10517      for (const room of payload.rooms) {
10518        if (!roomStates.has(room.room) || room.updates.length === 0) {
10519          continue;
10520        }
10521        roomStates.get(room.room).updateQueue.restoreExact(room.updates);
10522      }
10523    }
10524    function poll() {
10525      isPolling = true;
10526      pollingTimeoutId = null;
10527      async function start() {
10528        if (0 === roomStates.size) {
10529          isPolling = false;
10530          return;
10531        }
10532        isUnloadPending = false;
10533        const { payload, roomsInRequest } = buildPayloadForRequest(
10534          selectRoomsForRequest()
10535        );
10536        roomsInRequest.forEach((state) => {
10537          state.onStatusChange({ status: "connecting" });
10538        });
10539        try {
10540          const { rooms } = await postSyncUpdate(payload);
10541          consecutiveFailures = 0;
10542          isManualRetry = false;
10543          syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10544          roomsInRequest.forEach((state) => {
10545            if (roomStates.get(state.room) !== state) {
10546              return;
10547            }
10548            state.onStatusChange({ status: "connected" });
10549          });
10550          hasCollaborators = false;
10551          rooms.forEach((room) => {
10552            if (!roomStates.has(room.room)) {
10553              return;
10554            }
10555            const roomState = roomStates.get(room.room);
10556            roomState.endCursor = room.end_cursor;
10557            if (checkConnectionLimit(room.awareness, roomState)) {
10558              roomState.onStatusChange({
10559                status: "disconnected",
10560                error: new ConnectionError(
10561                  ConnectionErrorCode.CONNECTION_LIMIT_EXCEEDED,
10562                  "Connection limit exceeded"
10563                )
10564              });
10565              unregisterRoom(room.room);
10566              return;
10567            }
10568            roomState.processAwarenessUpdate(room.awareness);
10569            if (roomState.isPrimaryRoom && Object.keys(room.awareness).length > 1) {
10570              hasCollaborators = true;
10571              roomStates.forEach((state) => {
10572                state.updateQueue.resume();
10573              });
10574            }
10575            const responseUpdates = [];
10576            for (const update of room.updates) {
10577              try {
10578                const response = roomState.processDocUpdate(update);
10579                if (response) {
10580                  responseUpdates.push(response);
10581                }
10582              } catch (error) {
10583                roomState.log(
10584                  "Failed to apply sync update",
10585                  { error, update },
10586                  "error",
10587                  true
10588                  // force
10589                );
10590              }
10591            }
10592            roomState.updateQueue.addBulk(responseUpdates);
10593            if (room.should_compact) {
10594              roomState.log("Server requested compaction update");
10595              roomState.updateQueue.clear();
10596              roomState.updateQueue.add(
10597                roomState.createCompactionUpdate()
10598              );
10599            } else if (room.compaction_request) {
10600              roomState.log("Server requested (old) compaction update");
10601              roomState.updateQueue.add(
10602                createDeprecatedCompactionUpdate(
10603                  room.compaction_request
10604                )
10605              );
10606            }
10607          });
10608          if (isActiveBrowser && hasCollaborators) {
10609            pollInterval = POLLING_INTERVAL_WITH_COLLABORATORS_IN_MS;
10610          } else if (isActiveBrowser) {
10611            pollInterval = POLLING_INTERVAL_IN_MS;
10612          } else {
10613            pollInterval = POLLING_INTERVAL_BACKGROUND_TAB_IN_MS;
10614          }
10615        } catch (error) {
10616          if (isForbiddenError(error)) {
10617            handleForbiddenError(error, payload.rooms);
10618            if (roomStates.size === 0) {
10619              isPolling = false;
10620              return;
10621            }
10622          } else if (isRequestBodyTooLargeError(error)) {
10623            syncRequestBodySizeLimit = Math.max(
10624              MIN_SYNC_REQUEST_BODY_SIZE_LIMIT_IN_BYTES,
10625              Math.floor(syncRequestBodySizeLimit / 2)
10626            );
10627            pollInterval = hasCollaborators ? ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS[0] : ERROR_RETRY_DELAYS_SOLO_MS[0];
10628            restoreExactUpdates(payload);
10629            for (const room of payload.rooms) {
10630              if (!roomStates.has(room.room)) {
10631                continue;
10632              }
10633              roomStates.get(room.room).log(
10634                "Sync request body too large, retrying with smaller batches",
10635                {
10636                  error,
10637                  nextPoll: pollInterval,
10638                  syncRequestBodySizeLimit
10639                },
10640                "error",
10641                true
10642                // force
10643              );
10644            }
10645          } else if (isProtocolMismatchError(error)) {
10646            const affectedRooms = [...roomStates.entries()];
10647            for (const [, state] of affectedRooms) {
10648              state.onStatusChange({
10649                status: "disconnected",
10650                error: new ConnectionError(
10651                  ConnectionErrorCode.PROTOCOL_MISMATCH,
10652                  "Protocol mismatch between client and server"
10653                )
10654              });
10655            }
10656            for (const [room] of affectedRooms) {
10657              unregisterRoom(room, { sendDisconnectSignal: false });
10658            }
10659            isPolling = false;
10660            return;
10661          } else {
10662            consecutiveFailures++;
10663            const retrySchedule = hasCollaborators ? ERROR_RETRY_DELAYS_WITH_COLLABORATORS_MS : ERROR_RETRY_DELAYS_SOLO_MS;
10664            if (consecutiveFailures <= retrySchedule.length) {
10665              pollInterval = retrySchedule[consecutiveFailures - 1];
10666            } else {
10667              pollInterval = DISCONNECT_DIALOG_RETRY_MS;
10668            }
10669            if (isManualRetry) {
10670              pollInterval = MANUAL_RETRY_INTERVAL_MS;
10671              isManualRetry = false;
10672            }
10673            for (const room of payload.rooms) {
10674              if (!roomStates.has(room.room)) {
10675                continue;
10676              }
10677              const state = roomStates.get(room.room);
10678              if (room.updates.length > 0 && state.endCursor > 0) {
10679                state.updateQueue.clear();
10680                state.updateQueue.add(state.createCompactionUpdate());
10681              } else if (room.updates.length > 0) {
10682                state.updateQueue.restore(room.updates);
10683              }
10684              state.log(
10685                "Error posting sync update, will retry with backoff",
10686                { error, nextPoll: pollInterval },
10687                "error",
10688                true
10689                // force
10690              );
10691            }
10692            if (!isUnloadPending) {
10693              const backgroundRetriesFailed = consecutiveFailures > retrySchedule.length;
10694              roomsInRequest.forEach((state) => {
10695                if (roomStates.get(state.room) !== state) {
10696                  return;
10697                }
10698                state.onStatusChange({
10699                  status: "disconnected",
10700                  canManuallyRetry: true,
10701                  consecutiveFailures,
10702                  backgroundRetriesFailed,
10703                  willAutoRetryInMs: pollInterval
10704                });
10705              });
10706            }
10707          }
10708        }
10709        pollingTimeoutId = setTimeout(poll, pollInterval);
10710      }
10711      void start();
10712    }
10713    function registerRoom({
10714      room,
10715      doc: doc2,
10716      awareness,
10717      log,
10718      onStatusChange
10719    }) {
10720      if (roomStates.has(room)) {
10721        return;
10722      }
10723      const updateQueue = createUpdateQueue([createSyncStep1Update(doc2)]);
10724      const isPrimaryRoom = 0 === roomStates.size;
10725      function onAwarenessUpdate() {
10726        roomState.localAwarenessState = awareness.getLocalState() ?? {};
10727      }
10728      function onDocUpdate(update, origin2) {
10729        if (POLLING_MANAGER_ORIGIN === origin2) {
10730          return;
10731        }
10732        if (update.byteLength > MAX_UPDATE_SIZE_IN_BYTES) {
10733          const state = roomStates.get(room);
10734          if (!state) {
10735            return;
10736          }
10737          state.log("Document size limit exceeded", {
10738            maxUpdateSizeInBytes: MAX_UPDATE_SIZE_IN_BYTES,
10739            updateSizeInBytes: update.byteLength
10740          });
10741          state.onStatusChange({
10742            status: "disconnected",
10743            error: new ConnectionError(
10744              ConnectionErrorCode.DOCUMENT_SIZE_LIMIT_EXCEEDED,
10745              "Document size limit exceeded"
10746            )
10747          });
10748          unregisterRoom(room);
10749          return;
10750        }
10751        updateQueue.add(createSyncUpdate(update, SyncUpdateType.UPDATE));
10752      }
10753      function unregister() {
10754        doc2.off("updateV2", onDocUpdate);
10755        awareness.off("change", onAwarenessUpdate);
10756        updateQueue.clear();
10757      }
10758      const roomState = {
10759        clientId: doc2.clientID,
10760        createCompactionUpdate: () => createSyncUpdate(
10761          encodeStateAsUpdateV2(doc2),
10762          SyncUpdateType.COMPACTION
10763        ),
10764        endCursor: 0,
10765        isPrimaryRoom,
10766        localAwarenessState: awareness.getLocalState() ?? {},
10767        log,
10768        onStatusChange,
10769        processAwarenessUpdate: (state) => processAwarenessUpdate(state, awareness),
10770        processDocUpdate: (update) => processDocUpdate(update, doc2),
10771        room,
10772        unregister,
10773        updateQueue
10774      };
10775      doc2.on("updateV2", onDocUpdate);
10776      awareness.on("change", onAwarenessUpdate);
10777      roomStates.set(room, roomState);
10778      if (!areListenersRegistered) {
10779        window.addEventListener("beforeunload", handleBeforeUnload);
10780        window.addEventListener("pagehide", handlePageHide);
10781        document.addEventListener("visibilitychange", handleVisibilityChange);
10782        areListenersRegistered = true;
10783      }
10784      if (!isPolling) {
10785        poll();
10786      }
10787    }
10788    function unregisterRoom(room, { sendDisconnectSignal = true } = {}) {
10789      const state = roomStates.get(room);
10790      if (state) {
10791        if (sendDisconnectSignal) {
10792          const rooms = [
10793            {
10794              after: 0,
10795              awareness: null,
10796              client_id: state.clientId,
10797              room,
10798              updates: []
10799            }
10800          ];
10801          postSyncUpdateNonBlocking({ rooms });
10802        }
10803        state.unregister();
10804        roomStates.delete(room);
10805      }
10806      if (0 === roomStates.size && areListenersRegistered) {
10807        window.removeEventListener("beforeunload", handleBeforeUnload);
10808        window.removeEventListener("pagehide", handlePageHide);
10809        document.removeEventListener(
10810          "visibilitychange",
10811          handleVisibilityChange
10812        );
10813        areListenersRegistered = false;
10814        hasCheckedConnectionLimit = false;
10815        consecutiveFailures = 0;
10816        roomOverflowOffset = 0;
10817        syncRequestBodySizeLimit = MAX_SYNC_REQUEST_BODY_SIZE_IN_BYTES;
10818      }
10819    }
10820    function retryNow() {
10821      isManualRetry = true;
10822      if (pollingTimeoutId) {
10823        clearTimeout(pollingTimeoutId);
10824        pollingTimeoutId = null;
10825        poll();
10826      }
10827    }
10828    var pollingManager = {
10829      registerRoom,
10830      retryNow,
10831      unregisterRoom
10832    };
10833  
10834    // packages/sync/build-module/providers/http-polling/http-polling-provider.mjs
10835    var HttpPollingProvider = class extends ObservableV2 {
10836      constructor(options) {
10837        super();
10838        this.options = options;
10839        this.log("Initializing", { room: options.room });
10840        this.awareness = options.awareness ?? new Awareness(options.ydoc);
10841        this.connect();
10842      }
10843      awareness;
10844      status = "disconnected";
10845      /**
10846       * Connect to the endpoint and initialize sync.
10847       */
10848      connect() {
10849        this.log("Connecting");
10850        pollingManager.registerRoom({
10851          room: this.options.room,
10852          doc: this.options.ydoc,
10853          awareness: this.awareness,
10854          log: this.log,
10855          onStatusChange: this.emitStatus
10856        });
10857      }
10858      /**
10859       * Destroy the provider and cleanup resources.
10860       */
10861      destroy() {
10862        this.disconnect();
10863        super.destroy();
10864      }
10865      /**
10866       * Disconnect the provider and allow reconnection later.
10867       */
10868      disconnect() {
10869        this.log("Disconnecting");
10870        pollingManager.unregisterRoom(this.options.room);
10871        this.emitStatus({ status: "disconnected" });
10872      }
10873      /**
10874       * Emit connection status, passing the full object through so that
10875       * additional fields (e.g. `willAutoRetryInMs`) are preserved for consumers.
10876       *
10877       * @param connectionStatus The connection status object
10878       */
10879      emitStatus = (connectionStatus) => {
10880        const { status } = connectionStatus;
10881        const error = status === "disconnected" ? connectionStatus.error : void 0;
10882        if (this.status === status && !error) {
10883          return;
10884        }
10885        if (status === "connecting" && this.status !== "disconnected") {
10886          return;
10887        }
10888        this.log("Status change", { status, error });
10889        this.status = status;
10890        this.emit("status", [connectionStatus]);
10891      };
10892      /**
10893       * Log debug messages if debugging is enabled.
10894       *
10895       * @param message    The debug message
10896       * @param debug      Additional debug information
10897       * @param errorLevel The console method to use for logging
10898       * @param force      Whether to force logging regardless of debug setting
10899       */
10900      log = (message, debug = {}, errorLevel = "log", force = false) => {
10901        if (!this.options.debug && !force) {
10902          return;
10903        }
10904        const logFn = console[errorLevel] || console.log;
10905        logFn(`[$this.constructor.name}]: $message}`, {
10906          room: this.options.room,
10907          ...debug
10908        });
10909      };
10910    };
10911    function createHttpPollingProvider() {
10912      return async ({
10913        awareness,
10914        objectType,
10915        objectId,
10916        ydoc
10917      }) => {
10918        const room = objectId ? `$objectType}:$objectId}` : objectType;
10919        const provider = new HttpPollingProvider({
10920          awareness,
10921          // debug: true,
10922          room,
10923          ydoc
10924        });
10925        return {
10926          destroy: () => provider.destroy(),
10927          // Adapter: ObservableV2.on is compatible with ProviderOn
10928          // The callback receives data as the first parameter
10929          on: (event, callback) => {
10930            provider.on(event, callback);
10931          }
10932        };
10933      };
10934    }
10935  
10936    // packages/sync/build-module/providers/index.mjs
10937    var providerCreators = null;
10938    function getDefaultProviderCreators() {
10939      return window.__experimentalEnableRealTimeCollaboration ? [createHttpPollingProvider()] : [];
10940    }
10941    function isProviderCreator(creator) {
10942      return "function" === typeof creator;
10943    }
10944    function getProviderCreators() {
10945      if (providerCreators) {
10946        return providerCreators;
10947      }
10948      if (!window.__experimentalEnableRealTimeCollaboration) {
10949        return [];
10950      }
10951      const filteredProviderCreators = (0, import_hooks3.applyFilters)(
10952        "sync.providers",
10953        getDefaultProviderCreators()
10954      );
10955      if (!Array.isArray(filteredProviderCreators)) {
10956        providerCreators = [];
10957        return providerCreators;
10958      }
10959      providerCreators = filteredProviderCreators.filter(isProviderCreator);
10960      return providerCreators;
10961    }
10962  
10963    // packages/sync/build-module/y-utilities/y-multidoc-undomanager.mjs
10964    var popStackItem2 = (mum, type) => {
10965      const stack = type === "undo" ? mum.undoStack : mum.redoStack;
10966      while (stack.length > 0) {
10967        const um = (
10968          /** @type {Y.UndoManager} */
10969          stack.pop()
10970        );
10971        const prevUmStack = type === "undo" ? um.undoStack : um.redoStack;
10972        const stackItem = (
10973          /** @type {any} */
10974          prevUmStack.pop()
10975        );
10976        let actionPerformed = false;
10977        if (type === "undo") {
10978          um.undoStack = [stackItem];
10979          actionPerformed = um.undo() !== null;
10980          um.undoStack = prevUmStack;
10981        } else {
10982          um.redoStack = [stackItem];
10983          actionPerformed = um.redo() !== null;
10984          um.redoStack = prevUmStack;
10985        }
10986        if (actionPerformed) {
10987          return stackItem;
10988        }
10989      }
10990      return null;
10991    };
10992    var YMultiDocUndoManager = class extends Observable {
10993      /**
10994       * @param {Y.AbstractType<any>|Array<Y.AbstractType<any>>} typeScope Accepts either a single type, or an array of types
10995       * @param {ConstructorParameters<typeof Y.UndoManager>[1]} opts
10996       */
10997      constructor(typeScope = [], opts = {}) {
10998        super();
10999        this.docs = /* @__PURE__ */ new Map();
11000        this.trackedOrigins = opts.trackedOrigins || /* @__PURE__ */ new Set([null]);
11001        opts.trackedOrigins = this.trackedOrigins;
11002        this._defaultOpts = opts;
11003        this.undoStack = [];
11004        this.redoStack = [];
11005        this.addToScope(typeScope);
11006      }
11007      /**
11008       * @param {Array<Y.AbstractType<any>> | Y.AbstractType<any>} ytypes
11009       */
11010      addToScope(ytypes) {
11011        ytypes = isArray(ytypes) ? ytypes : [ytypes];
11012        ytypes.forEach((ytype) => {
11013          const ydoc = (
11014            /** @type {Y.Doc} */
11015            ytype.doc
11016          );
11017          const um = setIfUndefined(this.docs, ydoc, () => {
11018            const um2 = new UndoManager([ytype], this._defaultOpts);
11019            um2.on(
11020              "stack-cleared",
11021              /** @param {any} opts */
11022              ({
11023                undoStackCleared,
11024                redoStackCleared
11025              }) => {
11026                this.clear(undoStackCleared, redoStackCleared);
11027              }
11028            );
11029            ydoc.on("destroy", () => {
11030              this.docs.delete(ydoc);
11031              this.undoStack = this.undoStack.filter(
11032                (um3) => um3.doc !== ydoc
11033              );
11034              this.redoStack = this.redoStack.filter(
11035                (um3) => um3.doc !== ydoc
11036              );
11037            });
11038            um2.on(
11039              "stack-item-added",
11040              /** @param {any} change */
11041              (change) => {
11042                const stack = change.type === "undo" ? this.undoStack : this.redoStack;
11043                stack.push(um2);
11044                this.emit("stack-item-added", [
11045                  { ...change, ydoc },
11046                  this
11047                ]);
11048              }
11049            );
11050            um2.on(
11051              "stack-item-updated",
11052              /** @param {any} change */
11053              (change) => {
11054                this.emit("stack-item-updated", [
11055                  { ...change, ydoc },
11056                  this
11057                ]);
11058              }
11059            );
11060            um2.on(
11061              "stack-item-popped",
11062              /** @param {any} change */
11063              (change) => {
11064                this.emit("stack-item-popped", [
11065                  { ...change, ydoc },
11066                  this
11067                ]);
11068              }
11069            );
11070            return um2;
11071          });
11072          if (um.scope.every((yt) => yt !== ytype)) {
11073            um.scope.push(ytype);
11074          }
11075        });
11076      }
11077      /**
11078       * @param {any} origin
11079       */
11080      /* c8 ignore next 3 */
11081      addTrackedOrigin(origin2) {
11082        this.trackedOrigins.add(origin2);
11083      }
11084      /**
11085       * @param {any} origin
11086       */
11087      /* c8 ignore next 3 */
11088      removeTrackedOrigin(origin2) {
11089        this.trackedOrigins.delete(origin2);
11090      }
11091      /**
11092       * Undo last changes on type.
11093       *
11094       * @return {any?} Returns StackItem if a change was applied
11095       */
11096      undo() {
11097        return popStackItem2(this, "undo");
11098      }
11099      /**
11100       * Redo last undo operation.
11101       *
11102       * @return {any?} Returns StackItem if a change was applied
11103       */
11104      redo() {
11105        return popStackItem2(this, "redo");
11106      }
11107      clear(clearUndoStack = true, clearRedoStack = true) {
11108        if (clearUndoStack && this.canUndo() || clearRedoStack && this.canRedo()) {
11109          this.docs.forEach((um) => {
11110            clearUndoStack && (this.undoStack = []);
11111            clearRedoStack && (this.redoStack = []);
11112            um.clear(clearUndoStack, clearRedoStack);
11113          });
11114          this.emit("stack-cleared", [
11115            {
11116              undoStackCleared: clearUndoStack,
11117              redoStackCleared: clearRedoStack
11118            }
11119          ]);
11120        }
11121      }
11122      /* c8 ignore next 5 */
11123      stopCapturing() {
11124        this.docs.forEach((um) => {
11125          um.stopCapturing();
11126        });
11127      }
11128      /**
11129       * Are undo steps available?
11130       *
11131       * @return {boolean} `true` if undo is possible
11132       */
11133      canUndo() {
11134        return this.undoStack.length > 0;
11135      }
11136      /**
11137       * Are redo steps available?
11138       *
11139       * @return {boolean} `true` if redo is possible
11140       */
11141      canRedo() {
11142        return this.redoStack.length > 0;
11143      }
11144      destroy() {
11145        this.docs.forEach((um) => um.destroy());
11146        super.destroy();
11147      }
11148    };
11149  
11150    // packages/sync/build-module/undo-manager.mjs
11151    function createUndoManager() {
11152      const undoMetaHandlers = /* @__PURE__ */ new Map();
11153      const yUndoManager = new YMultiDocUndoManager([], {
11154        // Throttle undo/redo captures after 500ms of inactivity.
11155        // 500 was selected from subjective local UX testing, shorter timeouts
11156        // may cause mid-word undo stack items.
11157        captureTimeout: 500,
11158        // Ensure that we only scope the undo/redo to the current editor.
11159        // The yjs document's clientID is added once it's available.
11160        trackedOrigins: /* @__PURE__ */ new Set([LOCAL_EDITOR_ORIGIN])
11161      });
11162      const getUndoStackState = () => ({
11163        hasRedo: yUndoManager.canRedo(),
11164        hasUndo: yUndoManager.canUndo()
11165      });
11166      const notifyUndoStackChange = (ydoc) => {
11167        undoMetaHandlers.get(ydoc)?.onUndoStackChange?.(getUndoStackState());
11168      };
11169      yUndoManager.on("stack-item-added", (event) => {
11170        const handlers = undoMetaHandlers.get(event.ydoc);
11171        if (!handlers) {
11172          return;
11173        }
11174        handlers.addUndoMeta(event.ydoc, event.stackItem.meta);
11175        notifyUndoStackChange(event.ydoc);
11176      });
11177      yUndoManager.on("stack-item-updated", (event) => {
11178        notifyUndoStackChange(event.ydoc);
11179      });
11180      yUndoManager.on("stack-item-popped", (event) => {
11181        const handlers = undoMetaHandlers.get(event.ydoc);
11182        if (!handlers) {
11183          return;
11184        }
11185        handlers.restoreUndoMeta(event.ydoc, event.stackItem.meta);
11186        notifyUndoStackChange(event.ydoc);
11187      });
11188      yUndoManager.on("stack-cleared", () => {
11189        undoMetaHandlers.forEach((handlers) => {
11190          handlers.onUndoStackChange?.(getUndoStackState());
11191        });
11192      });
11193      return {
11194        /**
11195         * Record changes into the history.
11196         * Since Yjs automatically tracks changes, this method translates the WordPress
11197         * HistoryRecord format into Yjs operations.
11198         *
11199         * @param _record   A record of changes to record.
11200         * @param _isStaged Whether to immediately create an undo point or not.
11201         */
11202        addRecord(_record, _isStaged = false) {
11203        },
11204        /**
11205         * Add a Yjs map to the scope of the undo manager.
11206         *
11207         * @param {Y.Map< any >} ymap                       The Yjs map to add to the scope.
11208         * @param                handlers                   Handlers for the scoped document.
11209         * @param                handlers.addUndoMeta       Handler to add metadata to undo items.
11210         * @param                handlers.onUndoStackChange Handler for undo stack changes.
11211         * @param                handlers.restoreUndoMeta   Handler to restore metadata from undo items.
11212         */
11213        addToScope(ymap, handlers) {
11214          if (ymap.doc === null) {
11215            return;
11216          }
11217          const ydoc = ymap.doc;
11218          yUndoManager.addToScope(ymap);
11219          if (!undoMetaHandlers.has(ydoc)) {
11220            ydoc.on("destroy", () => undoMetaHandlers.delete(ydoc));
11221          }
11222          undoMetaHandlers.set(ydoc, handlers);
11223        },
11224        /**
11225         * Undo the last recorded changes.
11226         *
11227         */
11228        undo() {
11229          if (!yUndoManager.canUndo()) {
11230            return;
11231          }
11232          yUndoManager.undo();
11233          return [];
11234        },
11235        /**
11236         * Redo the last undone changes.
11237         */
11238        redo() {
11239          if (!yUndoManager.canRedo()) {
11240            return;
11241          }
11242          yUndoManager.redo();
11243          return [];
11244        },
11245        /**
11246         * Check if there are changes that can be undone.
11247         *
11248         * @return {boolean} Whether there are changes to undo.
11249         */
11250        hasUndo() {
11251          return yUndoManager.canUndo();
11252        },
11253        /**
11254         * Check if there are changes that can be redone.
11255         *
11256         * @return {boolean} Whether there are changes to redo.
11257         */
11258        hasRedo() {
11259          return yUndoManager.canRedo();
11260        },
11261        /**
11262         * Stop capturing changes into the current undo item.
11263         * The next change will create a new undo item.
11264         */
11265        stopCapturing() {
11266          yUndoManager.stopCapturing();
11267        }
11268      };
11269    }
11270  
11271    // packages/sync/build-module/crdt-snapshot.mjs
11272    function encodeDocSnapshot(ydoc) {
11273      return toBase64(encodeSnapshotV2(snapshot(ydoc)));
11274    }
11275    function docContainsSnapshot(ydoc, encodedSnapshot) {
11276      let snapshot2;
11277      try {
11278        snapshot2 = decodeSnapshotV2(fromBase64(encodedSnapshot));
11279      } catch {
11280        return false;
11281      }
11282      const localSnapshot = snapshot(ydoc);
11283      for (const [client, clock] of snapshot2.sv) {
11284        if ((localSnapshot.sv.get(client) ?? 0) < clock) {
11285          return false;
11286        }
11287      }
11288      const copiedDeleteSet = snapshot(ydoc).ds;
11289      const mergedDeleteSet = mergeDeleteSets([
11290        copiedDeleteSet,
11291        snapshot2.ds
11292      ]);
11293      return equalDeleteSets(localSnapshot.ds, mergedDeleteSet);
11294    }
11295  
11296    // packages/sync/build-module/utils.mjs
11297    function createYjsDoc(documentMeta = {}) {
11298      const metaMap = new Map(
11299        Object.entries(documentMeta)
11300      );
11301      return new Doc({ meta: metaMap });
11302    }
11303    function initializeYjsDoc(ydoc) {
11304      const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11305      stateMap.set(CRDT_STATE_MAP_VERSION_KEY, CRDT_DOC_VERSION);
11306    }
11307    function markEntityAsSaved(ydoc) {
11308      const recordMeta = ydoc.getMap(CRDT_STATE_MAP_KEY);
11309      recordMeta.set(CRDT_STATE_MAP_SAVED_AT_KEY, Date.now());
11310      recordMeta.set(CRDT_STATE_MAP_SAVED_BY_KEY, ydoc.clientID);
11311    }
11312    function pseudoRandomID() {
11313      return Math.floor(Math.random() * 1e9);
11314    }
11315    function serializeCrdtDoc(crdtDoc) {
11316      const tempDoc = createYjsDoc();
11317      applyUpdateV2(tempDoc, encodeStateAsUpdateV2(crdtDoc));
11318      const compactedUpdate = encodeStateAsUpdateV2(tempDoc);
11319      tempDoc.destroy();
11320      return JSON.stringify({
11321        document: toBase64(compactedUpdate),
11322        updateId: pseudoRandomID()
11323        // helps with debugging
11324      });
11325    }
11326    function deserializeCrdtDoc(serializedCrdtDoc) {
11327      try {
11328        const { document: document2 } = JSON.parse(serializedCrdtDoc);
11329        const docMeta = {
11330          [CRDT_DOC_META_PERSISTENCE_KEY]: true
11331        };
11332        const ydoc = createYjsDoc(docMeta);
11333        const yupdate = fromBase64(document2);
11334        applyUpdateV2(ydoc, yupdate);
11335        ydoc.clientID = pseudoRandomID();
11336        return ydoc;
11337      } catch {
11338        return null;
11339      }
11340    }
11341  
11342    // packages/sync/build-module/manager.mjs
11343    function getEntityId(objectType, objectId) {
11344      return `$objectType}_$objectId}`;
11345    }
11346    function createSyncManager(debug = false) {
11347      const debugWrap = debug ? logPerformanceTiming : passThru;
11348      const collectionStates = /* @__PURE__ */ new Map();
11349      const entityStates = /* @__PURE__ */ new Map();
11350      let undoManager;
11351      function log(component, message, entityId, context = {}) {
11352        if (!debug) {
11353          return;
11354        }
11355        console.log(`[SyncManager][$component}]: $message}`, {
11356          ...context,
11357          entityId
11358        });
11359      }
11360      async function loadEntity(syncConfig, objectType, objectId, record, handlers) {
11361        const providerCreators2 = getProviderCreators();
11362        const entityId = getEntityId(objectType, objectId);
11363        if (0 === providerCreators2.length) {
11364          log("loadEntity", "no providers, skipping", entityId);
11365          return;
11366        }
11367        if (entityStates.has(entityId)) {
11368          log("loadEntity", "already loaded", entityId);
11369          return;
11370        }
11371        if (false === syncConfig.shouldSync?.(objectType, objectId)) {
11372          log("loadEntity", "shouldSync false, skipping", entityId);
11373          return;
11374        }
11375        log("loadEntity", "loading", entityId);
11376        handlers = {
11377          addUndoMeta: debugWrap(handlers.addUndoMeta),
11378          editRecord: debugWrap(handlers.editRecord),
11379          getEditedRecord: debugWrap(handlers.getEditedRecord),
11380          onStatusChange: debugWrap(handlers.onStatusChange),
11381          persistCRDTDoc: debugWrap(handlers.persistCRDTDoc),
11382          refetchRecord: debugWrap(handlers.refetchRecord),
11383          restoreUndoMeta: debugWrap(handlers.restoreUndoMeta),
11384          onUndoStackChange: handlers.onUndoStackChange ? debugWrap(handlers.onUndoStackChange) : void 0
11385        };
11386        const ydoc = createYjsDoc({ objectType });
11387        const recordMap = ydoc.getMap(CRDT_RECORD_MAP_KEY);
11388        const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11389        const now = Date.now();
11390        let hasObserversAttached = false;
11391        let isEntityUnloaded = false;
11392        const unload = () => {
11393          log("loadEntity", "unloading", entityId);
11394          isEntityUnloaded = true;
11395          providerResults?.forEach((result) => result.destroy());
11396          handlers.onStatusChange(null);
11397          if (hasObserversAttached) {
11398            recordMap.unobserveDeep(onRecordUpdate);
11399            stateMap.unobserve(onStateMapUpdate);
11400          }
11401          ydoc.destroy();
11402          entityStates.delete(entityId);
11403        };
11404        const awareness = syncConfig.createAwareness?.(ydoc, objectId);
11405        const onRecordUpdate = (_events, transaction) => {
11406          if (transaction.local && !(transaction.origin instanceof UndoManager)) {
11407            return;
11408          }
11409          void internal.updateEntityRecord(objectType, objectId);
11410        };
11411        const onStateMapUpdate = (event, transaction) => {
11412          if (transaction.local) {
11413            return;
11414          }
11415          event.keysChanged.forEach((key) => {
11416            switch (key) {
11417              case CRDT_STATE_MAP_SAVED_AT_KEY:
11418                const savedAt = stateMap.get(CRDT_STATE_MAP_SAVED_AT_KEY);
11419                if ("number" === typeof savedAt && savedAt > now) {
11420                  log("loadEntity", "refetching record", entityId);
11421                  void handlers.refetchRecord().catch(() => {
11422                  });
11423                }
11424                break;
11425            }
11426          });
11427        };
11428        if (!undoManager) {
11429          undoManager = createUndoManager();
11430        }
11431        const { addUndoMeta, onUndoStackChange, restoreUndoMeta } = handlers;
11432        undoManager.addToScope(recordMap, {
11433          addUndoMeta,
11434          restoreUndoMeta,
11435          onUndoStackChange
11436        });
11437        let providerResults;
11438        const entityState = {
11439          awareness,
11440          handlers,
11441          objectId,
11442          objectType,
11443          syncConfig,
11444          unload,
11445          ydoc
11446        };
11447        entityStates.set(entityId, entityState);
11448        log("loadEntity", "connecting", entityId);
11449        providerResults = await Promise.all(
11450          providerCreators2.map(async (create7) => {
11451            const provider = await create7({
11452              objectType,
11453              objectId,
11454              ydoc,
11455              awareness
11456            });
11457            provider.on("status", handlers.onStatusChange);
11458            return provider;
11459          })
11460        );
11461        if (isEntityUnloaded) {
11462          log("loadEntity", "unloaded during connect, aborting", entityId);
11463          providerResults.forEach((result) => result.destroy());
11464          return;
11465        }
11466        initializeYjsDoc(ydoc);
11467        internal.applyPersistedCrdtDoc(objectType, objectId, record);
11468        recordMap.observeDeep(onRecordUpdate);
11469        stateMap.observe(onStateMapUpdate);
11470        hasObserversAttached = true;
11471      }
11472      async function loadCollection(syncConfig, objectType, handlers) {
11473        const providerCreators2 = getProviderCreators();
11474        const entityId = getEntityId(objectType, null);
11475        if (0 === providerCreators2.length) {
11476          log("loadCollection", "no providers, skipping", entityId);
11477          return;
11478        }
11479        if (collectionStates.has(objectType)) {
11480          log("loadCollection", "already loaded", entityId);
11481          return;
11482        }
11483        if (false === syncConfig.shouldSync?.(objectType, null)) {
11484          log("loadCollection", "shouldSync false, skipping", entityId);
11485          return;
11486        }
11487        log("loadCollection", "loading", entityId);
11488        const ydoc = createYjsDoc({ collection: true, objectType });
11489        const stateMap = ydoc.getMap(CRDT_STATE_MAP_KEY);
11490        const now = Date.now();
11491        let hasObserversAttached = false;
11492        let isCollectionUnloaded = false;
11493        const unload = () => {
11494          log("loadCollection", "unloading", entityId);
11495          isCollectionUnloaded = true;
11496          providerResults?.forEach((result) => result.destroy());
11497          handlers.onStatusChange(null);
11498          if (hasObserversAttached) {
11499            stateMap.unobserve(onStateMapUpdate);
11500          }
11501          ydoc.destroy();
11502          collectionStates.delete(objectType);
11503        };
11504        const onStateMapUpdate = (event, transaction) => {
11505          if (transaction.local) {
11506            return;
11507          }
11508          event.keysChanged.forEach((key) => {
11509            switch (key) {
11510              case CRDT_STATE_MAP_SAVED_AT_KEY:
11511                const newValue = stateMap.get(CRDT_STATE_MAP_SAVED_AT_KEY);
11512                if ("number" === typeof newValue && newValue > now) {
11513                  void handlers.refetchRecords().catch(() => {
11514                  });
11515                }
11516                break;
11517            }
11518          });
11519        };
11520        const awareness = syncConfig.createAwareness?.(ydoc);
11521        let providerResults;
11522        const collectionState = {
11523          awareness,
11524          handlers,
11525          syncConfig,
11526          unload,
11527          ydoc
11528        };
11529        collectionStates.set(objectType, collectionState);
11530        log("loadCollection", "connecting", entityId);
11531        providerResults = await Promise.all(
11532          providerCreators2.map(async (create7) => {
11533            const provider = await create7({
11534              awareness,
11535              objectType,
11536              objectId: null,
11537              ydoc
11538            });
11539            provider.on("status", handlers.onStatusChange);
11540            return provider;
11541          })
11542        );
11543        if (isCollectionUnloaded) {
11544          log(
11545            "loadCollection",
11546            "unloaded during connect, aborting",
11547            entityId
11548          );
11549          providerResults.forEach((result) => result.destroy());
11550          return;
11551        }
11552        stateMap.observe(onStateMapUpdate);
11553        hasObserversAttached = true;
11554        initializeYjsDoc(ydoc);
11555      }
11556      function unloadEntity(objectType, objectId) {
11557        const entityId = getEntityId(objectType, objectId);
11558        log("unloadEntity", "unloading", entityId);
11559        entityStates.get(entityId)?.unload();
11560        updateCRDTDoc(objectType, null, {}, origin, {
11561          isSave: true
11562        });
11563      }
11564      function unloadAll() {
11565        log("unloadAll", "unloading all entities", "all");
11566        for (const [, entityState] of [...entityStates]) {
11567          entityState.unload();
11568        }
11569        entityStates.clear();
11570        undoManager = void 0;
11571        for (const [, collectionState] of [...collectionStates]) {
11572          collectionState.unload();
11573        }
11574        collectionStates.clear();
11575      }
11576      function getAwareness(objectType, objectId) {
11577        const entityId = getEntityId(objectType, objectId);
11578        const entityState = entityStates.get(entityId);
11579        if (!entityState || !entityState.awareness) {
11580          return void 0;
11581        }
11582        return entityState.awareness;
11583      }
11584      function _applyPersistedCrdtDoc(objectType, objectId, record) {
11585        const entityId = getEntityId(objectType, objectId);
11586        const entityState = entityStates.get(entityId);
11587        if (!entityState) {
11588          log("applyPersistedCrdtDoc", "no entity state", entityId);
11589          return;
11590        }
11591        const {
11592          handlers,
11593          syncConfig: {
11594            applyChangesToCRDTDoc,
11595            getChangesFromCRDTDoc,
11596            getPersistedCRDTDoc
11597          },
11598          ydoc: targetDoc
11599        } = entityState;
11600        const serialized = getPersistedCRDTDoc?.(record);
11601        const tempDoc = serialized ? deserializeCrdtDoc(serialized) : null;
11602        if (!tempDoc) {
11603          log("applyPersistedCrdtDoc", "no persisted doc", entityId);
11604          targetDoc.transact(() => {
11605            applyChangesToCRDTDoc(targetDoc, record);
11606            handlers.persistCRDTDoc();
11607          }, LOCAL_SYNC_MANAGER_ORIGIN);
11608          return;
11609        }
11610        const update = encodeStateAsUpdateV2(tempDoc);
11611        applyUpdateV2(targetDoc, update);
11612        const invalidations = getChangesFromCRDTDoc(tempDoc, record);
11613        const invalidatedKeys = Object.keys(invalidations);
11614        tempDoc.destroy();
11615        if (0 === invalidatedKeys.length) {
11616          log("applyPersistedCrdtDoc", "valid persisted doc", entityId);
11617          return;
11618        }
11619        log("applyPersistedCrdtDoc", "invalidated keys", entityId, {
11620          invalidatedKeys
11621        });
11622        const changes = invalidatedKeys.reduce(
11623          (acc, key) => Object.assign(acc, {
11624            [key]: record[key]
11625          }),
11626          {}
11627        );
11628        targetDoc.transact(() => {
11629          applyChangesToCRDTDoc(targetDoc, changes);
11630          handlers.persistCRDTDoc();
11631        }, LOCAL_SYNC_MANAGER_ORIGIN);
11632      }
11633      function updateCRDTDoc(objectType, objectId, changes, origin2, options = {}) {
11634        const { isSave = false, isNewUndoLevel = false } = options;
11635        const entityId = getEntityId(objectType, objectId);
11636        const entityState = entityStates.get(entityId);
11637        const collectionState = collectionStates.get(objectType);
11638        if (entityState) {
11639          const { syncConfig, ydoc } = entityState;
11640          if (isNewUndoLevel && undoManager) {
11641            undoManager.stopCapturing?.();
11642          }
11643          ydoc.transact(() => {
11644            log("updateCRDTDoc", "applying changes", entityId, {
11645              changedKeys: Object.keys(changes)
11646            });
11647            syncConfig.applyChangesToCRDTDoc(ydoc, changes);
11648            if (isSave) {
11649              markEntityAsSaved(ydoc);
11650            }
11651          }, origin2);
11652        }
11653        if (collectionState && isSave) {
11654          collectionState.ydoc.transact(() => {
11655            markEntityAsSaved(collectionState.ydoc);
11656          }, origin2);
11657        }
11658      }
11659      const pendingCRDTDocUpdates = [];
11660      function flushPendingCRDTDocUpdates() {
11661        while (pendingCRDTDocUpdates.length > 0) {
11662          const args2 = pendingCRDTDocUpdates.shift();
11663          if (args2) {
11664            updateCRDTDoc(...args2);
11665          }
11666        }
11667      }
11668      function deferUpdateCRDTDoc(...args2) {
11669        pendingCRDTDocUpdates.push(args2);
11670        setTimeout(flushPendingCRDTDocUpdates, 0);
11671      }
11672      function updateOrDefer(objectType, objectId, changes, origin2, options = {}) {
11673        const hasRemotePeers = (getAwareness(objectType, objectId)?.getStates().size ?? 0) > 1;
11674        if (hasRemotePeers) {
11675          flushPendingCRDTDocUpdates();
11676          updateCRDTDoc(objectType, objectId, changes, origin2, options);
11677          return;
11678        }
11679        deferUpdateCRDTDoc(objectType, objectId, changes, origin2, options);
11680      }
11681      function getEntitySnapshot(objectType, objectId) {
11682        const entityId = getEntityId(objectType, objectId);
11683        const entityState = entityStates.get(entityId);
11684        if (!entityState) {
11685          log("getEntitySnapshot", "no entity state", entityId);
11686          return void 0;
11687        }
11688        flushPendingCRDTDocUpdates();
11689        return encodeDocSnapshot(entityState.ydoc);
11690      }
11691      function entityContainsSnapshot(objectType, objectId, encodedSnapshot) {
11692        const entityId = getEntityId(objectType, objectId);
11693        const entityState = entityStates.get(entityId);
11694        if (!entityState) {
11695          return false;
11696        }
11697        flushPendingCRDTDocUpdates();
11698        return docContainsSnapshot(entityState.ydoc, encodedSnapshot);
11699      }
11700      async function _updateEntityRecord(objectType, objectId) {
11701        const entityId = getEntityId(objectType, objectId);
11702        const entityState = entityStates.get(entityId);
11703        if (!entityState) {
11704          log("updateEntityRecord", "no entity state", entityId);
11705          return;
11706        }
11707        const { handlers, syncConfig, ydoc } = entityState;
11708        const changes = syncConfig.getChangesFromCRDTDoc(
11709          ydoc,
11710          await handlers.getEditedRecord()
11711        );
11712        const changedKeys = Object.keys(changes);
11713        if (0 === changedKeys.length) {
11714          return;
11715        }
11716        log("updateEntityRecord", "changes", entityId, {
11717          changedKeys
11718        });
11719        handlers.editRecord(changes);
11720      }
11721      async function createPersistedCRDTDoc(objectType, objectId) {
11722        const entityId = getEntityId(objectType, objectId);
11723        const entityState = entityStates.get(entityId);
11724        if (!entityState?.ydoc) {
11725          return null;
11726        }
11727        flushPendingCRDTDocUpdates();
11728        return serializeCrdtDoc(entityState.ydoc);
11729      }
11730      const internal = {
11731        applyPersistedCrdtDoc: debugWrap(_applyPersistedCrdtDoc),
11732        updateEntityRecord: debugWrap(_updateEntityRecord)
11733      };
11734      return {
11735        createPersistedCRDTDoc: debugWrap(createPersistedCRDTDoc),
11736        entityContainsSnapshot: debugWrap(entityContainsSnapshot),
11737        getAwareness,
11738        getEntitySnapshot: debugWrap(getEntitySnapshot),
11739        load: debugWrap(loadEntity),
11740        loadCollection: debugWrap(loadCollection),
11741        // Use getter to ensure we always return the current value of `undoManager`.
11742        get undoManager() {
11743          return undoManager;
11744        },
11745        unload: debugWrap(unloadEntity),
11746        unloadAll: debugWrap(unloadAll),
11747        update: debugWrap(updateOrDefer)
11748      };
11749    }
11750  
11751    // node_modules/diff/libesm/diff/base.js
11752    var Diff = class {
11753      diff(oldStr, newStr, options = {}) {
11754        let callback;
11755        if (typeof options === "function") {
11756          callback = options;
11757          options = {};
11758        } else if ("callback" in options) {
11759          callback = options.callback;
11760        }
11761        const oldString = this.castInput(oldStr, options);
11762        const newString = this.castInput(newStr, options);
11763        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
11764        const newTokens = this.removeEmpty(this.tokenize(newString, options));
11765        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
11766      }
11767      diffWithOptionsObj(oldTokens, newTokens, options, callback) {
11768        var _a;
11769        const done = (value) => {
11770          value = this.postProcess(value, options);
11771          if (callback) {
11772            setTimeout(function() {
11773              callback(value);
11774            }, 0);
11775            return void 0;
11776          } else {
11777            return value;
11778          }
11779        };
11780        const newLen = newTokens.length, oldLen = oldTokens.length;
11781        let editLength = 1;
11782        let maxEditLength = newLen + oldLen;
11783        if (options.maxEditLength != null) {
11784          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
11785        }
11786        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
11787        const abortAfterTimestamp = Date.now() + maxExecutionTime;
11788        const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
11789        let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
11790        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
11791          return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
11792        }
11793        let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
11794        const execEditLength = () => {
11795          for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
11796            let basePath;
11797            const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
11798            if (removePath) {
11799              bestPath[diagonalPath - 1] = void 0;
11800            }
11801            let canAdd = false;
11802            if (addPath) {
11803              const addPathNewPos = addPath.oldPos - diagonalPath;
11804              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
11805            }
11806            const canRemove = removePath && removePath.oldPos + 1 < oldLen;
11807            if (!canAdd && !canRemove) {
11808              bestPath[diagonalPath] = void 0;
11809              continue;
11810            }
11811            if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
11812              basePath = this.addToPath(addPath, true, false, 0, options);
11813            } else {
11814              basePath = this.addToPath(removePath, false, true, 1, options);
11815            }
11816            newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
11817            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
11818              return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
11819            } else {
11820              bestPath[diagonalPath] = basePath;
11821              if (basePath.oldPos + 1 >= oldLen) {
11822                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
11823              }
11824              if (newPos + 1 >= newLen) {
11825                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
11826              }
11827            }
11828          }
11829          editLength++;
11830        };
11831        if (callback) {
11832          (function exec() {
11833            setTimeout(function() {
11834              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
11835                return callback(void 0);
11836              }
11837              if (!execEditLength()) {
11838                exec();
11839              }
11840            }, 0);
11841          })();
11842        } else {
11843          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
11844            const ret = execEditLength();
11845            if (ret) {
11846              return ret;
11847            }
11848          }
11849        }
11850      }
11851      addToPath(path, added, removed, oldPosInc, options) {
11852        const last2 = path.lastComponent;
11853        if (last2 && !options.oneChangePerToken && last2.added === added && last2.removed === removed) {
11854          return {
11855            oldPos: path.oldPos + oldPosInc,
11856            lastComponent: { count: last2.count + 1, added, removed, previousComponent: last2.previousComponent }
11857          };
11858        } else {
11859          return {
11860            oldPos: path.oldPos + oldPosInc,
11861            lastComponent: { count: 1, added, removed, previousComponent: last2 }
11862          };
11863        }
11864      }
11865      extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
11866        const newLen = newTokens.length, oldLen = oldTokens.length;
11867        let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
11868        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
11869          newPos++;
11870          oldPos++;
11871          commonCount++;
11872          if (options.oneChangePerToken) {
11873            basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
11874          }
11875        }
11876        if (commonCount && !options.oneChangePerToken) {
11877          basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
11878        }
11879        basePath.oldPos = oldPos;
11880        return newPos;
11881      }
11882      equals(left, right, options) {
11883        if (options.comparator) {
11884          return options.comparator(left, right);
11885        } else {
11886          return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
11887        }
11888      }
11889      removeEmpty(array) {
11890        const ret = [];
11891        for (let i = 0; i < array.length; i++) {
11892          if (array[i]) {
11893            ret.push(array[i]);
11894          }
11895        }
11896        return ret;
11897      }
11898      // eslint-disable-next-line @typescript-eslint/no-unused-vars
11899      castInput(value, options) {
11900        return value;
11901      }
11902      // eslint-disable-next-line @typescript-eslint/no-unused-vars
11903      tokenize(value, options) {
11904        return Array.from(value);
11905      }
11906      join(chars) {
11907        return chars.join("");
11908      }
11909      postProcess(changeObjects, options) {
11910        return changeObjects;
11911      }
11912      get useLongestToken() {
11913        return false;
11914      }
11915      buildValues(lastComponent, newTokens, oldTokens) {
11916        const components = [];
11917        let nextComponent;
11918        while (lastComponent) {
11919          components.push(lastComponent);
11920          nextComponent = lastComponent.previousComponent;
11921          delete lastComponent.previousComponent;
11922          lastComponent = nextComponent;
11923        }
11924        components.reverse();
11925        const componentLen = components.length;
11926        let componentPos = 0, newPos = 0, oldPos = 0;
11927        for (; componentPos < componentLen; componentPos++) {
11928          const component = components[componentPos];
11929          if (!component.removed) {
11930            if (!component.added && this.useLongestToken) {
11931              let value = newTokens.slice(newPos, newPos + component.count);
11932              value = value.map(function(value2, i) {
11933                const oldValue = oldTokens[oldPos + i];
11934                return oldValue.length > value2.length ? oldValue : value2;
11935              });
11936              component.value = this.join(value);
11937            } else {
11938              component.value = this.join(newTokens.slice(newPos, newPos + component.count));
11939            }
11940            newPos += component.count;
11941            if (!component.added) {
11942              oldPos += component.count;
11943            }
11944          } else {
11945            component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
11946            oldPos += component.count;
11947          }
11948        }
11949        return components;
11950      }
11951    };
11952  
11953    // node_modules/diff/libesm/diff/character.js
11954    var CharacterDiff = class extends Diff {
11955    };
11956    var characterDiff = new CharacterDiff();
11957    function diffChars(oldStr, newStr, options) {
11958      return characterDiff.diff(oldStr, newStr, options);
11959    }
11960  
11961    // node_modules/diff/libesm/diff/line.js
11962    var LineDiff = class extends Diff {
11963      constructor() {
11964        super(...arguments);
11965        this.tokenize = tokenize;
11966      }
11967      equals(left, right, options) {
11968        if (options.ignoreWhitespace) {
11969          if (!options.newlineIsToken || !left.includes("\n")) {
11970            left = left.trim();
11971          }
11972          if (!options.newlineIsToken || !right.includes("\n")) {
11973            right = right.trim();
11974          }
11975        } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
11976          if (left.endsWith("\n")) {
11977            left = left.slice(0, -1);
11978          }
11979          if (right.endsWith("\n")) {
11980            right = right.slice(0, -1);
11981          }
11982        }
11983        return super.equals(left, right, options);
11984      }
11985    };
11986    var lineDiff = new LineDiff();
11987    function diffLines(oldStr, newStr, options) {
11988      return lineDiff.diff(oldStr, newStr, options);
11989    }
11990    function tokenize(value, options) {
11991      if (options.stripTrailingCr) {
11992        value = value.replace(/\r\n/g, "\n");
11993      }
11994      const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
11995      if (!linesAndNewlines[linesAndNewlines.length - 1]) {
11996        linesAndNewlines.pop();
11997      }
11998      for (let i = 0; i < linesAndNewlines.length; i++) {
11999        const line = linesAndNewlines[i];
12000        if (i % 2 && !options.newlineIsToken) {
12001          retLines[retLines.length - 1] += line;
12002        } else {
12003          retLines.push(line);
12004        }
12005      }
12006      return retLines;
12007    }
12008  
12009    // packages/sync/build-module/quill-delta/Delta.mjs
12010    var import_es62 = __toESM(require_es6(), 1);
12011  
12012    // packages/sync/build-module/quill-delta/AttributeMap.mjs
12013    var import_es6 = __toESM(require_es6(), 1);
12014    function cloneDeep(value) {
12015      return JSON.parse(JSON.stringify(value));
12016    }
12017    var AttributeMap;
12018    ((AttributeMap2) => {
12019      function compose(a = {}, b = {}, keepNull = false) {
12020        if (typeof a !== "object") {
12021          a = {};
12022        }
12023        if (typeof b !== "object") {
12024          b = {};
12025        }
12026        let attributes = cloneDeep(b);
12027        if (!keepNull) {
12028          attributes = Object.keys(attributes).reduce(
12029            (copy2, key) => {
12030              if (attributes[key] !== null || attributes[key] !== void 0) {
12031                copy2[key] = attributes[key];
12032              }
12033              return copy2;
12034            },
12035            {}
12036          );
12037        }
12038        for (const key in a) {
12039          if (a[key] !== void 0 && b[key] === void 0) {
12040            attributes[key] = a[key];
12041          }
12042        }
12043        return Object.keys(attributes).length > 0 ? attributes : void 0;
12044      }
12045      AttributeMap2.compose = compose;
12046      function diff(a = {}, b = {}) {
12047        if (typeof a !== "object") {
12048          a = {};
12049        }
12050        if (typeof b !== "object") {
12051          b = {};
12052        }
12053        const attributes = Object.keys(a).concat(Object.keys(b)).reduce((attrs, key) => {
12054          if (!(0, import_es6.default)(a[key], b[key])) {
12055            attrs[key] = b[key] === void 0 ? null : b[key];
12056          }
12057          return attrs;
12058        }, {});
12059        return Object.keys(attributes).length > 0 ? attributes : void 0;
12060      }
12061      AttributeMap2.diff = diff;
12062      function invert(attr = {}, base = {}) {
12063        attr = attr || {};
12064        const baseInverted = Object.keys(base).reduce(
12065          (memo, key) => {
12066            if (base[key] !== attr[key] && attr[key] !== void 0) {
12067              memo[key] = base[key];
12068            }
12069            return memo;
12070          },
12071          {}
12072        );
12073        return Object.keys(attr).reduce((memo, key) => {
12074          if (attr[key] !== base[key] && base[key] === void 0) {
12075            memo[key] = null;
12076          }
12077          return memo;
12078        }, baseInverted);
12079      }
12080      AttributeMap2.invert = invert;
12081      function transform(a, b, priority = false) {
12082        if (typeof a !== "object") {
12083          return b;
12084        }
12085        if (typeof b !== "object") {
12086          return void 0;
12087        }
12088        if (!priority) {
12089          return b;
12090        }
12091        const attributes = Object.keys(b).reduce(
12092          (attrs, key) => {
12093            if (a[key] === void 0) {
12094              attrs[key] = b[key];
12095            }
12096            return attrs;
12097          },
12098          {}
12099        );
12100        return Object.keys(attributes).length > 0 ? attributes : void 0;
12101      }
12102      AttributeMap2.transform = transform;
12103    })(AttributeMap || (AttributeMap = {}));
12104    var AttributeMap_default = AttributeMap;
12105  
12106    // packages/sync/build-module/quill-delta/Op.mjs
12107    var Op;
12108    ((Op2) => {
12109      function length2(op) {
12110        if (typeof op.delete === "number") {
12111          return op.delete;
12112        } else if (typeof op.retain === "number") {
12113          return op.retain;
12114        } else if (typeof op.retain === "object" && op.retain !== null) {
12115          return 1;
12116        }
12117        return typeof op.insert === "string" ? op.insert.length : 1;
12118      }
12119      Op2.length = length2;
12120    })(Op || (Op = {}));
12121    var Op_default = Op;
12122  
12123    // packages/sync/build-module/quill-delta/OpIterator.mjs
12124    var Iterator = class {
12125      ops;
12126      index;
12127      offset;
12128      constructor(ops) {
12129        this.ops = ops;
12130        this.index = 0;
12131        this.offset = 0;
12132      }
12133      hasNext() {
12134        return this.peekLength() < Infinity;
12135      }
12136      next(length2) {
12137        if (!length2) {
12138          length2 = Infinity;
12139        }
12140        const nextOp = this.ops[this.index];
12141        if (nextOp) {
12142          const offset = this.offset;
12143          const opLength = Op_default.length(nextOp);
12144          if (length2 >= opLength - offset) {
12145            length2 = opLength - offset;
12146            this.index += 1;
12147            this.offset = 0;
12148          } else {
12149            this.offset += length2;
12150          }
12151          if (typeof nextOp.delete === "number") {
12152            return { delete: length2 };
12153          }
12154          const retOp = {};
12155          if (nextOp.attributes) {
12156            retOp.attributes = nextOp.attributes;
12157          }
12158          if (typeof nextOp.retain === "number") {
12159            retOp.retain = length2;
12160          } else if (typeof nextOp.retain === "object" && nextOp.retain !== null) {
12161            retOp.retain = nextOp.retain;
12162          } else if (typeof nextOp.insert === "string") {
12163            retOp.insert = nextOp.insert.substr(offset, length2);
12164          } else {
12165            retOp.insert = nextOp.insert;
12166          }
12167          return retOp;
12168        }
12169        return { retain: Infinity };
12170      }
12171      peek() {
12172        return this.ops[this.index];
12173      }
12174      peekLength() {
12175        if (this.ops[this.index]) {
12176          return Op_default.length(this.ops[this.index]) - this.offset;
12177        }
12178        return Infinity;
12179      }
12180      peekType() {
12181        const op = this.ops[this.index];
12182        if (op) {
12183          if (typeof op.delete === "number") {
12184            return "delete";
12185          } else if (typeof op.retain === "number" || typeof op.retain === "object" && op.retain !== null) {
12186            return "retain";
12187          }
12188          return "insert";
12189        }
12190        return "retain";
12191      }
12192      rest() {
12193        if (!this.hasNext()) {
12194          return [];
12195        } else if (this.offset === 0) {
12196          return this.ops.slice(this.index);
12197        }
12198        const offset = this.offset;
12199        const index = this.index;
12200        const next = this.next();
12201        const rest = this.ops.slice(this.index);
12202        this.offset = offset;
12203        this.index = index;
12204        return [next].concat(rest);
12205      }
12206    };
12207  
12208    // packages/sync/build-module/quill-delta/Delta.mjs
12209    function cloneDeep2(value) {
12210      return JSON.parse(JSON.stringify(value));
12211    }
12212    var NULL_CHARACTER = String.fromCharCode(0);
12213    var STRING_TOO_LARGE_THRESHOLD = 1e4;
12214    function normalizeChangeCounts(changes) {
12215      return changes.map((change) => ({
12216        ...change,
12217        count: change.value.length
12218      }));
12219    }
12220    var getEmbedTypeAndData = (a, b) => {
12221      if (typeof a !== "object" || a === null) {
12222        throw new Error(`cannot retain a $typeof a}`);
12223      }
12224      if (typeof b !== "object" || b === null) {
12225        throw new Error(`cannot retain a $typeof b}`);
12226      }
12227      const embedType = Object.keys(a)[0];
12228      if (!embedType || embedType !== Object.keys(b)[0]) {
12229        throw new Error(
12230          `embed types not matched: $embedType} != $Object.keys(b)[0]}`
12231        );
12232      }
12233      return [embedType, a[embedType], b[embedType]];
12234    };
12235    var Delta = class _Delta {
12236      static Op = Op_default;
12237      static OpIterator = Iterator;
12238      static AttributeMap = AttributeMap_default;
12239      static handlers = {};
12240      static registerEmbed(embedType, handler) {
12241        this.handlers[embedType] = handler;
12242      }
12243      static unregisterEmbed(embedType) {
12244        delete this.handlers[embedType];
12245      }
12246      static getHandler(embedType) {
12247        const handler = this.handlers[embedType];
12248        if (!handler) {
12249          throw new Error(`no handlers for embed type "$embedType}"`);
12250        }
12251        return handler;
12252      }
12253      ops;
12254      constructor(ops) {
12255        if (Array.isArray(ops)) {
12256          this.ops = ops;
12257        } else if (ops !== null && ops !== void 0 && Array.isArray(ops.ops)) {
12258          this.ops = ops.ops;
12259        } else {
12260          this.ops = [];
12261        }
12262      }
12263      insert(arg, attributes) {
12264        const newOp = {};
12265        if (typeof arg === "string" && arg.length === 0) {
12266          return this;
12267        }
12268        newOp.insert = arg;
12269        if (attributes !== null && attributes !== void 0 && typeof attributes === "object" && Object.keys(attributes).length > 0) {
12270          newOp.attributes = attributes;
12271        }
12272        return this.push(newOp);
12273      }
12274      delete(length2) {
12275        if (length2 <= 0) {
12276          return this;
12277        }
12278        return this.push({ delete: length2 });
12279      }
12280      retain(length2, attributes) {
12281        if (typeof length2 === "number" && length2 <= 0) {
12282          return this;
12283        }
12284        const newOp = { retain: length2 };
12285        if (attributes !== null && attributes !== void 0 && typeof attributes === "object" && Object.keys(attributes).length > 0) {
12286          newOp.attributes = attributes;
12287        }
12288        return this.push(newOp);
12289      }
12290      push(newOp) {
12291        let index = this.ops.length;
12292        let lastOp = this.ops[index - 1];
12293        newOp = cloneDeep2(newOp);
12294        if (typeof lastOp === "object") {
12295          if (typeof newOp.delete === "number" && typeof lastOp.delete === "number") {
12296            this.ops[index - 1] = {
12297              delete: lastOp.delete + newOp.delete
12298            };
12299            return this;
12300          }
12301          if (typeof lastOp.delete === "number" && newOp.insert !== null && newOp.insert !== void 0) {
12302            index -= 1;
12303            lastOp = this.ops[index - 1];
12304            if (typeof lastOp !== "object") {
12305              this.ops.unshift(newOp);
12306              return this;
12307            }
12308          }
12309          if ((0, import_es62.default)(newOp.attributes, lastOp.attributes)) {
12310            if (typeof newOp.insert === "string" && typeof lastOp.insert === "string") {
12311              this.ops[index - 1] = {
12312                insert: lastOp.insert + newOp.insert
12313              };
12314              if (typeof newOp.attributes === "object") {
12315                this.ops[index - 1].attributes = newOp.attributes;
12316              }
12317              return this;
12318            } else if (typeof newOp.retain === "number" && typeof lastOp.retain === "number") {
12319              this.ops[index - 1] = {
12320                retain: lastOp.retain + newOp.retain
12321              };
12322              if (typeof newOp.attributes === "object") {
12323                this.ops[index - 1].attributes = newOp.attributes;
12324              }
12325              return this;
12326            }
12327          }
12328        }
12329        if (index === this.ops.length) {
12330          this.ops.push(newOp);
12331        } else {
12332          this.ops.splice(index, 0, newOp);
12333        }
12334        return this;
12335      }
12336      chop() {
12337        const lastOp = this.ops[this.ops.length - 1];
12338        if (lastOp && typeof lastOp.retain === "number" && !lastOp.attributes) {
12339          this.ops.pop();
12340        }
12341        return this;
12342      }
12343      filter(predicate) {
12344        return this.ops.filter(predicate);
12345      }
12346      forEach(predicate) {
12347        this.ops.forEach(predicate);
12348      }
12349      map(predicate) {
12350        return this.ops.map(predicate);
12351      }
12352      partition(predicate) {
12353        const passed = [];
12354        const failed = [];
12355        this.forEach((op) => {
12356          const target = predicate(op) ? passed : failed;
12357          target.push(op);
12358        });
12359        return [passed, failed];
12360      }
12361      reduce(predicate, initialValue) {
12362        return this.ops.reduce(predicate, initialValue);
12363      }
12364      changeLength() {
12365        return this.reduce((length2, elem) => {
12366          if (elem.insert) {
12367            return length2 + Op_default.length(elem);
12368          } else if (elem.delete) {
12369            return length2 - elem.delete;
12370          }
12371          return length2;
12372        }, 0);
12373      }
12374      length() {
12375        return this.reduce((length2, elem) => {
12376          return length2 + Op_default.length(elem);
12377        }, 0);
12378      }
12379      slice(start = 0, end = Infinity) {
12380        const ops = [];
12381        const iter = new Iterator(this.ops);
12382        let index = 0;
12383        while (index < end && iter.hasNext()) {
12384          let nextOp;
12385          if (index < start) {
12386            nextOp = iter.next(start - index);
12387          } else {
12388            nextOp = iter.next(end - index);
12389            ops.push(nextOp);
12390          }
12391          index += Op_default.length(nextOp);
12392        }
12393        return new _Delta(ops);
12394      }
12395      compose(other) {
12396        const thisIter = new Iterator(this.ops);
12397        const otherIter = new Iterator(other.ops);
12398        const ops = [];
12399        const firstOther = otherIter.peek();
12400        if (firstOther !== null && firstOther !== void 0 && typeof firstOther.retain === "number" && (firstOther.attributes === null || firstOther.attributes === void 0)) {
12401          let firstLeft = firstOther.retain;
12402          while (thisIter.peekType() === "insert" && thisIter.peekLength() <= firstLeft) {
12403            firstLeft -= thisIter.peekLength();
12404            ops.push(thisIter.next());
12405          }
12406          if (firstOther.retain - firstLeft > 0) {
12407            otherIter.next(firstOther.retain - firstLeft);
12408          }
12409        }
12410        const delta = new _Delta(ops);
12411        while (thisIter.hasNext() || otherIter.hasNext()) {
12412          if (otherIter.peekType() === "insert") {
12413            delta.push(otherIter.next());
12414          } else if (thisIter.peekType() === "delete") {
12415            delta.push(thisIter.next());
12416          } else {
12417            const length2 = Math.min(
12418              thisIter.peekLength(),
12419              otherIter.peekLength()
12420            );
12421            const thisOp = thisIter.next(length2);
12422            const otherOp = otherIter.next(length2);
12423            if (otherOp.retain) {
12424              const newOp = {};
12425              if (typeof thisOp.retain === "number") {
12426                newOp.retain = typeof otherOp.retain === "number" ? length2 : otherOp.retain;
12427              } else if (typeof otherOp.retain === "number") {
12428                if (thisOp.retain === null || thisOp.retain === void 0) {
12429                  newOp.insert = thisOp.insert;
12430                } else {
12431                  newOp.retain = thisOp.retain;
12432                }
12433              } else {
12434                const action = thisOp.retain === null || thisOp.retain === void 0 ? "insert" : "retain";
12435                const [embedType, thisData, otherData] = getEmbedTypeAndData(
12436                  thisOp[action],
12437                  otherOp.retain
12438                );
12439                const handler = _Delta.getHandler(embedType);
12440                newOp[action] = {
12441                  [embedType]: handler.compose(
12442                    thisData,
12443                    otherData,
12444                    action === "retain"
12445                  )
12446                };
12447              }
12448              const attributes = AttributeMap_default.compose(
12449                thisOp.attributes,
12450                otherOp.attributes,
12451                typeof thisOp.retain === "number"
12452              );
12453              if (attributes) {
12454                newOp.attributes = attributes;
12455              }
12456              delta.push(newOp);
12457              if (!otherIter.hasNext() && (0, import_es62.default)(delta.ops[delta.ops.length - 1], newOp)) {
12458                const rest = new _Delta(thisIter.rest());
12459                return delta.concat(rest).chop();
12460              }
12461            } else if (typeof otherOp.delete === "number" && (typeof thisOp.retain === "number" || typeof thisOp.retain === "object" && thisOp.retain !== null)) {
12462              delta.push(otherOp);
12463            }
12464          }
12465        }
12466        return delta.chop();
12467      }
12468      concat(other) {
12469        const delta = new _Delta(this.ops.slice());
12470        if (other.ops.length > 0) {
12471          delta.push(other.ops[0]);
12472          delta.ops = delta.ops.concat(other.ops.slice(1));
12473        }
12474        return delta;
12475      }
12476      diff(other) {
12477        if (this.ops === other.ops) {
12478          return new _Delta();
12479        }
12480        const strings = this.deltasToStrings(other);
12481        const diffResult = normalizeChangeCounts(
12482          diffChars(strings[0], strings[1])
12483        );
12484        const thisIter = new Iterator(this.ops);
12485        const otherIter = new Iterator(other.ops);
12486        const retDelta = this.convertChangesToDelta(
12487          diffResult,
12488          thisIter,
12489          otherIter
12490        );
12491        return retDelta.chop();
12492      }
12493      eachLine(predicate, newline = "\n") {
12494        const iter = new Iterator(this.ops);
12495        let line = new _Delta();
12496        let i = 0;
12497        while (iter.hasNext()) {
12498          if (iter.peekType() !== "insert") {
12499            return;
12500          }
12501          const thisOp = iter.peek();
12502          const start = Op_default.length(thisOp) - iter.peekLength();
12503          const index = typeof thisOp.insert === "string" ? thisOp.insert.indexOf(newline, start) - start : -1;
12504          if (index < 0) {
12505            line.push(iter.next());
12506          } else if (index > 0) {
12507            line.push(iter.next(index));
12508          } else {
12509            if (predicate(line, iter.next(1).attributes || {}, i) === false) {
12510              return;
12511            }
12512            i += 1;
12513            line = new _Delta();
12514          }
12515        }
12516        if (line.length() > 0) {
12517          predicate(line, {}, i);
12518        }
12519      }
12520      invert(base) {
12521        const inverted = new _Delta();
12522        this.reduce((baseIndex, op) => {
12523          if (op.insert) {
12524            inverted.delete(Op_default.length(op));
12525          } else if (typeof op.retain === "number" && (op.attributes === null || op.attributes === void 0)) {
12526            inverted.retain(op.retain);
12527            return baseIndex + op.retain;
12528          } else if (op.delete || typeof op.retain === "number") {
12529            const length2 = op.delete || op.retain;
12530            const slice = base.slice(baseIndex, baseIndex + length2);
12531            slice.forEach((baseOp) => {
12532              if (op.delete) {
12533                inverted.push(baseOp);
12534              } else if (op.retain && op.attributes) {
12535                inverted.retain(
12536                  Op_default.length(baseOp),
12537                  AttributeMap_default.invert(
12538                    op.attributes,
12539                    baseOp.attributes
12540                  )
12541                );
12542              }
12543            });
12544            return baseIndex + length2;
12545          } else if (typeof op.retain === "object" && op.retain !== null) {
12546            const slice = base.slice(baseIndex, baseIndex + 1);
12547            const baseOp = new Iterator(slice.ops).next();
12548            const [embedType, opData, baseOpData] = getEmbedTypeAndData(
12549              op.retain,
12550              baseOp.insert
12551            );
12552            const handler = _Delta.getHandler(embedType);
12553            inverted.retain(
12554              { [embedType]: handler.invert(opData, baseOpData) },
12555              AttributeMap_default.invert(op.attributes, baseOp.attributes)
12556            );
12557            return baseIndex + 1;
12558          }
12559          return baseIndex;
12560        }, 0);
12561        return inverted.chop();
12562      }
12563      transform(arg, priority = false) {
12564        priority = !!priority;
12565        if (typeof arg === "number") {
12566          return this.transformPosition(arg, priority);
12567        }
12568        const other = arg;
12569        const thisIter = new Iterator(this.ops);
12570        const otherIter = new Iterator(other.ops);
12571        const delta = new _Delta();
12572        while (thisIter.hasNext() || otherIter.hasNext()) {
12573          if (thisIter.peekType() === "insert" && (priority || otherIter.peekType() !== "insert")) {
12574            delta.retain(Op_default.length(thisIter.next()));
12575          } else if (otherIter.peekType() === "insert") {
12576            delta.push(otherIter.next());
12577          } else {
12578            const length2 = Math.min(
12579              thisIter.peekLength(),
12580              otherIter.peekLength()
12581            );
12582            const thisOp = thisIter.next(length2);
12583            const otherOp = otherIter.next(length2);
12584            if (thisOp.delete) {
12585              continue;
12586            } else if (otherOp.delete) {
12587              delta.push(otherOp);
12588            } else {
12589              const thisData = thisOp.retain;
12590              const otherData = otherOp.retain;
12591              let transformedData = typeof otherData === "object" && otherData !== null ? otherData : length2;
12592              if (typeof thisData === "object" && thisData !== null && typeof otherData === "object" && otherData !== null) {
12593                const embedType = Object.keys(thisData)[0];
12594                if (embedType === Object.keys(otherData)[0]) {
12595                  const handler = _Delta.getHandler(embedType);
12596                  if (handler) {
12597                    transformedData = {
12598                      [embedType]: handler.transform(
12599                        thisData[embedType],
12600                        otherData[embedType],
12601                        priority
12602                      )
12603                    };
12604                  }
12605                }
12606              }
12607              delta.retain(
12608                transformedData,
12609                AttributeMap_default.transform(
12610                  thisOp.attributes,
12611                  otherOp.attributes,
12612                  priority
12613                )
12614              );
12615            }
12616          }
12617        }
12618        return delta.chop();
12619      }
12620      transformPosition(index, priority = false) {
12621        priority = !!priority;
12622        const thisIter = new Iterator(this.ops);
12623        let offset = 0;
12624        while (thisIter.hasNext() && offset <= index) {
12625          const length2 = thisIter.peekLength();
12626          const nextType = thisIter.peekType();
12627          thisIter.next();
12628          if (nextType === "delete") {
12629            index -= Math.min(length2, index - offset);
12630            continue;
12631          } else if (nextType === "insert" && (offset < index || !priority)) {
12632            index += length2;
12633          }
12634          offset += length2;
12635        }
12636        return index;
12637      }
12638      /**
12639       * Given a Delta and a cursor position, do a diff and attempt to adjust
12640       * the diff to place insertions or deletions at the cursor position.
12641       *
12642       * @todo There are at least a few known cases where this produces a corrupted
12643       *       diff. When this is fixed, it should not be necessary to verify that the
12644       *       transformed diff applies cleanly.
12645       *
12646       * @see import("@wordpress/core-data/src/utils/crdt-blocks").mergeRichTextUpdate()
12647       *
12648       * @param other             - The other Delta to diff against.
12649       * @param cursorAfterChange - The cursor position index after the change.
12650       * @return A Delta that attempts to place insertions or deletions at the cursor position.
12651       */
12652      diffWithCursor(other, cursorAfterChange) {
12653        if (this.ops === other.ops) {
12654          return new _Delta();
12655        }
12656        const strings = this.deltasToStrings(other);
12657        const maxStringLength = Math.max(
12658          ...strings.map((str) => str.length)
12659        );
12660        if (maxStringLength > STRING_TOO_LARGE_THRESHOLD) {
12661          const diffResult = normalizeChangeCounts(
12662            diffLines(strings[0], strings[1])
12663          );
12664          const thisIterLarge = new Iterator(this.ops);
12665          const otherIterLarge = new Iterator(other.ops);
12666          return this.convertChangesToDelta(
12667            diffResult,
12668            thisIterLarge,
12669            otherIterLarge
12670          ).chop();
12671        } else if (cursorAfterChange === null) {
12672          return this.diff(other);
12673        }
12674        let diffs = normalizeChangeCounts(
12675          diffChars(strings[0], strings[1])
12676        );
12677        let lastDiffPosition = 0;
12678        const adjustedDiffs = [];
12679        for (let i = 0; i < diffs.length; i++) {
12680          const diff = diffs[i];
12681          const segmentStart = lastDiffPosition;
12682          const segmentEnd = lastDiffPosition + (diff.count ?? 0);
12683          const isCursorInSegment = cursorAfterChange > segmentStart && cursorAfterChange <= segmentEnd;
12684          const isUnchangedSegment = !diff.added && !diff.removed;
12685          const isRemovalSegment = diff.removed && !diff.added;
12686          const nextDiff = diffs[i + 1];
12687          const isNextDiffAnInsert = nextDiff && nextDiff.added && !nextDiff.removed;
12688          if (isUnchangedSegment && isCursorInSegment && isNextDiffAnInsert) {
12689            const movedSegments = this.tryMoveInsertionToCursor(
12690              diff,
12691              nextDiff,
12692              cursorAfterChange,
12693              segmentStart
12694            );
12695            if (movedSegments) {
12696              adjustedDiffs.push(...movedSegments);
12697              i++;
12698              lastDiffPosition = segmentEnd;
12699              continue;
12700            }
12701          }
12702          if (isRemovalSegment) {
12703            const movedSegments = this.tryMoveDeletionToCursor(
12704              diff,
12705              adjustedDiffs,
12706              cursorAfterChange,
12707              lastDiffPosition
12708            );
12709            if (movedSegments) {
12710              adjustedDiffs.pop();
12711              adjustedDiffs.push(...movedSegments);
12712              lastDiffPosition += diff.count ?? 0;
12713              continue;
12714            }
12715          }
12716          adjustedDiffs.push(diff);
12717          if (!diff.added) {
12718            lastDiffPosition += diff.count ?? 0;
12719          }
12720        }
12721        diffs = adjustedDiffs;
12722        const thisIter = new Iterator(this.ops);
12723        const otherIter = new Iterator(other.ops);
12724        const retDelta = this.convertChangesToDelta(
12725          diffs,
12726          thisIter,
12727          otherIter
12728        );
12729        return retDelta.chop();
12730      }
12731      /**
12732       * Try to move an insertion operation from after an unchanged segment to the cursor position within it.
12733       * This is a "look-ahead" strategy.
12734       *
12735       * @param diff              - The current unchanged diff segment.
12736       * @param nextDiff          - The next diff segment (expected to be an insertion).
12737       * @param cursorAfterChange - The cursor position after the change.
12738       * @param segmentStart      - The start position of the current segment.
12739       * @return An array of adjusted diff segments if the insertion was successfully moved, null otherwise.
12740       */
12741      tryMoveInsertionToCursor(diff, nextDiff, cursorAfterChange, segmentStart) {
12742        const nextDiffInsert = nextDiff.value;
12743        const insertLength = nextDiffInsert.length;
12744        const insertOffset = cursorAfterChange - segmentStart - insertLength;
12745        const textAtCursor = diff.value.substring(
12746          insertOffset,
12747          insertOffset + nextDiffInsert.length
12748        );
12749        const isInsertMoveable = textAtCursor === nextDiffInsert;
12750        if (!isInsertMoveable) {
12751          return null;
12752        }
12753        const beforeCursor = diff.value.substring(0, insertOffset);
12754        const afterCursor = diff.value.substring(insertOffset);
12755        const result = [];
12756        if (beforeCursor.length > 0) {
12757          result.push({
12758            value: beforeCursor,
12759            count: beforeCursor.length,
12760            added: false,
12761            removed: false
12762          });
12763        }
12764        result.push(nextDiff);
12765        if (afterCursor.length > 0) {
12766          result.push({
12767            value: afterCursor,
12768            count: afterCursor.length,
12769            added: false,
12770            removed: false
12771          });
12772        }
12773        return result;
12774      }
12775      /**
12776       * Try to move a deletion operation to the cursor position by looking back at the previous unchanged segment.
12777       * This is a "look-back" strategy.
12778       *
12779       * @param diff              - The current deletion diff segment.
12780       * @param adjustedDiffs     - The array of previously processed diff segments.
12781       * @param cursorAfterChange - The cursor position after the change.
12782       * @param lastDiffPosition  - The position in the document up to (but not including) the current diff.
12783       * @return An array of adjusted diff segments if the deletion was successfully moved, null otherwise.
12784       */
12785      tryMoveDeletionToCursor(diff, adjustedDiffs, cursorAfterChange, lastDiffPosition) {
12786        const prevDiff = adjustedDiffs[adjustedDiffs.length - 1];
12787        if (!prevDiff || prevDiff.added || prevDiff.removed) {
12788          return null;
12789        }
12790        const prevSegmentStart = lastDiffPosition - (prevDiff.count ?? 0);
12791        const prevSegmentEnd = lastDiffPosition;
12792        if (cursorAfterChange < prevSegmentStart || cursorAfterChange >= prevSegmentEnd) {
12793          return null;
12794        }
12795        const deletedChars = diff.value;
12796        const deleteOffset = cursorAfterChange - prevSegmentStart;
12797        const textAtCursor = prevDiff.value.substring(
12798          deleteOffset,
12799          deleteOffset + deletedChars.length
12800        );
12801        const canBePlacedHere = textAtCursor === deletedChars;
12802        if (!canBePlacedHere) {
12803          return null;
12804        }
12805        const beforeCursor = prevDiff.value.substring(0, deleteOffset);
12806        const atAndAfterCursor = prevDiff.value.substring(deleteOffset);
12807        const deletionLength = diff.count ?? 0;
12808        const afterDeletion = atAndAfterCursor.substring(deletionLength);
12809        const result = [];
12810        if (beforeCursor.length > 0) {
12811          result.push({
12812            value: beforeCursor,
12813            count: beforeCursor.length,
12814            added: false,
12815            removed: false
12816          });
12817        }
12818        result.push(diff);
12819        if (afterDeletion.length > 0) {
12820          result.push({
12821            value: afterDeletion,
12822            count: afterDeletion.length,
12823            added: false,
12824            removed: false
12825          });
12826        }
12827        return result;
12828      }
12829      /**
12830       * Convert two Deltas to string representations for diffing.
12831       *
12832       * @param other - The other Delta to convert.
12833       * @return A tuple of [thisString, otherString].
12834       */
12835      deltasToStrings(other) {
12836        return [this, other].map((delta) => {
12837          return delta.map((op) => {
12838            if (op.insert !== null || op.insert !== void 0) {
12839              return typeof op.insert === "string" ? op.insert : NULL_CHARACTER;
12840            }
12841            const prep = delta === other ? "on" : "with";
12842            throw new Error(
12843              "diff() called " + prep + " non-document"
12844            );
12845          }).join("");
12846        });
12847      }
12848      /**
12849       * Process diff changes and convert them to Delta operations.
12850       *
12851       * @param changes   - The array of changes from the diff algorithm.
12852       * @param thisIter  - Iterator for this Delta's operations.
12853       * @param otherIter - Iterator for the other Delta's operations.
12854       * @return A Delta containing the processed diff operations.
12855       */
12856      convertChangesToDelta(changes, thisIter, otherIter) {
12857        const retDelta = new _Delta();
12858        changes.forEach((component) => {
12859          let length2 = component.count ?? 0;
12860          while (length2 > 0) {
12861            let opLength = 0;
12862            if (component.added) {
12863              opLength = Math.min(otherIter.peekLength(), length2);
12864              retDelta.push(otherIter.next(opLength));
12865            } else if (component.removed) {
12866              opLength = Math.min(length2, thisIter.peekLength());
12867              thisIter.next(opLength);
12868              retDelta.delete(opLength);
12869            } else {
12870              opLength = Math.min(
12871                thisIter.peekLength(),
12872                otherIter.peekLength(),
12873                length2
12874              );
12875              const thisOp = thisIter.next(opLength);
12876              const otherOp = otherIter.next(opLength);
12877              if ((0, import_es62.default)(thisOp.insert, otherOp.insert)) {
12878                retDelta.retain(
12879                  opLength,
12880                  AttributeMap_default.diff(
12881                    thisOp.attributes,
12882                    otherOp.attributes
12883                  )
12884                );
12885              } else {
12886                retDelta.push(otherOp).delete(opLength);
12887              }
12888            }
12889            length2 -= opLength;
12890          }
12891        });
12892        return retDelta;
12893      }
12894    };
12895    var Delta_default = Delta;
12896  
12897    // packages/sync/build-module/private-apis.mjs
12898    var privateApis = {};
12899    lock(privateApis, {
12900      ConnectionErrorCode,
12901      createSyncManager,
12902      Delta: Delta_default,
12903      CRDT_DOC_META_PERSISTENCE_KEY,
12904      CRDT_RECORD_MAP_KEY,
12905      LOCAL_EDITOR_ORIGIN,
12906      LOCAL_UNDO_IGNORED_ORIGIN,
12907      retrySyncConnection: () => pollingManager.retryNow()
12908    });
12909  
12910    // packages/sync/build-module/index.mjs
12911    var YJS_VERSION = "13";
12912    return __toCommonJS(index_exports);
12913  })();
12914  (window.wp ||= {}).sync = wp.sync;
12915  })();