@tvuikit/navigation 0.1.0

package/dist/index.js

@@ -0,0 +1,916 @@
+function x(u) {
+  if (u && u.aborted)
+    try {
+      throw new DOMException("Aborted", "AbortError");
+    } catch {
+      const t = new Error("Aborted");
+      throw t.name = "AbortError", t;
+    }
+}
+function m(u) {
+  return u.x + u.w * 0.5;
+}
+function E(u) {
+  return u.y + u.h * 0.5;
+}
+function S(u, t) {
+  const i = u + 1048576, o = t + 1048576;
+  return (i + o) * (i + o + 1) / 2 + o;
+}
+function B(u, t, i) {
+  const o = Math.floor(u / i), c = Math.floor(t / i);
+  return o <= c ? [o, c] : [c, o];
+}
+class O {
+  cellSize;
+  // Use numeric keys instead of string keys to avoid GC pressure
+  byCell = /* @__PURE__ */ new Map();
+  nodeCells = /* @__PURE__ */ new Map();
+  constructor(t) {
+    if (!Number.isFinite(t) || t <= 0)
+      throw new Error(`cellSize must be > 0 (got ${t})`);
+    this.cellSize = t;
+  }
+  clear() {
+    this.byCell.clear(), this.nodeCells.clear();
+  }
+  upsert(t, i) {
+    this.remove(t);
+    const o = this.cellHashesForRect(i);
+    this.nodeCells.set(t, o);
+    for (let c = 0; c < o.length; c++) {
+      const d = o[c];
+      let a = this.byCell.get(d);
+      a || (a = [], this.byCell.set(d, a)), a.push(t);
+    }
+  }
+  remove(t) {
+    const i = this.nodeCells.get(t);
+    if (i) {
+      this.nodeCells.delete(t);
+      for (let o = 0; o < i.length; o++) {
+        const c = i[o], d = this.byCell.get(c);
+        if (!d) continue;
+        const a = d.indexOf(t);
+        if (a >= 0) {
+          const l = d.pop();
+          a < d.length && l !== void 0 && (d[a] = l);
+        }
+        d.length === 0 && this.byCell.delete(c);
+      }
+    }
+  }
+  /**
+   * Returns a deduped candidate set from an expanding ring search around (cx, cy).
+   * This is designed to keep worst-case bounded by `maxRings`.
+   */
+  queryRings(t, i, o, c) {
+    const d = Math.floor(t / this.cellSize), a = Math.floor(i / this.cellSize);
+    for (let l = 0; l <= o; l++)
+      for (let s = a - l; s <= a + l; s++)
+        for (let n = d - l; n <= d + l; n++) {
+          if (l > 0 && !(n === d - l || n === d + l || s === a - l || s === a + l))
+            continue;
+          const e = this.byCell.get(S(n, s));
+          if (e)
+            for (let r = 0; r < e.length; r++) c.add(e[r]);
+        }
+    return c;
+  }
+  cellHashesForRect(t) {
+    const [i, o] = B(t.x, t.x + t.w, this.cellSize), [c, d] = B(t.y, t.y + t.h, this.cellSize), a = [];
+    for (let l = c; l <= d; l++)
+      for (let s = i; s <= o; s++) a.push(S(s, l));
+    return a;
+  }
+}
+class k extends EventTarget {
+  registry;
+  index;
+  maxRings;
+  fallbackToScan;
+  focusedId = null;
+  scratchCandidates = /* @__PURE__ */ new Set();
+  lastFocusedByGroup = /* @__PURE__ */ new Map();
+  constructor(t) {
+    super(), this.registry = t.registry, this.index = new O(t.cellSize ?? 256), this.maxRings = t.maxRings ?? 4, this.fallbackToScan = t.fallbackToScan ?? !0;
+  }
+  get focused() {
+    return this.focusedId;
+  }
+  /**
+   * Syncs registry caches and updates the spatial index.
+   * For maximum perf, call this once per "frame/tick" from your app and keep
+   * engine operations `sync:false`.
+   */
+  sync(t) {
+    const i = t ?? this.registry.pendingUpdate?.();
+    this.registry.sync?.(i), this.dispatchEvent(new CustomEvent("sync", { detail: { hint: i } }));
+    const o = i?.added ?? [], c = i?.changed ?? [], d = i?.removed ?? [];
+    if (i && (o.length || c.length || d.length)) {
+      for (let l = 0; l < d.length; l++) this.index.remove(d[l]);
+      for (let l = 0; l < o.length; l++) this.upsertIndex(o[l]);
+      for (let l = 0; l < c.length; l++) this.upsertIndex(c[l]);
+      return;
+    }
+    this.index.clear();
+    const a = this.registry.ids();
+    for (let l = 0; l < a.length; l++) this.upsertIndex(a[l]);
+  }
+  focus(t, i) {
+    const o = i?.signal;
+    x(o), i?.sync && this.sync();
+    const c = i?.reason ?? "programmatic", d = this.focusedId;
+    if (d === t) return;
+    if (this.focusedId = t, this.recordGroupHistory(t), d) {
+      const l = this.registry.bounds(d);
+      this.registry.onBlur?.(d, c), this.dispatchEvent(
+        new CustomEvent("blur", {
+          detail: { nodeId: d, reason: c, bounds: l }
+        })
+      );
+    }
+    const a = this.registry.bounds(t);
+    this.registry.onFocus?.(t, c), this.dispatchEvent(
+      new CustomEvent("focus", {
+        detail: { nodeId: t, reason: c, bounds: a }
+      })
+    );
+  }
+  blur(t) {
+    x(t?.signal);
+    const i = this.focusedId;
+    if (!i) return;
+    this.focusedId = null;
+    const o = this.registry.bounds(i);
+    this.registry.onBlur?.(i, t?.reason ?? "programmatic"), this.dispatchEvent(
+      new CustomEvent("blur", {
+        detail: {
+          nodeId: i,
+          reason: t?.reason ?? "programmatic",
+          bounds: o
+        }
+      })
+    );
+  }
+  /**
+   * Programmatically focuses a group.
+   * - If the group has focus history, restores to the last focused node in the group (when valid).
+   * - Otherwise focuses the first eligible node found in the registry with that group id.
+   */
+  focusGroup(t, i) {
+    const o = i?.signal;
+    x(o), i?.sync && this.sync();
+    const c = i?.id;
+    if (c && this.isEligibleInGroup(c, t)) {
+      this.focus(c, i);
+      return;
+    }
+    const d = i?.fallback ?? "history-first";
+    if (d === "none") return;
+    if (d === "history-first" || d === "history") {
+      const l = this.lastFocusedByGroup.get(t);
+      if (l && this.isEligibleInGroup(l, t)) {
+        this.focus(l, i);
+        return;
+      }
+      if (d === "history") return;
+    }
+    const a = this.registry.ids();
+    for (let l = 0; l < a.length; l++) {
+      const s = a[l];
+      if (this.isEligibleInGroup(s, t)) {
+        this.focus(s, i);
+        return;
+      }
+    }
+  }
+  /**
+   * Clears stored focus history.
+   * If `groupId` is omitted, clears all groups.
+   */
+  clearGroupHistory(t) {
+    if (t === void 0) {
+      this.lastFocusedByGroup.clear();
+      return;
+    }
+    this.lastFocusedByGroup.delete(t);
+  }
+  /**
+   * Alias for `clearGroupHistory()` (programmatic focus history reset).
+   */
+  resetGroupHistory(t) {
+    this.clearGroupHistory(t);
+  }
+  move(t, i) {
+    const o = i?.signal;
+    x(o), i?.sync && this.sync();
+    const c = this.focusedId;
+    if (!c) {
+      this.dispatchEvent(
+        new CustomEvent("reject", {
+          detail: { from: null, direction: t, reason: "no-focused-node" }
+        })
+      );
+      return;
+    }
+    const d = this.registry.bounds(c);
+    if (!d) {
+      this.dispatchEvent(
+        new CustomEvent("reject", {
+          detail: { from: c, direction: t, reason: "no-bounds" }
+        })
+      );
+      return;
+    }
+    const { next: a, reason: l } = this.pickNext(c, d, t);
+    if (!a) {
+      this.dispatchEvent(
+        new CustomEvent("reject", {
+          detail: { from: c, direction: t, reason: l }
+        })
+      );
+      return;
+    }
+    const s = this.redirectOnGroupEnter(c, a);
+    this.dispatchEvent(
+      new CustomEvent("move", { detail: { from: c, to: s ?? a, direction: t } })
+    ), this.focus(s ?? a, o ? { reason: "move", signal: o } : { reason: "move" });
+  }
+  addEventListener(t, i, o) {
+    super.addEventListener(t, i, o);
+  }
+  removeEventListener(t, i, o) {
+    super.removeEventListener(t, i, o);
+  }
+  upsertIndex(t) {
+    const i = this.registry.bounds(t);
+    i && this.index.upsert(t, i);
+  }
+  groupOf(t) {
+    return this.registry.group ? this.registry.group(t) : null;
+  }
+  recordGroupHistory(t) {
+    const i = this.groupOf(t);
+    i && this.lastFocusedByGroup.set(i, t);
+  }
+  isEligible(t) {
+    return this.registry.enabled && !this.registry.enabled(t) || this.registry.visible && !this.registry.visible(t) ? !1 : this.registry.bounds(t) !== null;
+  }
+  isEligibleInGroup(t, i) {
+    return this.groupOf(t) !== i ? !1 : this.isEligible(t);
+  }
+  redirectOnGroupEnter(t, i) {
+    const o = this.groupOf(t), c = this.groupOf(i);
+    if (!c || c === o || !(this.registry.groupRestoreOnEnter?.(c) ?? !1)) return null;
+    const a = this.lastFocusedByGroup.get(c);
+    return !a || !this.isEligibleInGroup(a, c) ? null : a;
+  }
+  pickNext(t, i, o) {
+    this.scratchCandidates.clear();
+    const c = this.index.queryRings(
+      m(i),
+      E(i),
+      this.maxRings,
+      this.scratchCandidates
+    );
+    let d = null, a = 1 / 0;
+    const l = c.size > 0;
+    for (const s of c) {
+      if (s === t || this.registry.enabled && !this.registry.enabled(s) || this.registry.visible && !this.registry.visible(s)) continue;
+      const n = this.registry.bounds(s);
+      if (!n || !C(i, n, o)) continue;
+      const e = R(i, n, o);
+      e < a && (a = e, d = { id: s, rect: n });
+    }
+    if (d)
+      return this.isBoundaryBlocked(t, d.id, o) ? { next: null, reason: "boundary-blocked" } : { next: d.id, reason: "all-filtered" };
+    if (!l && this.fallbackToScan) {
+      const s = this.registry.ids();
+      for (let n = 0; n < s.length; n++) {
+        const e = s[n];
+        if (e === t || this.registry.enabled && !this.registry.enabled(e) || this.registry.visible && !this.registry.visible(e)) continue;
+        const r = this.registry.bounds(e);
+        if (!r || !C(i, r, o)) continue;
+        const f = R(i, r, o);
+        f < a && (a = f, d = { id: e, rect: r });
+      }
+      if (d)
+        return this.isBoundaryBlocked(t, d.id, o) ? { next: null, reason: "boundary-blocked" } : { next: d.id, reason: "all-filtered" };
+    }
+    return { next: null, reason: l ? "all-filtered" : "no-candidates" };
+  }
+  isBoundaryBlocked(t, i, o) {
+    const c = this.groupOf(t);
+    return !c || this.groupOf(i) === c ? !1 : this.registry.groupBoundary?.(c, o) ?? !1;
+  }
+}
+function C(u, t, i) {
+  const o = m(u), c = E(u), d = m(t), a = E(t);
+  switch (i) {
+    case "right":
+      return d > o;
+    case "left":
+      return d < o;
+    case "down":
+      return a > c;
+    case "up":
+      return a < c;
+  }
+}
+function R(u, t, i) {
+  const o = m(u), c = E(u), d = m(t), a = E(t), l = d - o, s = a - c;
+  let n = 0, e = 0;
+  switch (i) {
+    case "right":
+      n = l, e = Math.abs(s);
+      break;
+    case "left":
+      n = -l, e = Math.abs(s);
+      break;
+    case "down":
+      n = s, e = Math.abs(l);
+      break;
+    case "up":
+      n = -s, e = Math.abs(l);
+      break;
+  }
+  return n * n * 1 + e * e * 2.25;
+}
+function M() {
+  const u = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), o = [], c = /* @__PURE__ */ new Map();
+  let d = { added: [], removed: [], changed: [] };
+  const a = (e) => d.added.push(e), l = (e) => d.removed.push(e), s = (e) => d.changed.push(e);
+  return {
+    ids() {
+      return o;
+    },
+    bounds(e) {
+      return u.get(e)?.rect ?? null;
+    },
+    group(e) {
+      return u.get(e)?.groupId ?? null;
+    },
+    enabled(e) {
+      return u.get(e)?.enabled ?? !0;
+    },
+    visible(e) {
+      return u.get(e)?.visible ?? !0;
+    },
+    onFocus(e, r) {
+      u.get(e)?.onFocus?.(r);
+    },
+    onBlur(e, r) {
+      u.get(e)?.onBlur?.(r);
+    },
+    groupBoundary(e, r) {
+      const f = t.get(e);
+      return f ? f[r] ?? !1 : !1;
+    },
+    setGroupBoundary(e, r) {
+      t.set(e, r);
+    },
+    clearGroupBoundary(e) {
+      t.delete(e);
+    },
+    groupRestoreOnEnter(e) {
+      return i.get(e);
+    },
+    setGroupRestoreOnEnter(e, r) {
+      i.set(e, r);
+    },
+    clearGroupRestoreOnEnter(e) {
+      i.delete(e);
+    },
+    pendingUpdate() {
+      if (!(d.added.length > 0 || d.removed.length > 0 || d.changed.length > 0)) return;
+      const r = d;
+      return d = { added: [], removed: [], changed: [] }, r;
+    },
+    register(e) {
+      const r = e.id;
+      if (c.has(r)) {
+        this.update(r, e);
+        return;
+      }
+      o.push(r), c.set(r, o.length - 1);
+      const f = { rect: e.rect };
+      e.groupId !== void 0 && (f.groupId = e.groupId), e.enabled !== void 0 && (f.enabled = e.enabled), e.visible !== void 0 && (f.visible = e.visible), e.onFocus && (f.onFocus = e.onFocus), e.onBlur && (f.onBlur = e.onBlur), u.set(r, f), a(r);
+    },
+    unregister(e) {
+      const r = c.get(e);
+      if (r === void 0) return;
+      const f = o.pop();
+      f !== e && (o[r] = f, c.set(f, r)), c.delete(e), u.delete(e), l(e);
+    },
+    update(e, r) {
+      const f = u.get(e);
+      f && (r.rect && (f.rect = r.rect), r.groupId !== void 0 && (f.groupId = r.groupId), r.enabled !== void 0 && (f.enabled = r.enabled), r.visible !== void 0 && (f.visible = r.visible), r.onFocus && (f.onFocus = r.onFocus), r.onBlur && (f.onBlur = r.onBlur), s(e));
+    },
+    clear() {
+      u.clear(), t.clear(), i.clear(), o.length = 0, c.clear(), d = { added: [], removed: [], changed: [] };
+    }
+  };
+}
+function F() {
+  const u = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  let o = [], c = !0;
+  function d(n, e) {
+    return `${n}:${e}`;
+  }
+  function a(n) {
+    const e = n.indexOf(":");
+    if (e <= 0) return null;
+    const r = n.slice(0, e), f = n.slice(e + 1);
+    return f ? { source: r, localId: f } : null;
+  }
+  function l(n) {
+    const e = a(n);
+    if (!e) return null;
+    const r = u.get(e.source);
+    return r ? { registry: r, localId: e.localId } : null;
+  }
+  return {
+    addSource(n, e) {
+      if (n.includes(":"))
+        throw new Error(`Source name cannot contain ":" (got "${n}")`);
+      u.set(n, e), c = !0;
+    },
+    removeSource(n) {
+      const e = u.delete(n);
+      return e && (c = !0), e;
+    },
+    getSource(n) {
+      return u.get(n);
+    },
+    hasSource(n) {
+      return u.has(n);
+    },
+    sourceNames() {
+      return Array.from(u.keys());
+    },
+    toCombinedId: d,
+    fromCombinedId: a,
+    ids() {
+      if (!c) return o;
+      c = !1;
+      const n = [];
+      for (const [e, r] of u) {
+        const f = r.ids();
+        for (let h = 0; h < f.length; h++)
+          n.push(d(e, f[h]));
+      }
+      return o = n, o;
+    },
+    bounds(n) {
+      const e = l(n);
+      return e ? e.registry.bounds(e.localId) : null;
+    },
+    enabled(n) {
+      const e = l(n);
+      return e ? e.registry.enabled ? e.registry.enabled(e.localId) : !0 : !1;
+    },
+    visible(n) {
+      const e = l(n);
+      return e ? e.registry.visible ? e.registry.visible(e.localId) : !0 : !1;
+    },
+    group(n) {
+      const e = l(n);
+      return e && e.registry.group ? e.registry.group(e.localId) : null;
+    },
+    onFocus(n, e) {
+      const r = l(n);
+      r?.registry.onFocus?.(r.localId, e);
+    },
+    onBlur(n, e) {
+      const r = l(n);
+      r?.registry.onBlur?.(r.localId, e);
+    },
+    groupBoundary(n, e) {
+      const r = t.get(n);
+      return r ? r[e] ?? !1 : !1;
+    },
+    setGroupBoundary(n, e) {
+      t.set(n, e);
+    },
+    clearGroupBoundary(n) {
+      t.delete(n);
+    },
+    groupRestoreOnEnter(n) {
+      return i.get(n);
+    },
+    setGroupRestoreOnEnter(n, e) {
+      i.set(n, e);
+    },
+    clearGroupRestoreOnEnter(n) {
+      i.delete(n);
+    },
+    sync(n) {
+      if (!n) {
+        for (const h of u.values())
+          h.sync?.();
+        return;
+      }
+      const e = /* @__PURE__ */ new Map(), r = (h) => {
+        let g = e.get(h);
+        return g || (g = { added: [], removed: [], changed: [] }, e.set(h, g)), g;
+      }, f = (h, g) => {
+        if (h)
+          for (const y of h) {
+            const p = a(y);
+            p && r(p.source)[g].push(p.localId);
+          }
+      };
+      f(n.added, "added"), f(n.removed, "removed"), f(n.changed, "changed");
+      for (const [h, g] of u) {
+        const y = e.get(h);
+        g.sync?.(y);
+      }
+    },
+    pendingUpdate() {
+      const n = { added: [], removed: [], changed: [] };
+      let e = !1;
+      for (const [r, f] of u) {
+        const h = f.pendingUpdate?.();
+        if (h) {
+          if (e = !0, c = !0, h.added)
+            for (const g of h.added) n.added.push(d(r, g));
+          if (h.removed)
+            for (const g of h.removed) n.removed.push(d(r, g));
+          if (h.changed)
+            for (const g of h.changed) n.changed.push(d(r, g));
+        }
+      }
+      return e ? n : void 0;
+    }
+  };
+}
+function $(u) {
+  const t = F(), i = {
+    registry: t
+  };
+  u?.cellSize !== void 0 && (i.cellSize = u.cellSize), u?.maxRings !== void 0 && (i.maxRings = u.maxRings), u?.fallbackToScan !== void 0 && (i.fallbackToScan = u.fallbackToScan);
+  const o = new k(i), c = /* @__PURE__ */ new Set();
+  let d = null;
+  const a = () => {
+    for (const s of c)
+      s();
+  };
+  o.addEventListener("focus", a), o.addEventListener("blur", a);
+  const l = {
+    get engine() {
+      return o;
+    },
+    get registry() {
+      return t;
+    },
+    // === Source Management ===
+    getSource(s) {
+      let n = t.getSource(s);
+      return n || (n = M(), t.addSource(s, n), a()), n;
+    },
+    getExistingSource(s) {
+      return t.getSource(s);
+    },
+    addSource(s, n) {
+      t.addSource(s, n), a();
+    },
+    hasSource(s) {
+      return t.hasSource(s);
+    },
+    removeSource(s) {
+      const n = t.removeSource(s);
+      return n && a(), n;
+    },
+    sourceNames() {
+      return t.sourceNames();
+    },
+    // === Focus Management ===
+    get focused() {
+      return o.focused;
+    },
+    isFocused(s) {
+      return o.focused === s;
+    },
+    focus(s, n) {
+      o.focus(s, n);
+    },
+    blur(s) {
+      o.blur(s);
+    },
+    focusGroup(s, n) {
+      o.focusGroup(s, n);
+    },
+    move(s, n) {
+      o.move(s, n);
+    },
+    sync(s) {
+      o.sync(s);
+    },
+    // === Registration Helpers ===
+    register(s, n) {
+      l.getSource(s).register(n);
+    },
+    unregister(s, n) {
+      const e = t.getSource(s);
+      e && typeof e.unregister == "function" && e.unregister(n);
+    },
+    // === Subscription ===
+    subscribe(s) {
+      return c.add(s), () => {
+        c.delete(s);
+      };
+    },
+    getSnapshot() {
+      const s = o.focused;
+      return s === d ? d : (d = s, s);
+    },
+    // === Event Handling ===
+    addEventListener(s, n, e) {
+      o.addEventListener(s, n, e);
+    },
+    removeEventListener(s, n, e) {
+      o.removeEventListener(s, n, e);
+    },
+    // === Group Configuration ===
+    setGroupBoundary(s, n) {
+      t.setGroupBoundary?.(s, n);
+    },
+    clearGroupBoundary(s) {
+      t.clearGroupBoundary?.(s);
+    },
+    setGroupRestoreOnEnter(s, n) {
+      t.setGroupRestoreOnEnter?.(s, n);
+    },
+    clearGroupRestoreOnEnter(s) {
+      t.clearGroupRestoreOnEnter?.(s);
+    },
+    clearGroupHistory(s) {
+      o.clearGroupHistory(s);
+    }
+  };
+  return l;
+}
+function L(u, t, i) {
+  if (typeof document > "u")
+    return { update: () => {
+    }, destroy: () => {
+    } };
+  const o = document.createElement("div");
+  o.id = "tvkit-debug-overlay", o.style.cssText = `
+    position: fixed;
+    inset: 0;
+    pointer-events: none;
+    z-index: ${i};
+  `, document.body.appendChild(o);
+  const c = /* @__PURE__ */ new Map();
+  function d() {
+    const a = t.ids(), l = new Set(a);
+    for (const [s, n] of c)
+      l.has(s) || (n.remove(), c.delete(s));
+    for (const s of a) {
+      const n = t.bounds(s);
+      if (!n) continue;
+      let e = c.get(s);
+      e || (e = document.createElement("div"), e.style.cssText = `
+          position: fixed;
+          border: 1px solid rgba(0, 212, 170, 0.5);
+          background: rgba(0, 212, 170, 0.1);
+          font-size: 10px;
+          color: rgba(0, 212, 170, 0.8);
+          padding: 2px 4px;
+          font-family: monospace;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+          pointer-events: none;
+        `, o.appendChild(e), c.set(s, e));
+      const r = u.focused === s;
+      e.style.left = `${n.x}px`, e.style.top = `${n.y}px`, e.style.width = `${n.w}px`, e.style.height = `${n.h}px`, e.style.borderColor = r ? "#00d4aa" : "rgba(0, 212, 170, 0.5)", e.style.background = r ? "rgba(0, 212, 170, 0.3)" : "rgba(0, 212, 170, 0.1)", e.textContent = s;
+    }
+  }
+  return {
+    update: d,
+    destroy() {
+      o.remove(), c.clear();
+    }
+  };
+}
+function A(u, t, i = {}) {
+  const {
+    logLevel: o = "moves",
+    logger: c = console.log,
+    showOverlay: d = !1,
+    overlayZIndex: a = 9999
+  } = i, l = "[tvkit]", s = [];
+  if (o !== "none") {
+    const e = (g) => {
+      const y = g.detail;
+      c(
+        `${l} focus:`,
+        y.nodeId,
+        `(${y.reason})`,
+        y.bounds ? `at ${JSON.stringify(y.bounds)}` : ""
+      );
+    }, r = (g) => {
+      const y = g.detail;
+      c(`${l} blur:`, y.nodeId, `(${y.reason})`);
+    }, f = (g) => {
+      const y = g.detail;
+      c(`${l} move:`, y.from, "→", y.to, `(${y.direction})`);
+    }, h = (g) => {
+      const y = g.detail;
+      c(
+        `${l} reject:`,
+        y.from ?? "(none)",
+        y.direction,
+        `reason=${y.reason}`
+      );
+    };
+    if (u.addEventListener("focus", e), u.addEventListener("blur", r), u.addEventListener("move", f), u.addEventListener("reject", h), s.push(() => {
+      u.removeEventListener("focus", e), u.removeEventListener("blur", r), u.removeEventListener("move", f), u.removeEventListener("reject", h);
+    }), o === "verbose") {
+      const g = (y) => {
+        const p = y.detail, v = p.hint?.added?.length ?? 0, b = p.hint?.removed?.length ?? 0;
+        (v > 0 || b > 0) && c(`${l} sync: +${v} -${b}`);
+      };
+      u.addEventListener("sync", g), s.push(() => u.removeEventListener("sync", g));
+    }
+  }
+  let n = null;
+  if (d) {
+    n = L(u, t, a), n.update();
+    const e = () => n?.update(), r = () => n?.update();
+    u.addEventListener("sync", e), u.addEventListener("focus", r), s.push(() => {
+      u.removeEventListener("sync", e), u.removeEventListener("focus", r), n?.destroy();
+    });
+  }
+  return () => {
+    for (const e of s) e();
+  };
+}
+function N(u) {
+  const t = u.ids();
+  let i = 0, o = 0;
+  for (const c of t)
+    (!u.enabled || u.enabled(c)) && i++, (!u.visible || u.visible(c)) && o++;
+  return {
+    nodeCount: t.length,
+    enabledCount: i,
+    visibleCount: o
+  };
+}
+function w(u, t) {
+  return `${u}:${t}`;
+}
+function G(u) {
+  const t = u.indexOf(":");
+  if (t <= 0) return null;
+  const i = u.slice(0, t), o = u.slice(t + 1);
+  return o ? { sourceName: i, localId: o } : null;
+}
+function z(u) {
+  const t = /* @__PURE__ */ new Map();
+  for (let e = 0; e < u.length; e++) {
+    const r = u[e];
+    if (r.name.includes(":"))
+      throw new Error(`CombinedRegistry source name must not include ":" (got "${r.name}")`);
+    if (t.has(r.name))
+      throw new Error(`Duplicate CombinedRegistry source name "${r.name}"`);
+    t.set(r.name, r.registry);
+  }
+  let i = [], o = !0;
+  const c = /* @__PURE__ */ new Map(), d = 1e4, a = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+  function s(e) {
+    const r = c.get(e);
+    if (r !== void 0) return r;
+    const f = G(e);
+    if (!f)
+      return c.set(e, null), null;
+    const h = t.get(f.sourceName);
+    if (!h)
+      return c.set(e, null), null;
+    const g = { registry: h, localId: f.localId };
+    if (c.size >= d) {
+      const y = c.keys(), p = Math.floor(d * 0.2);
+      for (let v = 0; v < p; v++) {
+        const b = y.next().value;
+        b !== void 0 && c.delete(b);
+      }
+    }
+    return c.set(e, g), g;
+  }
+  return {
+    toCombinedId(e, r) {
+      return w(e, r);
+    },
+    fromCombinedId(e) {
+      return G(e);
+    },
+    getRegistry(e) {
+      return t.get(e);
+    },
+    clearCache() {
+      c.clear(), a.clear(), l.clear(), o = !0;
+    },
+    ids() {
+      if (!o) return i;
+      o = !1;
+      const e = [];
+      for (let r = 0; r < u.length; r++) {
+        const f = u[r], h = f.registry.ids();
+        for (let g = 0; g < h.length; g++) e.push(w(f.name, h[g]));
+      }
+      return i = e, i;
+    },
+    bounds(e) {
+      const r = s(e);
+      return r ? r.registry.bounds(r.localId) : null;
+    },
+    enabled(e) {
+      const r = s(e);
+      return r ? r.registry.enabled ? r.registry.enabled(r.localId) : !0 : !1;
+    },
+    visible(e) {
+      const r = s(e);
+      return r ? r.registry.visible ? r.registry.visible(r.localId) : !0 : !1;
+    },
+    group(e) {
+      const r = s(e);
+      return r && r.registry.group ? r.registry.group(r.localId) : null;
+    },
+    onFocus(e, r) {
+      const f = s(e);
+      f && f.registry.onFocus?.(f.localId, r);
+    },
+    onBlur(e, r) {
+      const f = s(e);
+      f && f.registry.onBlur?.(f.localId, r);
+    },
+    groupBoundary(e, r) {
+      const f = a.get(e);
+      return f ? f[r] ?? !1 : !1;
+    },
+    setGroupBoundary(e, r) {
+      a.set(e, r);
+    },
+    clearGroupBoundary(e) {
+      a.delete(e);
+    },
+    groupRestoreOnEnter(e) {
+      return l.get(e);
+    },
+    setGroupRestoreOnEnter(e, r) {
+      l.set(e, r);
+    },
+    clearGroupRestoreOnEnter(e) {
+      l.delete(e);
+    },
+    sync(e) {
+      if (!e) {
+        for (let g = 0; g < u.length; g++) u[g].registry.sync?.();
+        return;
+      }
+      const r = /* @__PURE__ */ new Map(), f = (g) => {
+        let y = r.get(g);
+        return y || (y = { added: [], removed: [], changed: [] }, r.set(g, y)), y;
+      }, h = (g, y) => {
+        if (g)
+          for (let p = 0; p < g.length; p++) {
+            const v = G(g[p]);
+            v && f(v.sourceName)[y].push(v.localId);
+          }
+      };
+      h(e.added, "added"), h(e.removed, "removed"), h(e.changed, "changed");
+      for (let g = 0; g < u.length; g++) {
+        const y = u[g], p = r.get(y.name);
+        y.registry.sync?.(p);
+      }
+    },
+    pendingUpdate() {
+      const e = { added: [], removed: [], changed: [] };
+      let r = !1;
+      for (let f = 0; f < u.length; f++) {
+        const h = u[f], g = h.registry.pendingUpdate?.();
+        if (!g) continue;
+        r = !0, o = !0;
+        const y = (p, v, b) => {
+          if (p)
+            for (let I = 0; I < p.length; I++) v.push(w(b, p[I]));
+        };
+        y(g.added, e.added, h.name), y(g.removed, e.removed, h.name), y(g.changed, e.changed, h.name);
+      }
+      return r ? e : void 0;
+    }
+  };
+}
+export {
+  k as NavigationEngine,
+  A as attachDebug,
+  z as createCombinedRegistry,
+  M as createGenericRegistry,
+  $ as createNavigationStore,
+  N as getEngineStats,
+  x as throwIfAborted
+};
+//# sourceMappingURL=index.js.map