https://missdream.org/wp-includes/js/dist/core-data.js

43// node_modules/fast-deep-equal/es6/index.js
44  var require_es6 = __commonJS({
45    "node_modules/fast-deep-equal/es6/index.js"(exports, module) {
46      "use strict";
47      module.exports = function equal(a, b) {
48        if (a === b) return true;
49        if (a && b && typeof a == "object" && typeof b == "object") {
50          if (a.constructor !== b.constructor) return false;
51          var length2, i, keys2;
52          if (Array.isArray(a)) {
53            length2 = a.length;
54            if (length2 != b.length) return false;
55            for (i = length2; i-- !== 0; )
56              if (!equal(a[i], b[i])) return false;
57            return true;
58          }
59          if (a instanceof Map && b instanceof Map) {
60            if (a.size !== b.size) return false;
61            for (i of a.entries())
62              if (!b.has(i[0])) return false;
63            for (i of a.entries())
64              if (!equal(i[1], b.get(i[0]))) return false;
65            return true;
66          }
67          if (a instanceof Set && b instanceof Set) {
68            if (a.size !== b.size) return false;
69            for (i of a.entries())
70              if (!b.has(i[0])) return false;
71            return true;
72          }
73          if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
74            length2 = a.length;
75            if (length2 != b.length) return false;
76            for (i = length2; i-- !== 0; )
77              if (a[i] !== b[i]) return false;
78            return true;
79          }
80          if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
81          if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
82          if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
83          keys2 = Object.keys(a);
84          length2 = keys2.length;
85          if (length2 !== Object.keys(b).length) return false;
86          for (i = length2; i-- !== 0; )
87            if (!Object.prototype.hasOwnProperty.call(b, keys2[i])) return false;
88          for (i = length2; i-- !== 0; ) {
89            var key = keys2[i];
90            if (!equal(a[key], b[key])) return false;
91          }
92          return true;
93        }
94        return a !== a && b !== b;
95      };
96    }
97  });
98
99  // package-external:@wordpress/compose
100  var require_compose = __commonJS({
101    "package-external:@wordpress/compose"(exports, module) {
102      module.exports = window.wp.compose;
103    }
104  });
105
106  // package-external:@wordpress/undo-manager
107  var require_undo_manager = __commonJS({
108    "package-external:@wordpress/undo-manager"(exports, module) {
109      module.exports = window.wp.undoManager;
110    }
111  });
112
113  // package-external:@wordpress/api-fetch
114  var require_api_fetch = __commonJS({
115    "package-external:@wordpress/api-fetch"(exports, module) {
116      module.exports = window.wp.apiFetch;
117    }
118  });
119
120  // package-external:@wordpress/private-apis
121  var require_private_apis = __commonJS({
122    "package-external:@wordpress/private-apis"(exports, module) {
123      module.exports = window.wp.privateApis;
124    }
125  });
126
127  // package-external:@wordpress/hooks
128  var require_hooks = __commonJS({
129    "package-external:@wordpress/hooks"(exports, module) {
130      module.exports = window.wp.hooks;
131    }
132  });
133
134  

134// node_modules/equivalent-key-map/equivalent-key-map.js
135  var require_equivalent_key_map = __commonJS({
136    "node_modules/equivalent-key-map/equivalent-key-map.js"(exports, module) {
137      "use strict";
138      function _typeof(obj) {
139        if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
140          _typeof = function(obj2) {
141            return typeof obj2;
142          };
143        } else {
144          _typeof = function(obj2) {
145            return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
146          };
147        }
148        return _typeof(obj);
149      }
150      function _classCallCheck(instance, Constructor) {
151        if (!(instance instanceof Constructor)) {
152          throw new TypeError("Cannot call a class as a function");
153        }
154      }
155      function _defineProperties(target, props) {
156        for (var i = 0; i < props.length; i++) {
157          var descriptor = props[i];
158          descriptor.enumerable = descriptor.enumerable || false;
159          descriptor.configurable = true;
160          if ("value" in descriptor) descriptor.writable = true;
161          Object.defineProperty(target, descriptor.key, descriptor);
162        }
163      }
164      function _createClass(Constructor, protoProps, staticProps) {
165        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
166        if (staticProps) _defineProperties(Constructor, staticProps);
167        return Constructor;
168      }
169      function getValuePair(instance, key) {
170        var _map = instance._map, _arrayTreeMap = instance._arrayTreeMap, _objectTreeMap = instance._objectTreeMap;
171        if (_map.has(key)) {
172          return _map.get(key);
173        }
174        var properties = Object.keys(key).sort();
175        var map2 = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
176        for (var i = 0; i < properties.length; i++) {
177          var property = properties[i];
178          map2 = map2.get(property);
179          if (map2 === void 0) {
180            return;
181          }
182          var propertyValue = key[property];
183          map2 = map2.get(propertyValue);
184          if (map2 === void 0) {
185            return;
186          }
187        }
188        var valuePair = map2.get("_ekm_value");
189        if (!valuePair) {
190          return;
191        }
192        _map.delete(valuePair[0]);
193        valuePair[0] = key;
194        map2.set("_ekm_value", valuePair);
195        _map.set(key, valuePair);
196        return valuePair;
197      }
198      var EquivalentKeyMap2 = /* @__PURE__ */ (function() {
199        function EquivalentKeyMap3(iterable) {
200          _classCallCheck(this, EquivalentKeyMap3);
201          this.clear();
202          if (iterable instanceof EquivalentKeyMap3) {
203            var iterablePairs = [];
204            iterable.forEach(function(value, key) {
205              iterablePairs.push([key, value]);
206            });
207            iterable = iterablePairs;
208          }
209          if (iterable != null) {
210            for (var i = 0; i < iterable.length; i++) {
211              this.set(iterable[i][0], iterable[i][1]);
212            }
213          }
214        }
215        _createClass(EquivalentKeyMap3, [{
216          key: "set",
217          /**
218           * Add or update an element with a specified key and value.
219           *
220           * @param {*} key   The key of the element to add.
221           * @param {*} value The value of the element to add.
222           *
223           * @return {EquivalentKeyMap} Map instance.
224           */
225          value: function set(key, value) {
226            if (key === null || _typeof(key) !== "object") {
227              this._map.set(key, value);
228              return this;
229            }
230            var properties = Object.keys(key).sort();
231            var valuePair = [key, value];
232            var map2 = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
233            for (var i = 0; i < properties.length; i++) {
234              var property = properties[i];
235              if (!map2.has(property)) {
236                map2.set(property, new EquivalentKeyMap3());
237              }
238              map2 = map2.get(property);
239              var propertyValue = key[property];
240              if (!map2.has(propertyValue)) {
241                map2.set(propertyValue, new EquivalentKeyMap3());
242              }
243              map2 = map2.get(propertyValue);
244            }
245            var previousValuePair = map2.get("_ekm_value");
246            if (previousValuePair) {
247              this._map.delete(previousValuePair[0]);
248            }
249            map2.set("_ekm_value", valuePair);
250            this._map.set(key, valuePair);
251            return this;
252          }
253          /**
254           * Returns a specified element.
255           *
256           * @param {*} key The key of the element to return.
257           *
258           * @return {?*} The element associated with the specified key or undefined
259           *              if the key can't be found.
260           */
261        }, {
262          key: "get",
263          value: function get(key) {
264            if (key === null || _typeof(key) !== "object") {
265              return this._map.get(key);
266            }
267            var valuePair = getValuePair(this, key);
268            if (valuePair) {
269              return valuePair[1];
270            }
271          }
272          /**
273           * Returns a boolean indicating whether an element with the specified key
274           * exists or not.
275           *
276           * @param {*} key The key of the element to test for presence.
277           *
278           * @return {boolean} Whether an element with the specified key exists.
279           */
280        }, {
281          key: "has",
282          value: function has(key) {
283            if (key === null || _typeof(key) !== "object") {
284              return this._map.has(key);
285            }
286            return getValuePair(this, key) !== void 0;
287          }
288          /**
289           * Removes the specified element.
290           *
291           * @param {*} key The key of the element to remove.
292           *
293           * @return {boolean} Returns true if an element existed and has been
294           *                   removed, or false if the element does not exist.
295           */
296        }, {
297          key: "delete",
298          value: function _delete(key) {
299            if (!this.has(key)) {
300              return false;
301            }
302            this.set(key, void 0);
303            return true;
304          }
305          /**
306           * Executes a provided function once per each key/value pair, in insertion
307           * order.
308           *
309           * @param {Function} callback Function to execute for each element.
310           * @param {*}        thisArg  Value to use as `this` when executing
311           *                            `callback`.
312           */
313        }, {
314          key: "forEach",
315          value: function forEach2(callback) {
316            var _this = this;
317            var thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this;
318            this._map.forEach(function(value, key) {
319              if (key !== null && _typeof(key) === "object") {
320                value = value[1];
321              }
322              callback.call(thisArg, value, key, _this);
323            });
324          }
325          /**
326           * Removes all elements.
327           */
328        }, {
329          key: "clear",
330          value: function clear() {
331            this._map = /* @__PURE__ */ new Map();
332            this._arrayTreeMap = /* @__PURE__ */ new Map();
333            this._objectTreeMap = /* @__PURE__ */ new Map();
334          }
335        }, {
336          key: "size",
337          get: function get() {
338            return this._map.size;
339          }
340        }]);
341        return EquivalentKeyMap3;
342      })();
343      module.exports = EquivalentKeyMap2;
344    }
345  });
346
347  // package-external:@wordpress/url
348  var require_url = __commonJS({
349    "package-external:@wordpress/url"(exports, module) {
350      module.exports = window.wp.url;
351    }
352  });
353
354  // package-external:@wordpress/blocks
355  var require_blocks = __commonJS({
356    "package-external:@wordpress/blocks"(exports, module) {
357      module.exports = window.wp.blocks;
358    }
359  });
360
361  // package-external:@wordpress/i18n
362  var require_i18n = __commonJS({
363    "package-external:@wordpress/i18n"(exports, module) {
364      module.exports = window.wp.i18n;
365    }
366  });
367
368  // package-external:@wordpress/block-editor
369  var require_block_editor = __commonJS({
370    "package-external:@wordpress/block-editor"(exports, module) {
371      module.exports = window.wp.blockEditor;
372    }
373  });
374
375  // package-external:@wordpress/rich-text
376  var require_rich_text = __commonJS({
377    "package-external:@wordpress/rich-text"(exports, module) {
378      module.exports = window.wp.richText;
379    }
380  });
381
382  // package-external:@wordpress/deprecated
383  var require_deprecated = __commonJS({
384    "package-external:@wordpress/deprecated"(exports, module) {
385      module.exports = window.wp.deprecated;
386    }
387  });
388
389  // package-external:@wordpress/html-entities
390  var require_html_entities = __commonJS({
391    "package-external:@wordpress/html-entities"(exports, module) {
392      module.exports = window.wp.htmlEntities;
393    }
394  });
395
396  // package-external:@wordpress/element
397  var require_element = __commonJS({
398    "package-external:@wordpress/element"(exports, module) {
399      module.exports = window.wp.element;
400    }
401  });
402
403  // vendor-external:react/jsx-runtime
404  var require_jsx_runtime = __commonJS({
405    "vendor-external:react/jsx-runtime"(exports, module) {
406      module.exports = window.ReactJSXRuntime;
407    }
408  });
409
410  // package-external:@wordpress/warning
411  var require_warning = __commonJS({
412    "package-external:@wordpress/warning"(exports, module) {
413      module.exports = window.wp.warning;
414    }
415  });
416
417  

