noteloom 0.3.3 → 0.5.0

package/dist/shared/fieldRegistry-PjJWXFoB.js

@@ -0,0 +1,223 @@
+class n {
+  constructor(e) {
+    this.peerId = e, this.wallTime = 0, this.counter = 0;
+  }
+  /** Local event (a user's own edit). Returns the stamped timestamp. */
+  tick() {
+    const e = Date.now();
+    return e > this.wallTime ? (this.wallTime = e, this.counter = 0) : this.counter += 1, { wallTime: this.wallTime, counter: this.counter, peerId: this.peerId };
+  }
+  /**
+   * Merges in a timestamp observed from a remote peer, advancing this
+   * clock so subsequent local ticks are guaranteed to sort after
+   * anything just received.
+   */
+  receive(e) {
+    const t = Date.now(), s = Math.max(t, this.wallTime, e.wallTime);
+    return s === this.wallTime && s === e.wallTime ? this.counter = Math.max(this.counter, e.counter) + 1 : s === this.wallTime ? this.counter += 1 : s === e.wallTime ? this.counter = e.counter + 1 : this.counter = 0, this.wallTime = s, { wallTime: this.wallTime, counter: this.counter, peerId: this.peerId };
+  }
+  /** Total order: wallTime, then counter, then peerId. */
+  static compare(e, t) {
+    return e.wallTime !== t.wallTime ? e.wallTime - t.wallTime : e.counter !== t.counter ? e.counter - t.counter : e.peerId === t.peerId ? 0 : e.peerId < t.peerId ? -1 : 1;
+  }
+}
+function d() {
+  return typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `peer-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+class u {
+  constructor() {
+    this.slots = /* @__PURE__ */ new Map();
+  }
+  /** Builds CRDT state from an existing plain-array order (e.g. loading a v1 document with no CRDT history). */
+  static fromArray(e, { peerId: t = "legacy" } = {}) {
+    const s = new u();
+    let o = null;
+    for (const r of e)
+      s.slots.set(r, {
+        id: r,
+        originId: o,
+        peerId: t,
+        clock: { wallTime: 0, counter: 0, peerId: t },
+        deleted: !1
+      }), o = r;
+    return s;
+  }
+  has(e) {
+    return this.slots.has(e);
+  }
+  /** The raw slot for `id` ({id, originId, peerId, clock, deleted}), or undefined — used to build a wire envelope for a change that was just made. */
+  getSlot(e) {
+    return this.slots.get(e);
+  }
+  isDeleted(e) {
+    const t = this.slots.get(e);
+    return !t || t.deleted;
+  }
+  /**
+   * Inserts `id` immediately after `afterId` (null = at the very start).
+   * Idempotent: re-inserting an id that already has a slot is a no-op,
+   * which guards against duplicate delivery over an unreliable transport.
+   */
+  insert(e, t, s, o) {
+    this.slots.has(e) || this.slots.set(e, { id: e, originId: t, peerId: o, clock: s, deleted: !1 });
+  }
+  /**
+   * `clock` records WHEN the delete happened (used by pruneTombstones to
+   * judge tombstone age) — deliberately a separate value from whatever
+   * clock the slot already had from insertion/move, which recorded a
+   * different thing (when its POSITION was last established). Without
+   * this, an old-but-just-deleted slot would look ancient from the
+   * moment it's deleted (inheriting its original insertion time, however
+   * long ago that was) and become immediately GC-eligible.
+   */
+  delete(e, t) {
+    const s = this.slots.get(e);
+    s && (s.deleted = !0, t && (s.deletedClock = t));
+  }
+  /** Undoes a local delete in place, preserving the slot's original position. */
+  restore(e) {
+    const t = this.slots.get(e);
+    t && (t.deleted = !1);
+  }
+  /**
+   * Repositions an existing slot to a new anchor in place, rather than
+   * tombstoning it and creating a new one — there is only ever one slot
+   * per id in a given list, so a same-list reorder (or moving a block
+   * back to a parent it was in before) must reuse it. Local-only for now:
+   * concurrent moves of the same id by two peers have no defined merge
+   * rule yet (last local move simply wins), since there's no remote path
+   * exercising this until the transport layer exists.
+   *
+   * Splices the slot out of the chain BEFORE re-anchoring it: anything
+   * currently anchored directly after `id` gets reparented to `id`'s old
+   * origin first. Without this, moving a node to an anchor that's
+   * currently one of its own (transitive) successors creates a cycle —
+   * e.g. a->b->c, "move a to after c" naively sets a.originId='c', but
+   * c.originId is (transitively) 'a', so the walk from the list start can
+   * no longer reach any of them. Splicing `id` out first means whatever
+   * anchor is chosen can never depend on `id` still being where it was.
+   */
+  move(e, t, s, o) {
+    if (t === e) return;
+    const r = this.slots.get(e);
+    if (!r) return;
+    const i = r.originId;
+    for (const c of this.slots.values())
+      c.originId === e && (c.originId = i);
+    r.originId = t, r.peerId = o, r.clock = s, r.deleted = !1;
+  }
+  /**
+   * Merges another peer's slot set into this one. Safe to call with
+   * slots in any order, any number of times — idempotent, commutative,
+   * and associative — which is what makes convergence hold regardless
+   * of network delivery order.
+   */
+  merge(e) {
+    for (const t of e) {
+      const s = this.slots.get(t.id);
+      s ? t.deleted && !s.deleted && (s.deleted = !0) : this.slots.set(t.id, { ...t });
+    }
+  }
+  /** Every slot as a plain array, for persistence/transport. */
+  toSlotArray() {
+    return Array.from(this.slots.values());
+  }
+  /** How many tombstoned (deleted but still retained) slots this list is currently carrying — for deciding whether GC is worth running, or just observing growth. */
+  tombstoneCount() {
+    let e = 0;
+    for (const t of this.slots.values())
+      t.deleted && (e += 1);
+    return e;
+  }
+  /**
+   * Permanently removes tombstoned slots whose delete happened before
+   * `beforeClock` — the actual fix for the "deleted content is never
+   * garbage-collected" limitation. Splices each removed slot out of the
+   * chain first (children reparented to its own origin, same technique
+   * as `move()`) so removal never orphans a slot anchored to it. Returns
+   * the number of slots actually removed.
+   *
+   * Safety of this is specifically tied to how this package's transport
+   * layer reconnects: `CollabSession` resyncs a reconnecting peer via a
+   * full document snapshot (see syncResponse in CollabSession.js), never
+   * by replaying a log of historical ops — so a peer that was offline
+   * longer than any reasonable GC threshold never needs an old tombstone
+   * to resolve a stale anchor; it just adopts the current state directly.
+   * The one theoretical residual risk is a single already-open connection
+   * somehow stalling for exactly as long as the GC threshold and then
+   * delivering an old queued message afterward — vanishingly unlikely for
+   * a live, ordered, reliable data channel (which disconnects long before
+   * that under any real network interruption), but not mathematically
+   * impossible, which is why this is opt-in rather than automatic.
+   */
+  pruneTombstones(e) {
+    let t = 0;
+    for (const [s, o] of this.slots) {
+      if (!o.deleted) continue;
+      const r = o.deletedClock ?? o.clock;
+      if (!(n.compare(r, e) >= 0)) {
+        for (const i of this.slots.values())
+          i.originId === s && (i.originId = o.originId);
+        this.slots.delete(s), t += 1;
+      }
+    }
+    return t;
+  }
+  /**
+   * Materializes the currently-visible order as a plain array of ids
+   * (tombstoned ids excluded) — this is what gets projected onto
+   * Block.contentIds after every structural change.
+   */
+  toArray() {
+    const e = /* @__PURE__ */ new Map();
+    for (const o of this.slots.values()) {
+      const r = e.get(o.originId);
+      r ? r.push(o) : e.set(o.originId, [o]);
+    }
+    for (const o of e.values())
+      o.sort((r, i) => n.compare(i.clock, r.clock));
+    const t = [], s = [...e.get(null) ?? []].reverse();
+    for (; s.length > 0; ) {
+      const o = s.pop();
+      o.deleted || t.push(o.id);
+      const r = e.get(o.id);
+      if (r)
+        for (let i = r.length - 1; i >= 0; i -= 1) s.push(r[i]);
+    }
+    return t;
+  }
+}
+class l {
+  constructor() {
+    this.clocks = /* @__PURE__ */ new Map();
+  }
+  static compositeKey(e, t) {
+    return `${e}:${t}`;
+  }
+  get(e, t) {
+    return this.clocks.get(l.compositeKey(e, t)) ?? null;
+  }
+  /** Local write: always wins outright — it just happened, nothing to compare against. */
+  recordLocal(e, t, s) {
+    this.clocks.set(l.compositeKey(e, t), s);
+  }
+  /**
+   * Whether a remote write to this field should be applied. Callers must
+   * check this before mutating so a stale remote write can be discarded
+   * without ever touching local state.
+   */
+  shouldApplyRemote(e, t, s) {
+    const o = this.get(e, t);
+    return o ? n.compare(s, o) > 0 : !0;
+  }
+  recordRemote(e, t, s) {
+    this.clocks.set(l.compositeKey(e, t), s);
+  }
+}
+export {
+  l as F,
+  n as H,
+  u as L,
+  d as g
+};
+//# sourceMappingURL=fieldRegistry-PjJWXFoB.js.map

package/dist/shared/fieldRegistry-PjJWXFoB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldRegistry-PjJWXFoB.js","sources":["../../src/crdt/clock.js","../../src/crdt/listCrdt.js","../../src/crdt/fieldRegistry.js"],"sourcesContent":["/**\n * Hybrid Logical Clock — a (wallTime, counter, peerId) timestamp used to\n * totally order concurrent edits across peers without a central server.\n * wallTime keeps timestamps meaningful as real time (e.g. \"edited 2 min\n * ago\"); counter breaks ties when multiple local events share a wallTime;\n * peerId breaks ties deterministically when both wallTime and counter\n * match across peers.\n */\nexport class HLC {\n  constructor(peerId) {\n    this.peerId = peerId;\n    this.wallTime = 0;\n    this.counter = 0;\n  }\n\n  /** Local event (a user's own edit). Returns the stamped timestamp. */\n  tick() {\n    const now = Date.now();\n    if (now > this.wallTime) {\n      this.wallTime = now;\n      this.counter = 0;\n    } else {\n      this.counter += 1;\n    }\n    return { wallTime: this.wallTime, counter: this.counter, peerId: this.peerId };\n  }\n\n  /**\n   * Merges in a timestamp observed from a remote peer, advancing this\n   * clock so subsequent local ticks are guaranteed to sort after\n   * anything just received.\n   */\n  receive(remote) {\n    const now = Date.now();\n    const maxWall = Math.max(now, this.wallTime, remote.wallTime);\n    if (maxWall === this.wallTime && maxWall === remote.wallTime) {\n      this.counter = Math.max(this.counter, remote.counter) + 1;\n    } else if (maxWall === this.wallTime) {\n      this.counter += 1;\n    } else if (maxWall === remote.wallTime) {\n      this.counter = remote.counter + 1;\n    } else {\n      this.counter = 0;\n    }\n    this.wallTime = maxWall;\n    return { wallTime: this.wallTime, counter: this.counter, peerId: this.peerId };\n  }\n\n  /** Total order: wallTime, then counter, then peerId. */\n  static compare(a, b) {\n    if (a.wallTime !== b.wallTime) return a.wallTime - b.wallTime;\n    if (a.counter !== b.counter) return a.counter - b.counter;\n    if (a.peerId === b.peerId) return 0;\n    return a.peerId < b.peerId ? -1 : 1;\n  }\n}\n\nexport function genPeerId() {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID();\n  }\n  return `peer-${Date.now()}-${Math.random().toString(36).slice(2)}`;\n}\n","import { HLC } from './clock.js';\n\n/**\n * Replicated ordered list, keyed by externally-owned stable ids (Noteloom's\n * existing block/run ids — this module never generates ids, only orders\n * and tombstones the ones it's given). Each item's position is defined\n * relative to a neighbor id (\"insert after X\"), not an array index, so\n * concurrent inserts/deletes at different local positions merge\n * deterministically regardless of what order the operations are applied\n * in on a given peer.\n *\n * Concurrent inserts anchored to the exact same origin are ordered\n * newest-first (by clock, then peerId) so a live edit lands as close to\n * its anchor as possible. Sequential inserts from one peer/batch (each\n * anchored to the id it just inserted, not re-anchored to the original\n * origin — the natural way typing and multi-block paste already work)\n * are never split apart by a concurrent peer's insert at the same\n * origin. A concurrent *non-chained* multi-item insert at the same\n * anchor by two peers can still interleave with this simpler\n * (RGA-style) scheme; convergence still holds, only interleave-avoidance\n * is partial rather than the full Fugue tree guarantee.\n */\nexport class ListCrdtState {\n  constructor() {\n    this.slots = new Map();\n  }\n\n  /** Builds CRDT state from an existing plain-array order (e.g. loading a v1 document with no CRDT history). */\n  static fromArray(ids, { peerId = 'legacy' } = {}) {\n    const state = new ListCrdtState();\n    let prev = null;\n    for (const id of ids) {\n      state.slots.set(id, {\n        id,\n        originId: prev,\n        peerId,\n        clock: { wallTime: 0, counter: 0, peerId },\n        deleted: false,\n      });\n      prev = id;\n    }\n    return state;\n  }\n\n  has(id) {\n    return this.slots.has(id);\n  }\n\n  /** The raw slot for `id` ({id, originId, peerId, clock, deleted}), or undefined — used to build a wire envelope for a change that was just made. */\n  getSlot(id) {\n    return this.slots.get(id);\n  }\n\n  isDeleted(id) {\n    const slot = this.slots.get(id);\n    return !slot || slot.deleted;\n  }\n\n  /**\n   * Inserts `id` immediately after `afterId` (null = at the very start).\n   * Idempotent: re-inserting an id that already has a slot is a no-op,\n   * which guards against duplicate delivery over an unreliable transport.\n   */\n  insert(id, afterId, clock, peerId) {\n    if (this.slots.has(id)) return;\n    this.slots.set(id, { id, originId: afterId, peerId, clock, deleted: false });\n  }\n\n  /**\n   * `clock` records WHEN the delete happened (used by pruneTombstones to\n   * judge tombstone age) — deliberately a separate value from whatever\n   * clock the slot already had from insertion/move, which recorded a\n   * different thing (when its POSITION was last established). Without\n   * this, an old-but-just-deleted slot would look ancient from the\n   * moment it's deleted (inheriting its original insertion time, however\n   * long ago that was) and become immediately GC-eligible.\n   */\n  delete(id, clock) {\n    const slot = this.slots.get(id);\n    if (!slot) return;\n    slot.deleted = true;\n    if (clock) slot.deletedClock = clock;\n  }\n\n  /** Undoes a local delete in place, preserving the slot's original position. */\n  restore(id) {\n    const slot = this.slots.get(id);\n    if (!slot) return;\n    slot.deleted = false;\n  }\n\n  /**\n   * Repositions an existing slot to a new anchor in place, rather than\n   * tombstoning it and creating a new one — there is only ever one slot\n   * per id in a given list, so a same-list reorder (or moving a block\n   * back to a parent it was in before) must reuse it. Local-only for now:\n   * concurrent moves of the same id by two peers have no defined merge\n   * rule yet (last local move simply wins), since there's no remote path\n   * exercising this until the transport layer exists.\n   *\n   * Splices the slot out of the chain BEFORE re-anchoring it: anything\n   * currently anchored directly after `id` gets reparented to `id`'s old\n   * origin first. Without this, moving a node to an anchor that's\n   * currently one of its own (transitive) successors creates a cycle —\n   * e.g. a->b->c, \"move a to after c\" naively sets a.originId='c', but\n   * c.originId is (transitively) 'a', so the walk from the list start can\n   * no longer reach any of them. Splicing `id` out first means whatever\n   * anchor is chosen can never depend on `id` still being where it was.\n   */\n  move(id, afterId, clock, peerId) {\n    if (afterId === id) return;\n    const slot = this.slots.get(id);\n    if (!slot) return;\n    const oldOriginId = slot.originId;\n    for (const other of this.slots.values()) {\n      if (other.originId === id) other.originId = oldOriginId;\n    }\n    slot.originId = afterId;\n    slot.peerId = peerId;\n    slot.clock = clock;\n    slot.deleted = false;\n  }\n\n  /**\n   * Merges another peer's slot set into this one. Safe to call with\n   * slots in any order, any number of times — idempotent, commutative,\n   * and associative — which is what makes convergence hold regardless\n   * of network delivery order.\n   */\n  merge(remoteSlots) {\n    for (const remote of remoteSlots) {\n      const local = this.slots.get(remote.id);\n      if (!local) {\n        this.slots.set(remote.id, { ...remote });\n      } else if (remote.deleted && !local.deleted) {\n        local.deleted = true;\n      }\n      // originId/peerId/clock never change after a slot is created —\n      // a slot's structural identity is fixed at insert time; `deleted`\n      // is the only field that can change, and only monotonically\n      // (existence-wins: once deleted, always deleted).\n    }\n  }\n\n  /** Every slot as a plain array, for persistence/transport. */\n  toSlotArray() {\n    return Array.from(this.slots.values());\n  }\n\n  /** How many tombstoned (deleted but still retained) slots this list is currently carrying — for deciding whether GC is worth running, or just observing growth. */\n  tombstoneCount() {\n    let count = 0;\n    for (const slot of this.slots.values()) {\n      if (slot.deleted) count += 1;\n    }\n    return count;\n  }\n\n  /**\n   * Permanently removes tombstoned slots whose delete happened before\n   * `beforeClock` — the actual fix for the \"deleted content is never\n   * garbage-collected\" limitation. Splices each removed slot out of the\n   * chain first (children reparented to its own origin, same technique\n   * as `move()`) so removal never orphans a slot anchored to it. Returns\n   * the number of slots actually removed.\n   *\n   * Safety of this is specifically tied to how this package's transport\n   * layer reconnects: `CollabSession` resyncs a reconnecting peer via a\n   * full document snapshot (see syncResponse in CollabSession.js), never\n   * by replaying a log of historical ops — so a peer that was offline\n   * longer than any reasonable GC threshold never needs an old tombstone\n   * to resolve a stale anchor; it just adopts the current state directly.\n   * The one theoretical residual risk is a single already-open connection\n   * somehow stalling for exactly as long as the GC threshold and then\n   * delivering an old queued message afterward — vanishingly unlikely for\n   * a live, ordered, reliable data channel (which disconnects long before\n   * that under any real network interruption), but not mathematically\n   * impossible, which is why this is opt-in rather than automatic.\n   */\n  pruneTombstones(beforeClock) {\n    let removed = 0;\n    for (const [id, slot] of this.slots) {\n      if (!slot.deleted) continue;\n      // deletedClock (when it was actually deleted) is what age means\n      // here -- falling back to the slot's own clock (when its position\n      // was established) only for a slot deleted before this field\n      // existed, which otherwise has no recorded deletion time at all.\n      const age = slot.deletedClock ?? slot.clock;\n      if (HLC.compare(age, beforeClock) >= 0) continue; // not old enough yet\n      for (const other of this.slots.values()) {\n        if (other.originId === id) other.originId = slot.originId;\n      }\n      this.slots.delete(id);\n      removed += 1;\n    }\n    return removed;\n  }\n\n  /**\n   * Materializes the currently-visible order as a plain array of ids\n   * (tombstoned ids excluded) — this is what gets projected onto\n   * Block.contentIds after every structural change.\n   */\n  toArray() {\n    const childrenByOrigin = new Map();\n    for (const slot of this.slots.values()) {\n      const bucket = childrenByOrigin.get(slot.originId);\n      if (bucket) bucket.push(slot);\n      else childrenByOrigin.set(slot.originId, [slot]);\n    }\n    for (const bucket of childrenByOrigin.values()) {\n      bucket.sort((a, b) => HLC.compare(b.clock, a.clock));\n    }\n\n    const result = [];\n    // Explicit-stack depth-first walk — a naive recursive walk's depth\n    // equals the list length on a long simple chain (the common case for\n    // typed/sequential content), which risks a stack overflow on large\n    // documents.\n    const stack = [...(childrenByOrigin.get(null) ?? [])].reverse();\n    while (stack.length > 0) {\n      const slot = stack.pop();\n      if (!slot.deleted) result.push(slot.id);\n      const children = childrenByOrigin.get(slot.id);\n      if (children) {\n        for (let i = children.length - 1; i >= 0; i -= 1) stack.push(children[i]);\n      }\n    }\n    return result;\n  }\n}\n","import { HLC } from './clock.js';\n\n/**\n * Tracks the logical-clock high-water mark for individual mutable fields\n * (a block's type, one prop key, a run's value, ...) so that when a\n * remote peer's write arrives it's only applied if it's actually newer\n * than whatever's already there — last-write-wins, scoped per field\n * rather than per whole block/run, so unrelated concurrent edits (peer A\n * changes the type, peer B changes a prop) both survive.\n */\nexport class FieldClockRegistry {\n  constructor() {\n    this.clocks = new Map();\n  }\n\n  static compositeKey(id, field) {\n    return `${id}:${field}`;\n  }\n\n  get(id, field) {\n    return this.clocks.get(FieldClockRegistry.compositeKey(id, field)) ?? null;\n  }\n\n  /** Local write: always wins outright — it just happened, nothing to compare against. */\n  recordLocal(id, field, clock) {\n    this.clocks.set(FieldClockRegistry.compositeKey(id, field), clock);\n  }\n\n  /**\n   * Whether a remote write to this field should be applied. Callers must\n   * check this before mutating so a stale remote write can be discarded\n   * without ever touching local state.\n   */\n  shouldApplyRemote(id, field, remoteClock) {\n    const current = this.get(id, field);\n    if (!current) return true;\n    return HLC.compare(remoteClock, current) > 0;\n  }\n\n  recordRemote(id, field, remoteClock) {\n    this.clocks.set(FieldClockRegistry.compositeKey(id, field), remoteClock);\n  }\n}\n"],"names":["HLC","peerId","now","remote","maxWall","a","b","genPeerId","ListCrdtState","ids","state","prev","id","slot","afterId","clock","oldOriginId","other","remoteSlots","local","count","beforeClock","removed","age","childrenByOrigin","bucket","result","stack","children","FieldClockRegistry","field","remoteClock","current"],"mappings":"AAQO,MAAMA,EAAI;AAAA,EACf,YAAYC,GAAQ;AAClB,SAAK,SAASA,GACd,KAAK,WAAW,GAChB,KAAK,UAAU;AAAA,EACjB;AAAA;AAAA,EAGA,OAAO;AACL,UAAMC,IAAM,KAAK,IAAG;AACpB,WAAIA,IAAM,KAAK,YACb,KAAK,WAAWA,GAChB,KAAK,UAAU,KAEf,KAAK,WAAW,GAEX,EAAE,UAAU,KAAK,UAAU,SAAS,KAAK,SAAS,QAAQ,KAAK,OAAM;AAAA,EAC9E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQC,GAAQ;AACd,UAAMD,IAAM,KAAK,IAAG,GACdE,IAAU,KAAK,IAAIF,GAAK,KAAK,UAAUC,EAAO,QAAQ;AAC5D,WAAIC,MAAY,KAAK,YAAYA,MAAYD,EAAO,WAClD,KAAK,UAAU,KAAK,IAAI,KAAK,SAASA,EAAO,OAAO,IAAI,IAC/CC,MAAY,KAAK,WAC1B,KAAK,WAAW,IACPA,MAAYD,EAAO,WAC5B,KAAK,UAAUA,EAAO,UAAU,IAEhC,KAAK,UAAU,GAEjB,KAAK,WAAWC,GACT,EAAE,UAAU,KAAK,UAAU,SAAS,KAAK,SAAS,QAAQ,KAAK,OAAM;AAAA,EAC9E;AAAA;AAAA,EAGA,OAAO,QAAQC,GAAGC,GAAG;AACnB,WAAID,EAAE,aAAaC,EAAE,WAAiBD,EAAE,WAAWC,EAAE,WACjDD,EAAE,YAAYC,EAAE,UAAgBD,EAAE,UAAUC,EAAE,UAC9CD,EAAE,WAAWC,EAAE,SAAe,IAC3BD,EAAE,SAASC,EAAE,SAAS,KAAK;AAAA,EACpC;AACF;AAEO,SAASC,IAAY;AAC1B,SAAI,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aACzD,OAAO,WAAU,IAEnB,QAAQ,KAAK,IAAG,CAAE,IAAI,KAAK,OAAM,EAAG,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAClE;ACxCO,MAAMC,EAAc;AAAA,EACzB,cAAc;AACZ,SAAK,QAAQ,oBAAI,IAAG;AAAA,EACtB;AAAA;AAAA,EAGA,OAAO,UAAUC,GAAK,EAAE,QAAAR,IAAS,SAAQ,IAAK,CAAA,GAAI;AAChD,UAAMS,IAAQ,IAAIF,EAAa;AAC/B,QAAIG,IAAO;AACX,eAAWC,KAAMH;AACf,MAAAC,EAAM,MAAM,IAAIE,GAAI;AAAA,QAClB,IAAAA;AAAA,QACA,UAAUD;AAAA,QACV,QAAAV;AAAA,QACA,OAAO,EAAE,UAAU,GAAG,SAAS,GAAG,QAAAA,EAAM;AAAA,QACxC,SAAS;AAAA,MACjB,CAAO,GACDU,IAAOC;AAET,WAAOF;AAAA,EACT;AAAA,EAEA,IAAIE,GAAI;AACN,WAAO,KAAK,MAAM,IAAIA,CAAE;AAAA,EAC1B;AAAA;AAAA,EAGA,QAAQA,GAAI;AACV,WAAO,KAAK,MAAM,IAAIA,CAAE;AAAA,EAC1B;AAAA,EAEA,UAAUA,GAAI;AACZ,UAAMC,IAAO,KAAK,MAAM,IAAID,CAAE;AAC9B,WAAO,CAACC,KAAQA,EAAK;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAOD,GAAIE,GAASC,GAAOd,GAAQ;AACjC,IAAI,KAAK,MAAM,IAAIW,CAAE,KACrB,KAAK,MAAM,IAAIA,GAAI,EAAE,IAAAA,GAAI,UAAUE,GAAS,QAAAb,GAAQ,OAAAc,GAAO,SAAS,GAAK,CAAE;AAAA,EAC7E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAOH,GAAIG,GAAO;AAChB,UAAMF,IAAO,KAAK,MAAM,IAAID,CAAE;AAC9B,IAAKC,MACLA,EAAK,UAAU,IACXE,MAAOF,EAAK,eAAeE;AAAA,EACjC;AAAA;AAAA,EAGA,QAAQH,GAAI;AACV,UAAMC,IAAO,KAAK,MAAM,IAAID,CAAE;AAC9B,IAAKC,MACLA,EAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,KAAKD,GAAIE,GAASC,GAAOd,GAAQ;AAC/B,QAAIa,MAAYF,EAAI;AACpB,UAAMC,IAAO,KAAK,MAAM,IAAID,CAAE;AAC9B,QAAI,CAACC,EAAM;AACX,UAAMG,IAAcH,EAAK;AACzB,eAAWI,KAAS,KAAK,MAAM,OAAM;AACnC,MAAIA,EAAM,aAAaL,MAAIK,EAAM,WAAWD;AAE9C,IAAAH,EAAK,WAAWC,GAChBD,EAAK,SAASZ,GACdY,EAAK,QAAQE,GACbF,EAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAMK,GAAa;AACjB,eAAWf,KAAUe,GAAa;AAChC,YAAMC,IAAQ,KAAK,MAAM,IAAIhB,EAAO,EAAE;AACtC,MAAKgB,IAEMhB,EAAO,WAAW,CAACgB,EAAM,YAClCA,EAAM,UAAU,MAFhB,KAAK,MAAM,IAAIhB,EAAO,IAAI,EAAE,GAAGA,GAAQ;AAAA,IAQ3C;AAAA,EACF;AAAA;AAAA,EAGA,cAAc;AACZ,WAAO,MAAM,KAAK,KAAK,MAAM,OAAM,CAAE;AAAA,EACvC;AAAA;AAAA,EAGA,iBAAiB;AACf,QAAIiB,IAAQ;AACZ,eAAWP,KAAQ,KAAK,MAAM,OAAM;AAClC,MAAIA,EAAK,YAASO,KAAS;AAE7B,WAAOA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,gBAAgBC,GAAa;AAC3B,QAAIC,IAAU;AACd,eAAW,CAACV,GAAIC,CAAI,KAAK,KAAK,OAAO;AACnC,UAAI,CAACA,EAAK,QAAS;AAKnB,YAAMU,IAAMV,EAAK,gBAAgBA,EAAK;AACtC,UAAI,EAAAb,EAAI,QAAQuB,GAAKF,CAAW,KAAK,IACrC;AAAA,mBAAWJ,KAAS,KAAK,MAAM,OAAM;AACnC,UAAIA,EAAM,aAAaL,MAAIK,EAAM,WAAWJ,EAAK;AAEnD,aAAK,MAAM,OAAOD,CAAE,GACpBU,KAAW;AAAA;AAAA,IACb;AACA,WAAOA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,UAAU;AACR,UAAME,IAAmB,oBAAI,IAAG;AAChC,eAAWX,KAAQ,KAAK,MAAM,OAAM,GAAI;AACtC,YAAMY,IAASD,EAAiB,IAAIX,EAAK,QAAQ;AACjD,MAAIY,IAAQA,EAAO,KAAKZ,CAAI,IACvBW,EAAiB,IAAIX,EAAK,UAAU,CAACA,CAAI,CAAC;AAAA,IACjD;AACA,eAAWY,KAAUD,EAAiB;AACpC,MAAAC,EAAO,KAAK,CAACpB,GAAGC,MAAMN,EAAI,QAAQM,EAAE,OAAOD,EAAE,KAAK,CAAC;AAGrD,UAAMqB,IAAS,CAAA,GAKTC,IAAQ,CAAC,GAAIH,EAAiB,IAAI,IAAI,KAAK,CAAA,CAAG,EAAE,QAAO;AAC7D,WAAOG,EAAM,SAAS,KAAG;AACvB,YAAMd,IAAOc,EAAM,IAAG;AACtB,MAAKd,EAAK,WAASa,EAAO,KAAKb,EAAK,EAAE;AACtC,YAAMe,IAAWJ,EAAiB,IAAIX,EAAK,EAAE;AAC7C,UAAIe;AACF,iBAAS,IAAIA,EAAS,SAAS,GAAG,KAAK,GAAG,KAAK,EAAG,CAAAD,EAAM,KAAKC,EAAS,CAAC,CAAC;AAAA,IAE5E;AACA,WAAOF;AAAA,EACT;AACF;AC5NO,MAAMG,EAAmB;AAAA,EAC9B,cAAc;AACZ,SAAK,SAAS,oBAAI,IAAG;AAAA,EACvB;AAAA,EAEA,OAAO,aAAajB,GAAIkB,GAAO;AAC7B,WAAO,GAAGlB,CAAE,IAAIkB,CAAK;AAAA,EACvB;AAAA,EAEA,IAAIlB,GAAIkB,GAAO;AACb,WAAO,KAAK,OAAO,IAAID,EAAmB,aAAajB,GAAIkB,CAAK,CAAC,KAAK;AAAA,EACxE;AAAA;AAAA,EAGA,YAAYlB,GAAIkB,GAAOf,GAAO;AAC5B,SAAK,OAAO,IAAIc,EAAmB,aAAajB,GAAIkB,CAAK,GAAGf,CAAK;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,kBAAkBH,GAAIkB,GAAOC,GAAa;AACxC,UAAMC,IAAU,KAAK,IAAIpB,GAAIkB,CAAK;AAClC,WAAKE,IACEhC,EAAI,QAAQ+B,GAAaC,CAAO,IAAI,IADtB;AAAA,EAEvB;AAAA,EAEA,aAAapB,GAAIkB,GAAOC,GAAa;AACnC,SAAK,OAAO,IAAIF,EAAmB,aAAajB,GAAIkB,CAAK,GAAGC,CAAW;AAAA,EACzE;AACF;"}