622// node_modules/yjs/dist/yjs.mjs
623  var yjs_exports = {};
624  __export(yjs_exports, {
625    AbsolutePosition: () => AbsolutePosition,
626    AbstractConnector: () => AbstractConnector,
627    AbstractStruct: () => AbstractStruct,
628    AbstractType: () => AbstractType,
629    Array: () => YArray,
630    ContentAny: () => ContentAny,
631    ContentBinary: () => ContentBinary,
632    ContentDeleted: () => ContentDeleted,
633    ContentDoc: () => ContentDoc,
634    ContentEmbed: () => ContentEmbed,
635    ContentFormat: () => ContentFormat,
636    ContentJSON: () => ContentJSON,
637    ContentString: () => ContentString,
638    ContentType: () => ContentType,
639    Doc: () => Doc,
640    GC: () => GC,
641    ID: () => ID,
642    Item: () => Item,
643    Map: () => YMap,
644    PermanentUserData: () => PermanentUserData,
645    RelativePosition: () => RelativePosition,
646    Skip: () => Skip,
647    Snapshot: () => Snapshot,
648    Text: () => YText,
649    Transaction: () => Transaction,
650    UndoManager: () => UndoManager,
651    UpdateDecoderV1: () => UpdateDecoderV1,
652    UpdateDecoderV2: () => UpdateDecoderV2,
653    UpdateEncoderV1: () => UpdateEncoderV1,
654    UpdateEncoderV2: () => UpdateEncoderV2,
655    XmlElement: () => YXmlElement,
656    XmlFragment: () => YXmlFragment,
657    XmlHook: () => YXmlHook,
658    XmlText: () => YXmlText,
659    YArrayEvent: () => YArrayEvent,
660    YEvent: () => YEvent,
661    YMapEvent: () => YMapEvent,
662    YTextEvent: () => YTextEvent,
663    YXmlEvent: () => YXmlEvent,
664    applyUpdate: () => applyUpdate,
665    applyUpdateV2: () => applyUpdateV2,
666    cleanupYTextFormatting: () => cleanupYTextFormatting,
667    compareIDs: () => compareIDs,
668    compareRelativePositions: () => compareRelativePositions,
669    convertUpdateFormatV1ToV2: () => convertUpdateFormatV1ToV2,
670    convertUpdateFormatV2ToV1: () => convertUpdateFormatV2ToV1,
671    createAbsolutePositionFromRelativePosition: () => createAbsolutePositionFromRelativePosition,
672    createDeleteSet: () => createDeleteSet,
673    createDeleteSetFromStructStore: () => createDeleteSetFromStructStore,
674    createDocFromSnapshot: () => createDocFromSnapshot,
675    createID: () => createID,
676    createRelativePositionFromJSON: () => createRelativePositionFromJSON,
677    createRelativePositionFromTypeIndex: () => createRelativePositionFromTypeIndex,
678    createSnapshot: () => createSnapshot,
679    decodeRelativePosition: () => decodeRelativePosition,
680    decodeSnapshot: () => decodeSnapshot,
681    decodeSnapshotV2: () => decodeSnapshotV2,
682    decodeStateVector: () => decodeStateVector,
683    decodeUpdate: () => decodeUpdate,
684    decodeUpdateV2: () => decodeUpdateV2,
685    diffUpdate: () => diffUpdate,
686    diffUpdateV2: () => diffUpdateV2,
687    emptySnapshot: () => emptySnapshot,
688    encodeRelativePosition: () => encodeRelativePosition,
689    encodeSnapshot: () => encodeSnapshot,
690    encodeSnapshotV2: () => encodeSnapshotV2,
691    encodeStateAsUpdate: () => encodeStateAsUpdate,
692    encodeStateAsUpdateV2: () => encodeStateAsUpdateV2,
693    encodeStateVector: () => encodeStateVector,
694    encodeStateVectorFromUpdate: () => encodeStateVectorFromUpdate,
695    encodeStateVectorFromUpdateV2: () => encodeStateVectorFromUpdateV2,
696    equalDeleteSets: () => equalDeleteSets,
697    equalSnapshots: () => equalSnapshots,
698    findIndexSS: () => findIndexSS,
699    findRootTypeKey: () => findRootTypeKey,
700    getItem: () => getItem,
701    getItemCleanEnd: () => getItemCleanEnd,
702    getItemCleanStart: () => getItemCleanStart,
703    getState: () => getState,
704    getTypeChildren: () => getTypeChildren,
705    isDeleted: () => isDeleted,
706    isParentOf: () => isParentOf,
707    iterateDeletedStructs: () => iterateDeletedStructs,
708    logType: () => logType,
709    logUpdate: () => logUpdate,
710    logUpdateV2: () => logUpdateV2,
711    mergeDeleteSets: () => mergeDeleteSets,
712    mergeUpdates: () => mergeUpdates,
713    mergeUpdatesV2: () => mergeUpdatesV2,
714    obfuscateUpdate: () => obfuscateUpdate,
715    obfuscateUpdateV2: () => obfuscateUpdateV2,
716    parseUpdateMeta: () => parseUpdateMeta,
717    parseUpdateMetaV2: () => parseUpdateMetaV2,
718    readUpdate: () => readUpdate,
719    readUpdateV2: () => readUpdateV2,
720    relativePositionToJSON: () => relativePositionToJSON,
721    snapshot: () => snapshot,
722    snapshotContainsUpdate: () => snapshotContainsUpdate,
723    transact: () => transact,
724    tryGc: () => tryGc,
725    typeListToArraySnapshot: () => typeListToArraySnapshot,
726    typeMapGetAllSnapshot: () => typeMapGetAllSnapshot,
727    typeMapGetSnapshot: () => typeMapGetSnapshot
728  });
729
730  

730// node_modules/lib0/map.js
731  var create = () => /* @__PURE__ */ new Map();
732  var copy = (m) => {
733    const r = create();
734    m.forEach((v, k) => {
735      r.set(k, v);
736    });
737    return r;
738  };
739  var setIfUndefined = (map2, key, createT) => {
740    let set = map2.get(key);
741    if (set === void 0) {
742      map2.set(key, set = createT());
743    }
744    return set;
745  };
746  var map = (m, f) => {
747    const res = [];
748    for (const [key, value] of m) {
749      res.push(f(value, key));
750    }
751    return res;
752  };
753  var any = (m, f) => {
754    for (const [key, value] of m) {
755      if (f(value, key)) {
756        return true;
757      }
758    }
759    return false;
760  };
761
762  

762// node_modules/lib0/set.js
763  var create2 = () => /* @__PURE__ */ new Set();
764
765  

765// node_modules/lib0/array.js
766  var last = (arr) => arr[arr.length - 1];
767  var appendTo = (dest, src) => {
768    for (let i = 0; i < src.length; i++) {
769      dest.push(src[i]);
770    }
771  };
772  var from = Array.from;
773  var every = (arr, f) => {
774    for (let i = 0; i < arr.length; i++) {
775      if (!f(arr[i], i, arr)) {
776        return false;
777      }
778    }
779    return true;
780  };
781  var some = (arr, f) => {
782    for (let i = 0; i < arr.length; i++) {
783      if (f(arr[i], i, arr)) {
784        return true;
785      }
786    }
787    return false;
788  };
789  var unfold = (len, f) => {
790    const array = new Array(len);
791    for (let i = 0; i < len; i++) {
792      array[i] = f(i, array);
793    }
794    return array;
795  };
796  var isArray = Array.isArray;
797
798  

798// node_modules/lib0/observable.js
799  var ObservableV2 = class {
800    constructor() {
801      this._observers = create();
802    }
803    /**
804     * @template {keyof EVENTS & string} NAME
805     * @param {NAME} name
806     * @param {EVENTS[NAME]} f
807     */
808    on(name, f) {
809      setIfUndefined(
810        this._observers,
811        /** @type {string} */
812        name,
813        create2
814      ).add(f);
815      return f;
816    }
817    /**
818     * @template {keyof EVENTS & string} NAME
819     * @param {NAME} name
820     * @param {EVENTS[NAME]} f
821     */
822    once(name, f) {
823      const _f = (...args2) => {
824        this.off(
825          name,
826          /** @type {any} */
827          _f
828        );
829        f(...args2);
830      };
831      this.on(
832        name,
833        /** @type {any} */
834        _f
835      );
836    }
837    /**
838     * @template {keyof EVENTS & string} NAME
839     * @param {NAME} name
840     * @param {EVENTS[NAME]} f
841     */
842    off(name, f) {
843      const observers = this._observers.get(name);
844      if (observers !== void 0) {
845        observers.delete(f);
846        if (observers.size === 0) {
847          this._observers.delete(name);
848        }
849      }
850    }
851    /**
852     * Emit a named event. All registered event listeners that listen to the
853     * specified name will receive the event.
854     *
855     * @todo This should catch exceptions
856     *
857     * @template {keyof EVENTS & string} NAME
858     * @param {NAME} name The event name.
859     * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
860     */
861    emit(name, args2) {
862      return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
863    }
864    destroy() {
865      this._observers = create();
866    }
867  };
868  var Observable = class {
869    constructor() {
870      this._observers = create();
871    }
872    /**
873     * @param {N} name
874     * @param {function} f
875     */
876    on(name, f) {
877      setIfUndefined(this._observers, name, create2).add(f);
878    }
879    /**
880     * @param {N} name
881     * @param {function} f
882     */
883    once(name, f) {
884      const _f = (...args2) => {
885        this.off(name, _f);
886        f(...args2);
887      };
888      this.on(name, _f);
889    }
890    /**
891     * @param {N} name
892     * @param {function} f
893     */
894    off(name, f) {
895      const observers = this._observers.get(name);
896      if (observers !== void 0) {
897        observers.delete(f);
898        if (observers.size === 0) {
899          this._observers.delete(name);
900        }
901      }
902    }
903    /**
904     * Emit a named event. All registered event listeners that listen to the
905     * specified name will receive the event.
906     *
907     * @todo This should catch exceptions
908     *
909     * @param {N} name The event name.
910     * @param {Array<any>} args The arguments that are applied to the event listener.
911     */
912    emit(name, args2) {
913      return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
914    }
915    destroy() {
916      this._observers = create();
917    }
918  };
919
920  

920// node_modules/lib0/math.js
921  var floor = Math.floor;
922  var abs = Math.abs;
923  var min = (a, b) => a < b ? a : b;
924  var max = (a, b) => a > b ? a : b;
925  var isNaN2 = Number.isNaN;
926  var isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
927
928  

928// node_modules/lib0/binary.js
929  var BIT1 = 1;
930  var BIT2 = 2;
931  var BIT3 = 4;
932  var BIT4 = 8;
933  var BIT6 = 32;
934  var BIT7 = 64;
935  var BIT8 = 128;
936  var BIT18 = 1 << 17;
937  var BIT19 = 1 << 18;
938  var BIT20 = 1 << 19;
939  var BIT21 = 1 << 20;
940  var BIT22 = 1 << 21;
941  var BIT23 = 1 << 22;
942  var BIT24 = 1 << 23;
943  var BIT25 = 1 << 24;
944  var BIT26 = 1 << 25;
945  var BIT27 = 1 << 26;
946  var BIT28 = 1 << 27;
947  var BIT29 = 1 << 28;
948  var BIT30 = 1 << 29;
949  var BIT31 = 1 << 30;
950  var BIT32 = 1 << 31;
951  var BITS5 = 31;
952  var BITS6 = 63;
953  var BITS7 = 127;
954  var BITS17 = BIT18 - 1;
955  var BITS18 = BIT19 - 1;
956  var BITS19 = BIT20 - 1;
957  var BITS20 = BIT21 - 1;
958  var BITS21 = BIT22 - 1;
959  var BITS22 = BIT23 - 1;
960  var BITS23 = BIT24 - 1;
961  var BITS24 = BIT25 - 1;
962  var BITS25 = BIT26 - 1;
963  var BITS26 = BIT27 - 1;
964  var BITS27 = BIT28 - 1;
965  var BITS28 = BIT29 - 1;
966  var BITS29 = BIT30 - 1;
967  var BITS30 = BIT31 - 1;
968  var BITS31 = 2147483647;
969
970  

970// node_modules/lib0/number.js
971  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
972  var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
973  var LOWEST_INT32 = 1 << 31;
974  var isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
975  var isNaN3 = Number.isNaN;
976  var parseInt2 = Number.parseInt;
977
978  

978// node_modules/lib0/string.js
979  var fromCharCode = String.fromCharCode;
980  var fromCodePoint = String.fromCodePoint;
981  var MAX_UTF16_CHARACTER = fromCharCode(65535);
982  var toLowerCase = (s) => s.toLowerCase();
983  var trimLeftRegex = /^\s*/g;
984  var trimLeft = (s) => s.replace(trimLeftRegex, "");
985  var fromCamelCaseRegex = /([A-Z])/g;
986  var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
987  var _encodeUtf8Polyfill = (str) => {
988    const encodedString = unescape(encodeURIComponent(str));
989    const len = encodedString.length;
990    const buf = new Uint8Array(len);
991    for (let i = 0; i < len; i++) {
992      buf[i] = /** @type {number} */
993      encodedString.codePointAt(i);
994    }
995    return buf;
996  };
997  var utf8TextEncoder = (
998    /** @type {TextEncoder} */
999    typeof TextEncoder !== "undefined" ? new TextEncoder() : null
1000  );
1001  var _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
1002  var encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
1003  var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
1004  if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
1005    utf8TextDecoder = null;
1006  }
1007  var repeat = (source, n) => unfold(n, () => source).join("");
1008
1009  

1009// node_modules/lib0/encoding.js
1010  var Encoder = class {
1011    constructor() {
1012      this.cpos = 0;
1013      this.cbuf = new Uint8Array(100);
1014      this.bufs = [];
1015    }
1016  };
1017  var createEncoder = () => new Encoder();
1018  var length = (encoder) => {
1019    let len = encoder.cpos;
1020    for (let i = 0; i < encoder.bufs.length; i++) {
1021      len += encoder.bufs[i].length;
1022    }
1023    return len;
1024  };
1025  var toUint8Array = (encoder) => {
1026    const uint8arr = new Uint8Array(length(encoder));
1027    let curPos = 0;
1028    for (let i = 0; i < encoder.bufs.length; i++) {
1029      const d = encoder.bufs[i];
1030      uint8arr.set(d, curPos);
1031      curPos += d.length;
1032    }
1033    uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
1034    return uint8arr;
1035  };
1036  var verifyLen = (encoder, len) => {
1037    const bufferLen = encoder.cbuf.length;
1038    if (bufferLen - encoder.cpos < len) {
1039      encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
1040      encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
1041      encoder.cpos = 0;
1042    }
1043  };
1044  var write = (encoder, num) => {
1045    const bufferLen = encoder.cbuf.length;
1046    if (encoder.cpos === bufferLen) {
1047      encoder.bufs.push(encoder.cbuf);
1048      encoder.cbuf = new Uint8Array(bufferLen * 2);
1049      encoder.cpos = 0;
1050    }
1051    encoder.cbuf[encoder.cpos++] = num;
1052  };
1053  var writeUint8 = write;
1054  var writeVarUint = (encoder, num) => {
1055    while (num > BITS7) {
1056      write(encoder, BIT8 | BITS7 & num);
1057      num = floor(num / 128);
1058    }
1059    write(encoder, BITS7 & num);
1060  };
1061  var writeVarInt = (encoder, num) => {
1062    const isNegative = isNegativeZero(num);
1063    if (isNegative) {
1064      num = -num;
1065    }
1066    write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | BITS6 & num);
1067    num = floor(num / 64);
1068    while (num > 0) {
1069      write(encoder, (num > BITS7 ? BIT8 : 0) | BITS7 & num);
1070      num = floor(num / 128);
1071    }
1072  };
1073  var _strBuffer = new Uint8Array(3e4);
1074  var _maxStrBSize = _strBuffer.length / 3;
1075  var _writeVarStringNative = (encoder, str) => {
1076    if (str.length < _maxStrBSize) {
1077      const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
1078      writeVarUint(encoder, written);
1079      for (let i = 0; i < written; i++) {
1080        write(encoder, _strBuffer[i]);
1081      }
1082    } else {
1083      writeVarUint8Array(encoder, encodeUtf8(str));
1084    }
1085  };
1086  var _writeVarStringPolyfill = (encoder, str) => {
1087    const encodedString = unescape(encodeURIComponent(str));
1088    const len = encodedString.length;
1089    writeVarUint(encoder, len);
1090    for (let i = 0; i < len; i++) {
1091      write(
1092        encoder,
1093        /** @type {number} */
1094        encodedString.codePointAt(i)
1095      );
1096    }
1097  };
1098  var writeVarString = utf8TextEncoder && /** @type {any} */
1099  utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
1100  var writeBinaryEncoder = (encoder, append2) => writeUint8Array(encoder, toUint8Array(append2));
1101  var writeUint8Array = (encoder, uint8Array) => {
1102    const bufferLen = encoder.cbuf.length;
1103    const cpos = encoder.cpos;
1104    const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
1105    const rightCopyLen = uint8Array.length - leftCopyLen;
1106    encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
1107    encoder.cpos += leftCopyLen;
1108    if (rightCopyLen > 0) {
1109      encoder.bufs.push(encoder.cbuf);
1110      encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
1111      encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
1112      encoder.cpos = rightCopyLen;
1113    }
1114  };
1115  var writeVarUint8Array = (encoder, uint8Array) => {
1116    writeVarUint(encoder, uint8Array.byteLength);
1117    writeUint8Array(encoder, uint8Array);
1118  };
1119  var writeOnDataView = (encoder, len) => {
1120    verifyLen(encoder, len);
1121    const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
1122    encoder.cpos += len;
1123    return dview;
1124  };
1125  var writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
1126  var writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
1127  var writeBigInt64 = (encoder, num) => (
1128    /** @type {any} */
1129    writeOnDataView(encoder, 8).setBigInt64(0, num, false)
1130  );
1131  var floatTestBed = new DataView(new ArrayBuffer(4));
1132  var isFloat32 = (num) => {
1133    floatTestBed.setFloat32(0, num);
1134    return floatTestBed.getFloat32(0) === num;
1135  };
1136  var writeAny = (encoder, data) => {
1137    switch (typeof data) {
1138      case "string":
1139        write(encoder, 119);
1140        writeVarString(encoder, data);
1141        break;
1142      case "number":
1143        if (isInteger(data) && abs(data) <= BITS31) {
1144          write(encoder, 125);
1145          writeVarInt(encoder, data);
1146        } else if (isFloat32(data)) {
1147          write(encoder, 124);
1148          writeFloat32(encoder, data);
1149        } else {
1150          write(encoder, 123);
1151          writeFloat64(encoder, data);
1152        }
1153        break;
1154      case "bigint":
1155        write(encoder, 122);
1156        writeBigInt64(encoder, data);
1157        break;
1158      case "object":
1159        if (data === null) {
1160          write(encoder, 126);
1161        } else if (isArray(data)) {
1162          write(encoder, 117);
1163          writeVarUint(encoder, data.length);
1164          for (let i = 0; i < data.length; i++) {
1165            writeAny(encoder, data[i]);
1166          }
1167        } else if (data instanceof Uint8Array) {
1168          write(encoder, 116);
1169          writeVarUint8Array(encoder, data);
1170        } else {
1171          write(encoder, 118);
1172          const keys2 = Object.keys(data);
1173          writeVarUint(encoder, keys2.length);
1174          for (let i = 0; i < keys2.length; i++) {
1175            const key = keys2[i];
1176            writeVarString(encoder, key);
1177            writeAny(encoder, data[key]);
1178          }
1179        }
1180        break;
1181      case "boolean":
1182        write(encoder, data ? 120 : 121);
1183        break;
1184      default:
1185        write(encoder, 127);
1186    }
1187  };
1188  var RleEncoder = class extends Encoder {
1189    /**
1190     * @param {function(Encoder, T):void} writer
1191     */
1192    constructor(writer) {
1193      super();
1194      this.w = writer;
1195      this.s = null;
1196      this.count = 0;
1197    }
1198    /**
1199     * @param {T} v
1200     */
1201    write(v) {
1202      if (this.s === v) {
1203        this.count++;
1204      } else {
1205        if (this.count > 0) {
1206          writeVarUint(this, this.count - 1);
1207        }
1208        this.count = 1;
1209        this.w(this, v);
1210        this.s = v;
1211      }
1212    }
1213  };
1214  var flushUintOptRleEncoder = (encoder) => {
1215    if (encoder.count > 0) {
1216      writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
1217      if (encoder.count > 1) {
1218        writeVarUint(encoder.encoder, encoder.count - 2);
1219      }
1220    }
1221  };
1222  var UintOptRleEncoder = class {
1223    constructor() {
1224      this.encoder = new Encoder();
1225      this.s = 0;
1226      this.count = 0;
1227    }
1228    /**
1229     * @param {number} v
1230     */
1231    write(v) {
1232      if (this.s === v) {
1233        this.count++;
1234      } else {
1235        flushUintOptRleEncoder(this);
1236        this.count = 1;
1237        this.s = v;
1238      }
1239    }
1240    /**
1241     * Flush the encoded state and transform this to a Uint8Array.
1242     *
1243     * Note that this should only be called once.
1244     */
1245    toUint8Array() {
1246      flushUintOptRleEncoder(this);
1247      return toUint8Array(this.encoder);
1248    }
1249  };
1250  var flushIntDiffOptRleEncoder = (encoder) => {
1251    if (encoder.count > 0) {
1252      const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
1253      writeVarInt(encoder.encoder, encodedDiff);
1254      if (encoder.count > 1) {
1255        writeVarUint(encoder.encoder, encoder.count - 2);
1256      }
1257    }
1258  };
1259  var IntDiffOptRleEncoder = class {
1260    constructor() {
1261      this.encoder = new Encoder();
1262      this.s = 0;
1263      this.count = 0;
1264      this.diff = 0;
1265    }
1266    /**
1267     * @param {number} v
1268     */
1269    write(v) {
1270      if (this.diff === v - this.s) {
1271        this.s = v;
1272        this.count++;
1273      } else {
1274        flushIntDiffOptRleEncoder(this);
1275        this.count = 1;
1276        this.diff = v - this.s;
1277        this.s = v;
1278      }
1279    }
1280    /**
1281     * Flush the encoded state and transform this to a Uint8Array.
1282     *
1283     * Note that this should only be called once.
1284     */
1285    toUint8Array() {
1286      flushIntDiffOptRleEncoder(this);
1287      return toUint8Array(this.encoder);
1288    }
1289  };
1290  var StringEncoder = class {
1291    constructor() {
1292      this.sarr = [];
1293      this.s = "";
1294      this.lensE = new UintOptRleEncoder();
1295    }
1296    /**
1297     * @param {string} string
1298     */
1299    write(string) {
1300      this.s += string;
1301      if (this.s.length > 19) {
1302        this.sarr.push(this.s);
1303        this.s = "";
1304      }
1305      this.lensE.write(string.length);
1306    }
1307    toUint8Array() {
1308      const encoder = new Encoder();
1309      this.sarr.push(this.s);
1310      this.s = "";
1311      writeVarString(encoder, this.sarr.join(""));
1312      writeUint8Array(encoder, this.lensE.toUint8Array());
1313      return toUint8Array(encoder);
1314    }
1315  };
1316
1317  

1317// node_modules/lib0/error.js
1318  var create3 = (s) => new Error(s);
1319  var methodUnimplemented = () => {
1320    throw create3("Method unimplemented");
1321  };
1322  var unexpectedCase = () => {
1323    throw create3("Unexpected case");
1324  };
1325
1326  

1326// node_modules/lib0/decoding.js
1327  var errorUnexpectedEndOfArray = create3("Unexpected end of array");
1328  var errorIntegerOutOfRange = create3("Integer out of Range");
1329  var Decoder = class {
1330    /**
1331     * @param {Uint8Array<Buf>} uint8Array Binary data to decode
1332     */
1333    constructor(uint8Array) {
1334      this.arr = uint8Array;
1335      this.pos = 0;
1336    }
1337  };
1338  var createDecoder = (uint8Array) => new Decoder(uint8Array);
1339  var hasContent = (decoder) => decoder.pos !== decoder.arr.length;
1340  var readUint8Array = (decoder, len) => {
1341    const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
1342    decoder.pos += len;
1343    return view;
1344  };
1345  var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
1346  var readUint8 = (decoder) => decoder.arr[decoder.pos++];
1347  var readVarUint = (decoder) => {
1348    let num = 0;
1349    let mult = 1;
1350    const len = decoder.arr.length;
1351    while (decoder.pos < len) {
1352      const r = decoder.arr[decoder.pos++];
1353      num = num + (r & BITS7) * mult;
1354      mult *= 128;
1355      if (r < BIT8) {
1356        return num;
1357      }
1358      if (num > MAX_SAFE_INTEGER) {
1359        throw errorIntegerOutOfRange;
1360      }
1361    }
1362    throw errorUnexpectedEndOfArray;
1363  };
1364  var readVarInt = (decoder) => {
1365    let r = decoder.arr[decoder.pos++];
1366    let num = r & BITS6;
1367    let mult = 64;
1368    const sign = (r & BIT7) > 0 ? -1 : 1;
1369    if ((r & BIT8) === 0) {
1370      return sign * num;
1371    }
1372    const len = decoder.arr.length;
1373    while (decoder.pos < len) {
1374      r = decoder.arr[decoder.pos++];
1375      num = num + (r & BITS7) * mult;
1376      mult *= 128;
1377      if (r < BIT8) {
1378        return sign * num;
1379      }
1380      if (num > MAX_SAFE_INTEGER) {
1381        throw errorIntegerOutOfRange;
1382      }
1383    }
1384    throw errorUnexpectedEndOfArray;
1385  };
1386  var _readVarStringPolyfill = (decoder) => {
1387    let remainingLen = readVarUint(decoder);
1388    if (remainingLen === 0) {
1389      return "";
1390    } else {
1391      let encodedString = String.fromCodePoint(readUint8(decoder));
1392      if (--remainingLen < 100) {
1393        while (remainingLen--) {
1394          encodedString += String.fromCodePoint(readUint8(decoder));
1395        }
1396      } else {
1397        while (remainingLen > 0) {
1398          const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
1399          const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
1400          decoder.pos += nextLen;
1401          encodedString += String.fromCodePoint.apply(
1402            null,
1403            /** @type {any} */
1404            bytes
1405          );
1406          remainingLen -= nextLen;
1407        }
1408      }
1409      return decodeURIComponent(escape(encodedString));
1410    }
1411  };
1412  var _readVarStringNative = (decoder) => (
1413    /** @type any */
1414    utf8TextDecoder.decode(readVarUint8Array(decoder))
1415  );
1416  var readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
1417  var readFromDataView = (decoder, len) => {
1418    const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
1419    decoder.pos += len;
1420    return dv;
1421  };
1422  var readFloat32 = (decoder) => readFromDataView(decoder, 4).getFloat32(0, false);
1423  var readFloat64 = (decoder) => readFromDataView(decoder, 8).getFloat64(0, false);
1424  var readBigInt64 = (decoder) => (
1425    /** @type {any} */
1426    readFromDataView(decoder, 8).getBigInt64(0, false)
1427  );
1428  var readAnyLookupTable = [
1429    (decoder) => void 0,
1430    // CASE 127: undefined
1431    (decoder) => null,
1432    // CASE 126: null
1433    readVarInt,
1434    // CASE 125: integer
1435    readFloat32,
1436    // CASE 124: float32
1437    readFloat64,
1438    // CASE 123: float64
1439    readBigInt64,
1440    // CASE 122: bigint
1441    (decoder) => false,
1442    // CASE 121: boolean (false)
1443    (decoder) => true,
1444    // CASE 120: boolean (true)
1445    readVarString,
1446    // CASE 119: string
1447    (decoder) => {
1448      const len = readVarUint(decoder);
1449      const obj = {};
1450      for (let i = 0; i < len; i++) {
1451        const key = readVarString(decoder);
1452        obj[key] = readAny(decoder);
1453      }
1454      return obj;
1455    },
1456    (decoder) => {
1457      const len = readVarUint(decoder);
1458      const arr = [];
1459      for (let i = 0; i < len; i++) {
1460        arr.push(readAny(decoder));
1461      }
1462      return arr;
1463    },
1464    readVarUint8Array
1465    // CASE 116: Uint8Array
1466  ];
1467  var readAny = (decoder) => readAnyLookupTable[127 - readUint8(decoder)](decoder);
1468  var RleDecoder = class extends Decoder {
1469    /**
1470     * @param {Uint8Array} uint8Array
1471     * @param {function(Decoder):T} reader
1472     */
1473    constructor(uint8Array, reader) {
1474      super(uint8Array);
1475      this.reader = reader;
1476      this.s = null;
1477      this.count = 0;
1478    }
1479    read() {
1480      if (this.count === 0) {
1481        this.s = this.reader(this);
1482        if (hasContent(this)) {
1483          this.count = readVarUint(this) + 1;
1484        } else {
1485          this.count = -1;
1486        }
1487      }
1488      this.count--;
1489      return (
1490        /** @type {T} */
1491        this.s
1492      );
1493    }
1494  };
1495  var UintOptRleDecoder = class extends Decoder {
1496    /**
1497     * @param {Uint8Array} uint8Array
1498     */
1499    constructor(uint8Array) {
1500      super(uint8Array);
1501      this.s = 0;
1502      this.count = 0;
1503    }
1504    read() {
1505      if (this.count === 0) {
1506        this.s = readVarInt(this);
1507        const isNegative = isNegativeZero(this.s);
1508        this.count = 1;
1509        if (isNegative) {
1510          this.s = -this.s;
1511          this.count = readVarUint(this) + 2;
1512        }
1513      }
1514      this.count--;
1515      return (
1516        /** @type {number} */
1517        this.s
1518      );
1519    }
1520  };
1521  var IntDiffOptRleDecoder = class extends Decoder {
1522    /**
1523     * @param {Uint8Array} uint8Array
1524     */
1525    constructor(uint8Array) {
1526      super(uint8Array);
1527      this.s = 0;
1528      this.count = 0;
1529      this.diff = 0;
1530    }
1531    /**
1532     * @return {number}
1533     */
1534    read() {
1535      if (this.count === 0) {
1536        const diff = readVarInt(this);
1537        const hasCount = diff & 1;
1538        this.diff = floor(diff / 2);
1539        this.count = 1;
1540        if (hasCount) {
1541          this.count = readVarUint(this) + 2;
1542        }
1543      }
1544      this.s += this.diff;
1545      this.count--;
1546      return this.s;
1547    }
1548  };
1549  var StringDecoder = class {
1550    /**
1551     * @param {Uint8Array} uint8Array
1552     */
1553    constructor(uint8Array) {
1554      this.decoder = new UintOptRleDecoder(uint8Array);
1555      this.str = readVarString(this.decoder);
1556      this.spos = 0;
1557    }
1558    /**
1559     * @return {string}
1560     */
1561    read() {
1562      const end = this.spos + this.decoder.read();
1563      const res = this.str.slice(this.spos, end);
1564      this.spos = end;
1565      return res;
1566    }
1567  };
1568
1569  

1569// node_modules/lib0/webcrypto.js
1570  var subtle = crypto.subtle;
1571  var getRandomValues = crypto.getRandomValues.bind(crypto);
1572
1573  

1573// node_modules/lib0/random.js
1574  var uint32 = () => getRandomValues(new Uint32Array(1))[0];
1575  var uuidv4Template = "10000000-1000-4000-8000" + -1e11;
1576  var uuidv4 = () => uuidv4Template.replace(
1577    /[018]/g,
1578    /** @param {number} c */
1579    (c) => (c ^ uint32() & 15 >> c / 4).toString(16)
1580  );
1581
1582  

1582// node_modules/lib0/time.js
1583  var getUnixTime = Date.now;
1584
1585  

1585// node_modules/lib0/promise.js
1586  var create4 = (f) => (
1587    /** @type {Promise<T>} */
1588    new Promise(f)
1589  );
1590  var all = Promise.all.bind(Promise);
1591
1592  

1592// node_modules/lib0/conditions.js
1593  var undefinedToNull = (v) => v === void 0 ? null : v;
1594
1595  

1595// node_modules/lib0/storage.js
1596  var VarStoragePolyfill = class {
1597    constructor() {
1598      this.map = /* @__PURE__ */ new Map();
1599    }
1600    /**
1601     * @param {string} key
1602     * @param {any} newValue
1603     */
1604    setItem(key, newValue) {
1605      this.map.set(key, newValue);
1606    }
1607    /**
1608     * @param {string} key
1609     */
1610    getItem(key) {
1611      return this.map.get(key);
1612    }
1613  };
1614  var _localStorage = new VarStoragePolyfill();
1615  var usePolyfill = true;
1616  try {
1617    if (typeof localStorage !== "undefined" && localStorage) {
1618      _localStorage = localStorage;
1619      usePolyfill = false;
1620    }
1621  } catch (e) {
1622  }
1623  var varStorage = _localStorage;
1624
1625  

1625// node_modules/lib0/trait/equality.js
1626  var EqualityTraitSymbol = /* @__PURE__ */ Symbol("Equality");
1627  var equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
1628
1629  

1629// node_modules/lib0/object.js
1630  var isObject = (o) => typeof o === "object";
1631  var assign = Object.assign;
1632  var keys = Object.keys;
1633  var forEach = (obj, f) => {
1634    for (const key in obj) {
1635      f(obj[key], key);
1636    }
1637  };
1638  var size = (obj) => keys(obj).length;
1639  var isEmpty = (obj) => {
1640    for (const _k in obj) {
1641      return false;
1642    }
1643    return true;
1644  };
1645  var every2 = (obj, f) => {
1646    for (const key in obj) {
1647      if (!f(obj[key], key)) {
1648        return false;
1649      }
1650    }
1651    return true;
1652  };
1653  var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
1654  var equalFlat = (a, b) => a === b || size(a) === size(b) && every2(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && equals(b[key], val));
1655  var freeze = Object.freeze;
1656  var deepFreeze = (o) => {
1657    for (const key in o) {
1658      const c = o[key];
1659      if (typeof c === "object" || typeof c === "function") {
1660        deepFreeze(o[key]);
1661      }
1662    }
1663    return freeze(o);
1664  };
1665
1666  

1666// node_modules/lib0/function.js
1667  var callAll = (fs, args2, i = 0) => {
1668    try {
1669      for (; i < fs.length; i++) {
1670        fs[i](...args2);
1671      }
1672    } finally {
1673      if (i < fs.length) {
1674        callAll(fs, args2, i + 1);
1675      }
1676    }
1677  };
1678  var id = (a) => a;
1679  var equalityDeep = (a, b) => {
1680    if (a === b) {
1681      return true;
1682    }
1683    if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
1684      return false;
1685    }
1686    if (a[EqualityTraitSymbol] != null) {
1687      return a[EqualityTraitSymbol](b);
1688    }
1689    switch (a.constructor) {
1690      case ArrayBuffer:
1691        a = new Uint8Array(a);
1692        b = new Uint8Array(b);
1693      // eslint-disable-next-line no-fallthrough
1694      case Uint8Array: {
1695        if (a.byteLength !== b.byteLength) {
1696          return false;
1697        }
1698        for (let i = 0; i < a.length; i++) {
1699          if (a[i] !== b[i]) {
1700            return false;
1701          }
1702        }
1703        break;
1704      }
1705      case Set: {
1706        if (a.size !== b.size) {
1707          return false;
1708        }
1709        for (const value of a) {
1710          if (!b.has(value)) {
1711            return false;
1712          }
1713        }
1714        break;
1715      }
1716      case Map: {
1717        if (a.size !== b.size) {
1718          return false;
1719        }
1720        for (const key of a.keys()) {
1721          if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
1722            return false;
1723          }
1724        }
1725        break;
1726      }
1727      case void 0:
1728      case Object:
1729        if (size(a) !== size(b)) {
1730          return false;
1731        }
1732        for (const key in a) {
1733          if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
1734            return false;
1735          }
1736        }
1737        break;
1738      case Array:
1739        if (a.length !== b.length) {
1740          return false;
1741        }
1742        for (let i = 0; i < a.length; i++) {
1743          if (!equalityDeep(a[i], b[i])) {
1744            return false;
1745          }
1746        }
1747        break;
1748      default:
1749        return false;
1750    }
1751    return true;
1752  };
1753  var isOneOf = (value, options) => options.includes(value);
1754
1755  

1755// node_modules/lib0/environment.js
1756  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]";
1757  var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && !isNode;
1758  var isMac = typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
1759  var params;
1760  var args = [];
1761  var computeParams = () => {
1762    if (params === void 0) {
1763      if (isNode) {
1764        params = create();
1765        const pargs = process.argv;
1766        let currParamName = null;
1767        for (let i = 0; i < pargs.length; i++) {
1768          const parg = pargs[i];
1769          if (parg[0] === "-") {
1770            if (currParamName !== null) {
1771              params.set(currParamName, "");
1772            }
1773            currParamName = parg;
1774          } else {
1775            if (currParamName !== null) {
1776              params.set(currParamName, parg);
1777              currParamName = null;
1778            } else {
1779              args.push(parg);
1780            }
1781          }
1782        }
1783        if (currParamName !== null) {
1784          params.set(currParamName, "");
1785        }
1786      } else if (typeof location === "object") {
1787        params = create();
1788        (location.search || "?").slice(1).split("&").forEach((kv) => {
1789          if (kv.length !== 0) {
1790            const [key, value] = kv.split("=");
1791            params.set(`--${fromCamelCase(key, "-")}`, value);
1792            params.set(`-${fromCamelCase(key, "-")}`, value);
1793          }
1794        });
1795      } else {
1796        params = create();
1797      }
1798    }
1799    return params;
1800  };
1801  var hasParam = (name) => computeParams().has(name);
1802  var getVariable = (name) => isNode ? undefinedToNull(process.env[name.toUpperCase().replaceAll("-", "_")]) : undefinedToNull(varStorage.getItem(name));
1803  var hasConf = (name) => hasParam("--" + name) || getVariable(name) !== null;
1804  var production = hasConf("production");
1805  var forceColor = isNode && isOneOf(process.env.FORCE_COLOR, ["true", "1", "2"]);
1806  var supportsColor = forceColor || !hasParam("--no-colors") && // @todo deprecate --no-colors
1807  !hasConf("no-color") && (!isNode || process.stdout.isTTY) && (!isNode || hasParam("--color") || getVariable("COLORTERM") !== null || (getVariable("TERM") || "").includes("color"));
1808
1809  

1809// node_modules/lib0/buffer.js
1810  var createUint8ArrayFromLen = (len) => new Uint8Array(len);
1811  var createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length2) => new Uint8Array(buffer, byteOffset, length2);
1812  var toBase64Browser = (bytes) => {
1813    let s = "";
1814    for (let i = 0; i < bytes.byteLength; i++) {
1815      s += fromCharCode(bytes[i]);
1816    }
1817    return btoa(s);
1818  };
1819  var toBase64Node = (bytes) => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
1820  var fromBase64Browser = (s) => {
1821    const a = atob(s);
1822    const bytes = createUint8ArrayFromLen(a.length);
1823    for (let i = 0; i < a.length; i++) {
1824      bytes[i] = a.charCodeAt(i);
1825    }
1826    return bytes;
1827  };
1828  var fromBase64Node = (s) => {
1829    const buf = Buffer.from(s, "base64");
1830    return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength);
1831  };
1832  var toBase64 = isBrowser ? toBase64Browser : toBase64Node;
1833  var fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
1834  var copyUint8Array = (uint8Array) => {
1835    const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
1836    newBuf.set(uint8Array);
1837    return newBuf;
1838  };
1839
1840  

1840// node_modules/lib0/pair.js
1841  var Pair = class {
1842    /**
1843     * @param {L} left
1844     * @param {R} right
1845     */
1846    constructor(left, right) {
1847      this.left = left;
1848      this.right = right;
1849    }
1850  };
1851  var create5 = (left, right) => new Pair(left, right);
1852
1853  

1853// node_modules/lib0/prng.js
1854  var bool = (gen) => gen.next() >= 0.5;
1855  var int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1856  var int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
1857  var int31 = (gen, min2, max2) => int32(gen, min2, max2);
1858  var letter = (gen) => fromCharCode(int31(gen, 97, 122));
1859  var word = (gen, minLen = 0, maxLen = 20) => {
1860    const len = int31(gen, minLen, maxLen);
1861    let str = "";
1862    for (let i = 0; i < len; i++) {
1863      str += letter(gen);
1864    }
1865    return str;
1866  };
1867  var oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
1868
1869  

1869// node_modules/lib0/schema.js
1870  var schemaSymbol = /* @__PURE__ */ Symbol("0schema");
1871  var ValidationError = class {
1872    constructor() {
1873      this._rerrs = [];
1874    }
1875    /**
1876     * @param {string?} path
1877     * @param {string} expected
1878     * @param {string} has
1879     * @param {string?} message
1880     */
1881    extend(path, expected, has, message = null) {
1882      this._rerrs.push({ path, expected, has, message });
1883    }
1884    toString() {
1885      const s = [];
1886      for (let i = this._rerrs.length - 1; i > 0; i--) {
1887        const r = this._rerrs[i];
1888        s.push(repeat(" ", (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
1889      }
1890      return s.join("\n");
1891    }
1892  };
1893  var shapeExtends = (a, b) => {
1894    if (a === b) return true;
1895    if (a == null || b == null || a.constructor !== b.constructor) return false;
1896    if (a[EqualityTraitSymbol]) return equals(a, b);
1897    if (isArray(a)) {
1898      return every(
1899        a,
1900        (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
1901      );
1902    } else if (isObject(a)) {
1903      return every2(
1904        a,
1905        (aitem, akey) => shapeExtends(aitem, b[akey])
1906      );
1907    }
1908    return false;
1909  };
1910  var Schema = class {
1911    // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
1912    /**
1913     * If true, the more things are added to the shape the more objects this schema will accept (e.g.
1914     * union). By default, the more objects are added, the the fewer objects this schema will accept.
1915     * @protected
1916     */
1917    static _dilutes = false;
1918    /**
1919     * @param {Schema<any>} other
1920     */
1921    extends(other) {
1922      let [a, b] = [
1923        /** @type {any} */
1924        this.shape,
1925        /** @type {any} */
1926        other.shape
1927      ];
1928      if (
1929        /** @type {typeof Schema<any>} */
1930        this.constructor._dilutes
1931      ) [b, a] = [a, b];
1932      return shapeExtends(a, b);
1933    }
1934    /**
1935     * Overwrite this when necessary. By default, we only check the `shape` property which every shape
1936     * should have.
1937     * @param {Schema<any>} other
1938     */
1939    equals(other) {
1940      return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
1941    }
1942    [schemaSymbol]() {
1943      return true;
1944    }
1945    /**
1946     * @param {object} other
1947     */
1948    [EqualityTraitSymbol](other) {
1949      return this.equals(
1950        /** @type {any} */
1951        other
1952      );
1953    }
1954    /**
1955     * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
1956     * Schema. Validate will check the structure of the parameter and return true iff the instance
1957     * really is an instance of Schema.
1958     *
1959     * @param {T} o
1960     * @return {boolean}
1961     */
1962    validate(o) {
1963      return this.check(o);
1964    }
1965    /* c8 ignore start */
1966    /**
1967     * Similar to validate, but this method accepts untyped parameters.
1968     *
1969     * @param {any} _o
1970     * @param {ValidationError} [_err]
1971     * @return {_o is T}
1972     */
1973    check(_o, _err) {
1974      methodUnimplemented();
1975    }
1976    /* c8 ignore stop */
1977    /**
1978     * @type {Schema<T?>}
1979     */
1980    get nullable() {
1981      return $union(this, $null);
1982    }
1983    /**
1984     * @type {$Optional<Schema<T>>}
1985     */
1986    get optional() {
1987      return new $Optional(
1988        /** @type {Schema<T>} */
1989        this
1990      );
1991    }
1992    /**
1993     * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
1994     * Use this if you know that the type is of a specific type and you just want to convince the type
1995     * system.
1996     *
1997     * **Do not rely on these error messages!**
1998     * Performs an assertion check only if not in a production environment.
1999     *
2000     * @template OO
2001     * @param {OO} o
2002     * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
2003     */
2004    cast(o) {
2005      assert(o, this);
2006      return (
2007        /** @type {any} */
2008        o
2009      );
2010    }
2011    /**
2012     * EXPECTO PATRONUM!! 🪄
2013     * This function protects against type errors. Though it may not work in the real world.
2014     *
2015     * "After all this time?"
2016     * "Always." - Snape, talking about type safety
2017     *
2018     * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
2019     * Use this if you know that the type is of a specific type and you just want to convince the type
2020     * system.
2021     *
2022     * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
2023     *
2024     * **Do not rely on these error messages!**
2025     * Performs an assertion check if not in a production environment.
2026     *
2027     * @param {T} o
2028     * @return {o extends T ? T : never}
2029     */
2030    expect(o) {
2031      assert(o, this);
2032      return o;
2033    }
2034  };
2035  var $ConstructedBy = class extends Schema {
2036    /**
2037     * @param {C} c
2038     * @param {((o:Instance<C>)=>boolean)|null} check
2039     */
2040    constructor(c, check) {
2041      super();
2042      this.shape = c;
2043      this._c = check;
2044    }
2045    /**
2046     * @param {any} o
2047     * @param {ValidationError} [err]
2048     * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
2049     */
2050    check(o, err = void 0) {
2051      const c = o?.constructor === this.shape && (this._c == null || this._c(o));
2052      !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
2053      return c;
2054    }
2055  };
2056  var $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
2057  var $$constructedBy = $constructedBy($ConstructedBy);
2058  var $Custom = class extends Schema {
2059    /**
2060     * @param {(o:any) => boolean} check
2061     */
2062    constructor(check) {
2063      super();
2064      this.shape = check;
2065    }
2066    /**
2067     * @param {any} o
2068     * @param {ValidationError} err
2069     * @return {o is any}
2070     */
2071    check(o, err) {
2072      const c = this.shape(o);
2073      !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
2074      return c;
2075    }
2076  };
2077  var $custom = (check) => new $Custom(check);
2078  var $$custom = $constructedBy($Custom);
2079  var $Literal = class extends Schema {
2080    /**
2081     * @param {Array<T>} literals
2082     */
2083    constructor(literals) {
2084      super();
2085      this.shape = literals;
2086    }
2087    /**
2088     *
2089     * @param {any} o
2090     * @param {ValidationError} [err]
2091     * @return {o is T}
2092     */
2093    check(o, err) {
2094      const c = this.shape.some((a) => a === o);
2095      !c && err?.extend(null, this.shape.join(" | "), o.toString());
2096      return c;
2097    }
2098  };
2099  var $literal = (...literals) => new $Literal(literals);
2100  var $$literal = $constructedBy($Literal);
2101  var _regexEscape = (
2102    /** @type {any} */
2103    RegExp.escape || /** @type {(str:string) => string} */
2104    ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s))
2105  );
2106  var _schemaStringTemplateToRegex = (s) => {
2107    if ($string.check(s)) {
2108      return [_regexEscape(s)];
2109    }
2110    if ($$literal.check(s)) {
2111      return (
2112        /** @type {Array<string|number>} */
2113        s.shape.map((v) => v + "")
2114      );
2115    }
2116    if ($$number.check(s)) {
2117      return ["[+-]?\\d+.?\\d*"];
2118    }
2119    if ($$string.check(s)) {
2120      return [".*"];
2121    }
2122    if ($$union.check(s)) {
2123      return s.shape.map(_schemaStringTemplateToRegex).flat(1);
2124    }
2125    unexpectedCase();
2126  };
2127  var $StringTemplate = class extends Schema {
2128    /**
2129     * @param {T} shape
2130     */
2131    constructor(shape) {
2132      super();
2133      this.shape = shape;
2134      this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
2135    }
2136    /**
2137     * @param {any} o
2138     * @param {ValidationError} [err]
2139     * @return {o is CastStringTemplateArgsToTemplate<T>}
2140     */
2141    check(o, err) {
2142      const c = this._r.exec(o) != null;
2143      !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
2144      return c;
2145    }
2146  };
2147  var $$stringTemplate = $constructedBy($StringTemplate);
2148  var isOptionalSymbol = /* @__PURE__ */ Symbol("optional");
2149  var $Optional = class extends Schema {
2150    /**
2151     * @param {S} shape
2152     */
2153    constructor(shape) {
2154      super();
2155      this.shape = shape;
2156    }
2157    /**
2158     * @param {any} o
2159     * @param {ValidationError} [err]
2160     * @return {o is (Unwrap<S>|undefined)}
2161     */
2162    check(o, err) {
2163      const c = o === void 0 || this.shape.check(o);
2164      !c && err?.extend(null, "undefined (optional)", "()");
2165      return c;
2166    }
2167    get [isOptionalSymbol]() {
2168      return true;
2169    }
2170  };
2171  var $$optional = $constructedBy($Optional);
2172  var $Never = class extends Schema {
2173    /**
2174     * @param {any} _o
2175     * @param {ValidationError} [err]
2176     * @return {_o is never}
2177     */
2178    check(_o, err) {
2179      err?.extend(null, "never", typeof _o);
2180      return false;
2181    }
2182  };
2183  var $never = new $Never();
2184  var $$never = $constructedBy($Never);
2185  var $Object = class _$Object extends Schema {
2186    /**
2187     * @param {S} shape
2188     * @param {boolean} partial
2189     */
2190    constructor(shape, partial = false) {
2191      super();
2192      this.shape = shape;
2193      this._isPartial = partial;
2194    }
2195    static _dilutes = true;
2196    /**
2197     * @type {Schema<Partial<$ObjectToType<S>>>}
2198     */
2199    get partial() {
2200      return new _$Object(this.shape, true);
2201    }
2202    /**
2203     * @param {any} o
2204     * @param {ValidationError} err
2205     * @return {o is $ObjectToType<S>}
2206     */
2207    check(o, err) {
2208      if (o == null) {
2209        err?.extend(null, "object", "null");
2210        return false;
2211      }
2212      return every2(this.shape, (vv, vk) => {
2213        const c = this._isPartial && !hasProperty(o, vk) || vv.check(o[vk], err);
2214        !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
2215        return c;
2216      });
2217    }
2218  };
2219  var $object = (def) => (
2220    /** @type {any} */
2221    new $Object(def)
2222  );
2223  var $$object = $constructedBy($Object);
2224  var $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
2225  var $Record = class extends Schema {
2226    /**
2227     * @param {Keys} keys
2228     * @param {Values} values
2229     */
2230    constructor(keys2, values) {
2231      super();
2232      this.shape = {
2233        keys: keys2,
2234        values
2235      };
2236    }
2237    /**
2238     * @param {any} o
2239     * @param {ValidationError} err
2240     * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
2241     */
2242    check(o, err) {
2243      return o != null && every2(o, (vv, vk) => {
2244        const ck = this.shape.keys.check(vk, err);
2245        !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
2246        return ck && this.shape.values.check(vv, err);
2247      });
2248    }
2249  };
2250  var $record = (keys2, values) => new $Record(keys2, values);
2251  var $$record = $constructedBy($Record);
2252  var $Tuple = class extends Schema {
2253    /**
2254     * @param {S} shape
2255     */
2256    constructor(shape) {
2257      super();
2258      this.shape = shape;
2259    }
2260    /**
2261     * @param {any} o
2262     * @param {ValidationError} err
2263     * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
2264     */
2265    check(o, err) {
2266      return o != null && every2(this.shape, (vv, vk) => {
2267        const c = (
2268          /** @type {Schema<any>} */
2269          vv.check(o[vk], err)
2270        );
2271        !c && err?.extend(vk.toString(), "Tuple", typeof vv);
2272        return c;
2273      });
2274    }
2275  };
2276  var $tuple = (...def) => new $Tuple(def);
2277  var $$tuple = $constructedBy($Tuple);
2278  var $Array = class extends Schema {
2279    /**
2280     * @param {Array<S>} v
2281     */
2282    constructor(v) {
2283      super();
2284      this.shape = v.length === 1 ? v[0] : new $Union(v);
2285    }
2286    /**
2287     * @param {any} o
2288     * @param {ValidationError} [err]
2289     * @return {o is Array<S extends Schema<infer T> ? T : never>} o
2290     */
2291    check(o, err) {
2292      const c = isArray(o) && every(o, (oi) => this.shape.check(oi));
2293      !c && err?.extend(null, "Array", "");
2294      return c;
2295    }
2296  };
2297  var $array = (...def) => new $Array(def);
2298  var $$array = $constructedBy($Array);
2299  var $arrayAny = $custom((o) => isArray(o));
2300  var $InstanceOf = class extends Schema {
2301    /**
2302     * @param {new (...args:any) => T} constructor
2303     * @param {((o:T) => boolean)|null} check
2304     */
2305    constructor(constructor, check) {
2306      super();
2307      this.shape = constructor;
2308      this._c = check;
2309    }
2310    /**
2311     * @param {any} o
2312     * @param {ValidationError} err
2313     * @return {o is T}
2314     */
2315    check(o, err) {
2316      const c = o instanceof this.shape && (this._c == null || this._c(o));
2317      !c && err?.extend(null, this.shape.name, o?.constructor.name);
2318      return c;
2319    }
2320  };
2321  var $instanceOf = (c, check = null) => new $InstanceOf(c, check);
2322  var $$instanceOf = $constructedBy($InstanceOf);
2323  var $$schema = $instanceOf(Schema);
2324  var $Lambda = class extends Schema {
2325    /**
2326     * @param {Args} args
2327     */
2328    constructor(args2) {
2329      super();
2330      this.len = args2.length - 1;
2331      this.args = $tuple(...args2.slice(-1));
2332      this.res = args2[this.len];
2333    }
2334    /**
2335     * @param {any} f
2336     * @param {ValidationError} err
2337     * @return {f is _LArgsToLambdaDef<Args>}
2338     */
2339    check(f, err) {
2340      const c = f.constructor === Function && f.length <= this.len;
2341      !c && err?.extend(null, "function", typeof f);
2342      return c;
2343    }
2344  };
2345  var $$lambda = $constructedBy($Lambda);
2346  var $function = $custom((o) => typeof o === "function");
2347  var $Intersection = class extends Schema {
2348    /**
2349     * @param {T} v
2350     */
2351    constructor(v) {
2352      super();
2353      this.shape = v;
2354    }
2355    /**
2356     * @param {any} o
2357     * @param {ValidationError} [err]
2358     * @return {o is Intersect<UnwrapArray<T>>}
2359     */
2360    check(o, err) {
2361      const c = every(this.shape, (check) => check.check(o, err));
2362      !c && err?.extend(null, "Intersectinon", typeof o);
2363      return c;
2364    }
2365  };
2366  var $$intersect = $constructedBy($Intersection, (o) => o.shape.length > 0);
2367  var $Union = class extends Schema {
2368    static _dilutes = true;
2369    /**
2370     * @param {Array<Schema<S>>} v
2371     */
2372    constructor(v) {
2373      super();
2374      this.shape = v;
2375    }
2376    /**
2377     * @param {any} o
2378     * @param {ValidationError} [err]
2379     * @return {o is S}
2380     */
2381    check(o, err) {
2382      const c = some(this.shape, (vv) => vv.check(o, err));
2383      err?.extend(null, "Union", typeof o);
2384      return c;
2385    }
2386  };
2387  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);
2388  var $$union = (
2389    /** @type {Schema<$Union<any>>} */
2390    $constructedBy($Union)
2391  );
2392  var _t = () => true;
2393  var $any = $custom(_t);
2394  var $$any = (
2395    /** @type {Schema<Schema<any>>} */
2396    $constructedBy($Custom, (o) => o.shape === _t)
2397  );
2398  var $bigint = $custom((o) => typeof o === "bigint");
2399  var $$bigint = (
2400    /** @type {Schema<Schema<BigInt>>} */
2401    $custom((o) => o === $bigint)
2402  );
2403  var $symbol = $custom((o) => typeof o === "symbol");
2404  var $$symbol = (
2405    /** @type {Schema<Schema<Symbol>>} */
2406    $custom((o) => o === $symbol)
2407  );
2408  var $number = $custom((o) => typeof o === "number");
2409  var $$number = (
2410    /** @type {Schema<Schema<number>>} */
2411    $custom((o) => o === $number)
2412  );
2413  var $string = $custom((o) => typeof o === "string");
2414  var $$string = (
2415    /** @type {Schema<Schema<string>>} */
2416    $custom((o) => o === $string)
2417  );
2418  var $boolean = $custom((o) => typeof o === "boolean");
2419  var $$boolean = (
2420    /** @type {Schema<Schema<Boolean>>} */
2421    $custom((o) => o === $boolean)
2422  );
2423  var $undefined = $literal(void 0);
2424  var $$undefined = (
2425    /** @type {Schema<Schema<undefined>>} */
2426    $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0)
2427  );
2428  var $void = $literal(void 0);
2429  var $null = $literal(null);
2430  var $$null = (
2431    /** @type {Schema<Schema<null>>} */
2432    $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
2433  );
2434  var $uint8Array = $constructedBy(Uint8Array);
2435  var $$uint8Array = (
2436    /** @type {Schema<Schema<Uint8Array>>} */
2437    $constructedBy($ConstructedBy, (o) => o.shape === Uint8Array)
2438  );
2439  var $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
2440  var $json = (() => {
2441    const $jsonArr = (
2442      /** @type {$Array<$any>} */
2443      $array($any)
2444    );
2445    const $jsonRecord = (
2446      /** @type {$Record<$string,$any>} */
2447      $record($string, $any)
2448    );
2449    const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
2450    $jsonArr.shape = $json2;
2451    $jsonRecord.shape.values = $json2;
2452    return $json2;
2453  })();
2454  var $ = (o) => {
2455    if ($$schema.check(o)) {
2456      return (
2457        /** @type {any} */
2458        o
2459      );
2460    } else if ($objectAny.check(o)) {
2461      const o2 = {};
2462      for (const k in o) {
2463        o2[k] = $(o[k]);
2464      }
2465      return (
2466        /** @type {any} */
2467        $object(o2)
2468      );
2469    } else if ($arrayAny.check(o)) {
2470      return (
2471        /** @type {any} */
2472        $union(...o.map($))
2473      );
2474    } else if ($primitive.check(o)) {
2475      return (
2476        /** @type {any} */
2477        $literal(o)
2478      );
2479    } else if ($function.check(o)) {
2480      return (
2481        /** @type {any} */
2482        $constructedBy(
2483          /** @type {any} */
2484          o
2485        )
2486      );
2487    }
2488    unexpectedCase();
2489  };
2490  var assert = production ? () => {
2491  } : (o, schema) => {
2492    const err = new ValidationError();
2493    if (!schema.check(o, err)) {
2494      throw create3(`Expected value to be of type ${schema.constructor.name}.
2495${err.toString()}`);
2496    }
2497  };
2498  var PatternMatcher = class {
2499    /**
2500     * @param {Schema<State>} [$state]
2501     */
2502    constructor($state) {
2503      this.patterns = [];
2504      this.$state = $state;
2505    }
2506    /**
2507     * @template P
2508     * @template R
2509     * @param {P} pattern
2510     * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
2511     * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
2512     */
2513    if(pattern, handler) {
2514      this.patterns.push({ if: $(pattern), h: handler });
2515      return this;
2516    }
2517    /**
2518     * @template R
2519     * @param {(o:any,s:State)=>R} h
2520     */
2521    else(h) {
2522      return this.if($any, h);
2523    }
2524    /**
2525     * @return {State extends undefined
2526     *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
2527     *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
2528     */
2529    done() {
2530      return (
2531        /** @type {any} */
2532        (o, s) => {
2533          for (let i = 0; i < this.patterns.length; i++) {
2534            const p = this.patterns[i];
2535            if (p.if.check(o)) {
2536              return p.h(o, s);
2537            }
2538          }
2539          throw create3("Unhandled pattern");
2540        }
2541      );
2542    }
2543  };
2544  var match = (state) => new PatternMatcher(
2545    /** @type {any} */
2546    state
2547  );
2548  var _random = (
2549    /** @type {any} */
2550    match(
2551      /** @type {Schema<prng.PRNG>} */
2552      $any
2553    ).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) => {
2554      const res = {};
2555      for (const k in o.shape) {
2556        let prop = o.shape[k];
2557        if ($$optional.check(prop)) {
2558          if (bool(gen)) {
2559            continue;
2560          }
2561          prop = prop.shape;
2562        }
2563        res[k] = _random(prop, gen);
2564      }
2565      return res;
2566    }).if($$array, (o, gen) => {
2567      const arr = [];
2568      const n = int32(gen, 0, 42);
2569      for (let i = 0; i < n; i++) {
2570        arr.push(random(gen, o.shape));
2571      }
2572      return arr;
2573    }).if($$literal, (o, gen) => {
2574      return oneOf(gen, o.shape);
2575    }).if($$null, (o, gen) => {
2576      return null;
2577    }).if($$lambda, (o, gen) => {
2578      const res = random(gen, o.res);
2579      return () => res;
2580    }).if($$any, (o, gen) => random(gen, oneOf(gen, [
2581      $number,
2582      $string,
2583      $null,
2584      $undefined,
2585      $bigint,
2586      $boolean,
2587      $array($number),
2588      $record($union("a", "b", "c"), $number)
2589    ]))).if($$record, (o, gen) => {
2590      const res = {};
2591      const keysN = int53(gen, 0, 3);
2592      for (let i = 0; i < keysN; i++) {
2593        const key = random(gen, o.shape.keys);
2594        const val = random(gen, o.shape.values);
2595        res[key] = val;
2596      }
2597      return res;
2598    }).done()
2599  );
2600  var random = (gen, schema) => (
2601    /** @type {any} */
2602    _random($(schema), gen)
2603  );
2604
2605