@capillaryjs/capillary-viz 1.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,3426 @@
+var Tt = Object.defineProperty;
+var zt = (t, e, r) => e in t ? Tt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var c = (t, e, r) => zt(t, typeof e != "symbol" ? e + "" : e, r);
+import { Emitter as A, DerivedEmitter as z, BaseEmitter as xe, FetchState as k, combineFetchStates as Rt } from "@capillaryjs/capillary";
+import { Component as Te, Button as oe, css as G, OptionGroup as At, readDeclarativeRegions as Ot, OptionGroupHeaderEnd as jt, OptionsBox as Lt, Checkbox as ae, GroupBox as ge } from "@capillaryjs/capillary-ui";
+function Xe([t, e, r]) {
+  return {
+    "--c1": t,
+    "--c2": e,
+    "--c3": r,
+    "--colored-dark": t,
+    "--colored-base": e,
+    "--colored-light": r
+  };
+}
+class I {
+  constructor(e) {
+    c(this, "key");
+    c(this, "label");
+    c(this, "categories$");
+    c(this, "hidden$");
+    c(this, "visibleCategories$");
+    c(this, "allowResorting");
+    c(this, "ownedCategories");
+    c(this, "visibleCategoriesEmitter");
+    c(this, "seenKeys", /* @__PURE__ */ new Set());
+    c(this, "visibilityEmitters", /* @__PURE__ */ new Map());
+    c(this, "releaseCategoryDefaults");
+    c(this, "disposed", !1);
+    W(e, "Criterion options"), this.key = P(e.key, "Criterion key"), this.label = ze(e.label, "Criterion label"), pe(e.categories$, "Criterion categories$"), this.categories$ = e.categories$, this.allowResorting = e.allowResorting ?? !1, this.ownedCategories = e.ownedCategories, this.hidden$ = new A(
+      new Set(e.initialHiddenKeys ?? []),
+      { owner: this, purpose: `${this.key} hidden categories`, equals: Mt }
+    ), this.visibleCategoriesEmitter = new z(
+      [this.categories$, this.hidden$],
+      ([r, i]) => Object.freeze(
+        r.filter(({ key: n }) => !i.has(n))
+      ),
+      { owner: this, purpose: `${this.key} visible categories` }
+    ), this.visibleCategories$ = this.visibleCategoriesEmitter, this.releaseCategoryDefaults = this.categories$.subscribe(({ value: r }) => {
+      Array.isArray(r) && this.applyFirstSeenDefaults(r);
+    });
+  }
+  visibility(e) {
+    this.assertActive();
+    const r = P(e, "Category key");
+    let i = this.visibilityEmitters.get(r);
+    return i == null && (i = new Pt(this.hidden$, r, this), this.visibilityEmitters.set(r, i)), i;
+  }
+  setAllVisible(e, r) {
+    this.assertActive();
+    const i = new Set(this.categories$.get().map(({ key: s }) => s)), n = new Set(this.hidden$.get());
+    for (const s of i)
+      e ? n.delete(s) : n.add(s);
+    return this.hidden$.set(n, r ?? `${this.key} category visibility changed`);
+  }
+  pruneHidden(e) {
+    this.assertActive();
+    const r = new Set(this.categories$.get().map(({ key: n }) => n)), i = new Set([...this.hidden$.get()].filter((n) => r.has(n)));
+    return this.hidden$.set(i, e ?? `${this.key} hidden categories pruned`);
+  }
+  dispose() {
+    var e;
+    if (!this.disposed) {
+      this.disposed = !0, this.releaseCategoryDefaults();
+      for (const r of this.visibilityEmitters.values()) r.dispose();
+      this.visibilityEmitters.clear(), this.visibleCategoriesEmitter.dispose(), this.hidden$.dispose(), (e = this.ownedCategories) == null || e.dispose();
+    }
+  }
+  applyFirstSeenDefaults(e) {
+    Je(e, `${this.label} categories`);
+    const r = new Set(this.hidden$.get());
+    let i = !1;
+    for (const n of e)
+      this.seenKeys.has(n.key) || (this.seenKeys.add(n.key), n.hiddenByDefault === !0 && !r.has(n.key) && (r.add(n.key), i = !0));
+    i && this.hidden$.set(r, `${this.key} first-seen defaults applied`);
+  }
+  assertActive() {
+    if (this.disposed) throw new Error(`Criterion "${this.key}" is disposed`);
+  }
+}
+function si(t) {
+  W(t, "Static criterion options");
+  const e = Ze(t.categories, `${t.label} categories`), r = new A(e, {
+    purpose: `${t.key} static categories`
+  });
+  return new I({ ...t, categories$: r, ownedCategories: r });
+}
+function oi(t) {
+  if (W(t, "Derived criterion options"), pe(t.source$, "Derived criterion source$"), typeof t.extractKeys != "function")
+    throw new TypeError("Derived criterion extractKeys must be a function");
+  if (typeof t.describe != "function")
+    throw new TypeError("Derived criterion describe must be a function");
+  const e = new z(
+    [t.source$],
+    ([r]) => Dt(r, t),
+    { purpose: `${t.key} derived categories` }
+  );
+  return new I({
+    ...t,
+    allowResorting: t.allowResorting ?? !0,
+    categories$: e,
+    ownedCategories: e
+  });
+}
+function Dt(t, e) {
+  if (!Array.isArray(t)) throw new TypeError("Derived category items must be an array");
+  const r = /* @__PURE__ */ new Map();
+  let i = 0;
+  for (const o of t) {
+    const a = be(e.extractKeys(o));
+    if (a.length === 0) {
+      i += 1;
+      continue;
+    }
+    for (const l of a) r.set(l, (r.get(l) ?? 0) + 1);
+  }
+  const n = [...r].filter(([, o]) => o > 0).map(([o, a]) => ({ key: o, count: a, label: e.describe(o, a).label }));
+  n.sort(e.compare ?? ((o, a) => a.count - o.count || o.label.localeCompare(a.label) || o.key.localeCompare(a.key)));
+  const s = n.map(({ key: o, count: a }) => {
+    const l = e.describe(o, a);
+    return Ee({
+      key: o,
+      ...l,
+      generated: !0,
+      predicate: (u) => be(e.extractKeys(u)).includes(o)
+    }, "Derived category");
+  });
+  if (i > 0 && e.unmatched != null) {
+    const { key: o, ...a } = e.unmatched;
+    s.push(Ee({
+      key: o,
+      ...a,
+      generated: !0,
+      predicate: (l) => be(e.extractKeys(l)).length === 0
+    }, "Derived unmatched category"));
+  }
+  return Ze(s, "Derived categories");
+}
+function ai(t, e) {
+  pe(t, "filterByHidden items$"), Nt(e);
+  const r = [t];
+  for (const i of e) r.push(i.categories$, i.hidden$);
+  return new z(
+    r,
+    (i) => i[0].filter((s) => !e.some((o, a) => {
+      const l = i[a * 2 + 1], u = i[a * 2 + 2];
+      return l.some((h) => u.has(h.key) && h.predicate(s));
+    })),
+    { purpose: "items filtered by hidden visualization categories" }
+  );
+}
+function li(t, e) {
+  if (pe(t, "categoryCounts items$"), !(e instanceof I))
+    throw new TypeError("categoryCounts criterion must be a GroupingCriterion");
+  return new z(
+    [t, e.categories$],
+    (r) => {
+      const i = r[0], n = r[1];
+      return new Map(n.map((s) => [
+        s.key,
+        i.filter((o) => s.predicate(o)).length
+      ]));
+    },
+    { purpose: `${e.key} unfiltered category counts` }
+  );
+}
+function Mt(t, e) {
+  return t === e || t.size === e.size && [...t].every((r) => e.has(r));
+}
+class Pt extends xe {
+  constructor(r, i, n) {
+    super(r.get().has(i) ? "hidden" : "visible", {
+      owner: n,
+      purpose: `${i} category visibility`,
+      fetchState: r.getFetchState(),
+      error: r.getError()
+    });
+    c(this, "release");
+    this.source = r, this.categoryKey = i, this.release = r.subscribe((s) => this.updateFromSource(s), {
+      emitCurrent: !1
+    });
+  }
+  set(r, i) {
+    if (r !== "hidden" && r !== "visible")
+      throw new TypeError("Category visibility must be hidden or visible");
+    const n = new Set(this.source.get());
+    return r === "hidden" ? n.add(this.categoryKey) : n.delete(this.categoryKey), this.source.set(n, i ?? `${this.categoryKey} visibility changed`);
+  }
+  dispose() {
+    this.release(), super.dispose();
+  }
+  updateFromSource(r) {
+    this.setSnapshot({
+      value: r.value.has(this.categoryKey) ? "hidden" : "visible",
+      fetchState: r.fetchState,
+      error: r.error,
+      parentEvent: r.event,
+      cause: "hidden category membership changed"
+    });
+  }
+}
+function be(t) {
+  const r = (t == null ? [] : typeof t == "string" ? [t] : [...t]).map((i) => P(i, "Extracted category key"));
+  return [...new Set(r)];
+}
+function Ze(t, e) {
+  return Je(t, e), Object.freeze(t.map((r) => Ee(r, e)));
+}
+function Ee(t, e) {
+  W(t, e);
+  const r = {
+    ...t,
+    key: P(t.key, `${e} key`),
+    label: ze(t.label, `${e} label`),
+    colors: Qe(t.colors, `${e} colors`)
+  };
+  if (typeof t.predicate != "function")
+    throw new TypeError(`${e} predicate must be a function`);
+  return t.colorKey !== void 0 && P(t.colorKey, `${e} colorKey`), Object.freeze(r);
+}
+function Je(t, e) {
+  if (!Array.isArray(t)) throw new TypeError(`${e} must be an array`);
+  const r = /* @__PURE__ */ new Set();
+  for (const i of t) {
+    W(i, e);
+    const n = P(i.key, `${e} key`);
+    if (r.has(n)) throw new Error(`${e} contains duplicate key "${n}"`);
+    if (r.add(n), ze(i.label, `${e} label`), Qe(i.colors, `${e} colors`), typeof i.predicate != "function")
+      throw new TypeError(`${e} predicate must be a function`);
+  }
+}
+function Nt(t) {
+  if (!Array.isArray(t)) throw new TypeError("Criteria must be an array");
+  const e = /* @__PURE__ */ new Set();
+  for (const r of t) {
+    if (!(r instanceof I))
+      throw new TypeError("Criteria must contain GroupingCriterion instances");
+    if (e.has(r.key)) throw new Error(`Duplicate criterion key "${r.key}"`);
+    e.add(r.key);
+  }
+}
+function Qe(t, e) {
+  if (!Array.isArray(t) || t.length !== 3 || t.some((r) => typeof r != "string" || r.trim() === ""))
+    throw new TypeError(`${e} must contain three non-empty CSS color values`);
+  return Object.freeze([...t]);
+}
+function pe(t, e) {
+  if (t == null || typeof t != "object" && typeof t != "function" || typeof Reflect.get(t, "get") != "function" || typeof Reflect.get(t, "getFetchState") != "function" || typeof Reflect.get(t, "getError") != "function" || typeof Reflect.get(t, "subscribe") != "function")
+    throw new TypeError(`${e} must be a readable emitter`);
+}
+function W(t, e) {
+  if (t == null || typeof t != "object" || Array.isArray(t))
+    throw new TypeError(`${e} must be an object`);
+}
+function P(t, e) {
+  if (typeof t != "string" || t.trim() === "")
+    throw new TypeError(`${e} must be a non-empty string`);
+  return t;
+}
+function ze(t, e) {
+  if (typeof t != "string" || t.trim() === "")
+    throw new TypeError(`${e} must be a non-empty string`);
+  return t;
+}
+function we(t, e, r = {}) {
+  if (!Array.isArray(t)) throw new TypeError("Block layout items must be an array");
+  if (!Array.isArray(e)) throw new TypeError("Block layout splits must be an array");
+  const i = r.readabilityThreshold ?? 0.02;
+  if (!Number.isFinite(i) || i < 0 || i > 1)
+    throw new RangeError("Block readability threshold must be between zero and one");
+  const n = [], s = Object.freeze([...t]), o = et({
+    items: s,
+    splits: e,
+    splitIndex: 0,
+    path: Object.freeze([]),
+    criterion: null,
+    category: null,
+    parentCount: s.length,
+    totalShare: 1,
+    readabilityThreshold: i,
+    issues: n,
+    rootLabel: r.rootLabel ?? "All items"
+  });
+  return Object.freeze({ valid: n.length === 0, root: o, issues: Object.freeze(n) });
+}
+function Kt(t) {
+  if (!(t instanceof I))
+    throw new TypeError("criterionSnapshot requires a GroupingCriterion");
+  return Object.freeze({
+    key: t.key,
+    label: t.label,
+    categories: t.categories$.get(),
+    allowResorting: t.allowResorting
+  });
+}
+function D(t, e) {
+  if (e == null) return null;
+  let r = t;
+  for (const i of e) {
+    const n = r.children.find((s) => s.criterionKey === i.criterionKey && s.categoryKey === i.categoryKey);
+    if (n == null) return null;
+    r = n;
+  }
+  return r;
+}
+class It {
+  constructor(e, r, i = {}) {
+    c(this, "layout$");
+    c(this, "selectedPath$");
+    c(this, "selectedBlock$");
+    c(this, "selectedItems$");
+    c(this, "layoutEmitter");
+    c(this, "selectedBlockEmitter");
+    c(this, "selectedItemsEmitter");
+    c(this, "releases", []);
+    c(this, "disposed", !1);
+    this.options = i, this.layoutEmitter = new Bt(e, r, i), this.layout$ = this.layoutEmitter, this.selectedPath$ = new A(null, {
+      owner: this,
+      purpose: "selected block path",
+      equals: qt
+    }), this.selectedBlockEmitter = new z(
+      [this.layout$, this.selectedPath$],
+      ([n, s]) => D(n.root, s),
+      { owner: this, purpose: "selected block" }
+    ), this.selectedBlock$ = this.selectedBlockEmitter, this.selectedItemsEmitter = new z(
+      [this.selectedBlock$],
+      ([n]) => (n == null ? void 0 : n.items) ?? Object.freeze([]),
+      { owner: this, purpose: "selected block items" }
+    ), this.selectedItems$ = this.selectedItemsEmitter, this.releases.push(
+      this.layout$.subscribe(() => this.reconcileSelection(), { emitCurrent: !1 }),
+      this.selectedPath$.subscribe(() => this.reconcileSelection(), { emitCurrent: !1 })
+    );
+  }
+  select(e, r) {
+    this.assertActive();
+    const i = tt(e);
+    if (D(this.layout$.get().root, i) == null)
+      throw new Error("Cannot select a path absent from the current block layout");
+    return this.selectedPath$.set(i, r ?? "block selected");
+  }
+  clear(e) {
+    return this.assertActive(), this.selectedPath$.set(null, e ?? "block selection cleared");
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const e of this.releases.splice(0)) e();
+      this.selectedItemsEmitter.dispose(), this.selectedBlockEmitter.dispose(), this.selectedPath$.dispose(), this.layoutEmitter.dispose();
+    }
+  }
+  reconcileSelection() {
+    const e = this.selectedPath$.get();
+    e == null || D(this.layout$.get().root, e) != null || this.selectedPath$.set(null, "block selection no longer exists");
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("Block selection model is disposed");
+  }
+}
+function ci(t, e, r = {}) {
+  return new It(t, e, r);
+}
+class Bt extends xe {
+  constructor(r, i, n) {
+    super(we([], [], n), {
+      purpose: "reactive block layout",
+      fetchState: k.Initial
+    });
+    c(this, "releases", []);
+    c(this, "categoryReleases", []);
+    this.items$ = r, this.splits$ = i, this.options = n, Ie(r, "Block selection items$"), Ie(i, "Block selection splits$"), this.releases.push(
+      r.subscribe(({ event: s }) => this.recompute(s), { emitCurrent: !1 }),
+      i.subscribe(({ event: s }) => {
+        this.subscribeCategories(), this.recompute(s);
+      }, { emitCurrent: !1 })
+    ), this.subscribeCategories(), this.recompute(null);
+  }
+  dispose() {
+    for (const r of this.releases.splice(0)) r();
+    this.releaseCategories(), super.dispose();
+  }
+  subscribeCategories() {
+    this.releaseCategories(), this.categoryReleases = this.splits$.get().map((r) => r.categories$.subscribe(
+      ({ event: i }) => this.recompute(i),
+      { emitCurrent: !1 }
+    ));
+  }
+  releaseCategories() {
+    for (const r of this.categoryReleases.splice(0)) r();
+  }
+  recompute(r) {
+    const i = this.splits$.get(), n = [
+      this.items$,
+      this.splits$,
+      ...i.map(({ categories$: p }) => p)
+    ], s = n.map((p) => p.getFetchState()), o = n.map((p) => p.getError()).filter(Ut);
+    let a, l = null;
+    try {
+      a = we(
+        this.items$.get(),
+        i.map(Kt),
+        this.options
+      );
+    } catch (p) {
+      l = p, a = we([], [], this.options);
+    }
+    const u = l == null ? o : [...o, l], h = u.length > 0 ? k.Error : Rt(s);
+    this.setSnapshot({
+      value: a,
+      fetchState: h,
+      error: u.length === 0 ? null : Object.freeze(u),
+      parentEvent: r,
+      cause: "block layout source changed"
+    });
+  }
+}
+function et(t) {
+  const {
+    items: e,
+    splits: r,
+    splitIndex: i,
+    path: n,
+    criterion: s,
+    category: o,
+    parentCount: a,
+    totalShare: l,
+    readabilityThreshold: u,
+    issues: h,
+    rootLabel: p
+  } = t, b = r[i], y = b != null && n.length > 0 && l < u, g = b == null || y ? [] : Ft({
+    items: e,
+    splits: r,
+    splitIndex: i,
+    path: n,
+    criterion: b,
+    totalShare: l,
+    readabilityThreshold: u,
+    issues: h,
+    rootLabel: p
+  }), f = a === 0 ? 0 : e.length / a;
+  return Object.freeze({
+    key: _t(n),
+    path: n,
+    criterionKey: (s == null ? void 0 : s.key) ?? null,
+    criterionLabel: (s == null ? void 0 : s.label) ?? null,
+    categoryKey: (o == null ? void 0 : o.key) ?? null,
+    label: (o == null ? void 0 : o.label) ?? p,
+    colors: (o == null ? void 0 : o.colors) ?? null,
+    colorKey: (o == null ? void 0 : o.colorKey) ?? null,
+    count: e.length,
+    share: f,
+    totalShare: l,
+    depth: n.length - 1,
+    items: e,
+    children: Object.freeze(g),
+    childOrientation: n.length % 2 === 0 ? "horizontal" : "vertical",
+    childrenSuppressed: y
+  });
+}
+function Ft(t) {
+  const { items: e, criterion: r, path: i, issues: n } = t, s = new Map(r.categories.map((l) => [l.key, {
+    category: l,
+    items: []
+  }]));
+  let o = !0;
+  if (e.forEach((l, u) => {
+    const h = r.categories.filter((p) => p.predicate(l));
+    if (h.length !== 1) {
+      o = !1, n.push(Object.freeze({
+        kind: h.length === 0 ? "unmatched" : "multiple-matches",
+        criterionKey: r.key,
+        criterionLabel: r.label,
+        parentPath: i,
+        item: l,
+        itemIndex: u,
+        matchedCategoryKeys: Object.freeze(h.map(({ key: p }) => p))
+      }));
+      return;
+    }
+    s.get(h[0].key).items.push(l);
+  }), !o) return [];
+  let a = [...s.values()].filter((l) => l.items.length > 0);
+  return r.allowResorting && (a = a.sort((l, u) => u.items.length - l.items.length || l.category.label.localeCompare(u.category.label) || l.category.key.localeCompare(u.category.key))), a.map(({ category: l, items: u }) => {
+    const h = tt([...i, {
+      criterionKey: r.key,
+      categoryKey: l.key
+    }]), p = e.length === 0 ? 0 : u.length / e.length;
+    return et({
+      ...t,
+      items: Object.freeze(u),
+      splitIndex: t.splitIndex + 1,
+      path: h,
+      criterion: r,
+      category: l,
+      parentCount: e.length,
+      totalShare: t.totalShare * p
+    });
+  });
+}
+function tt(t) {
+  if (!Array.isArray(t)) throw new TypeError("Block path must be an array");
+  return Object.freeze(t.map((e) => {
+    if (e == null || typeof e != "object")
+      throw new TypeError("Block path segments must be objects");
+    if (typeof e.criterionKey != "string" || e.criterionKey === "" || typeof e.categoryKey != "string" || e.categoryKey === "")
+      throw new TypeError("Block path keys must be non-empty strings");
+    return Object.freeze({ ...e });
+  }));
+}
+function qt(t, e) {
+  return t === e || t != null && e != null && t.length === e.length && t.every((r, i) => {
+    const n = e[i];
+    return r.criterionKey === (n == null ? void 0 : n.criterionKey) && r.categoryKey === n.categoryKey;
+  });
+}
+function _t(t) {
+  return t.length === 0 ? "root" : t.map(({ criterionKey: e, categoryKey: r }) => `${encodeURIComponent(e)}=${encodeURIComponent(r)}`).join("/");
+}
+function Ut(t) {
+  return t != null;
+}
+function Ie(t, e) {
+  if (t == null || typeof t != "object" && typeof t != "function" || typeof Reflect.get(t, "get") != "function" || typeof Reflect.get(t, "getFetchState") != "function" || typeof Reflect.get(t, "getError") != "function" || typeof Reflect.get(t, "subscribe") != "function")
+    throw new TypeError(`${e} must be a readable emitter`);
+}
+const Be = "data-cap-structural-styles";
+let Ht = 1;
+class rt {
+  constructor(e = `runtime-${Ht++}`) {
+    c(this, "id");
+    c(this, "cssFragments", /* @__PURE__ */ new Map());
+    if (typeof e != "string") throw new TypeError("StyleRegistry id must be a string");
+    this.id = e;
+  }
+  registerCSS(e) {
+    if (typeof e != "string") throw new TypeError("Component CSS must be a string");
+    const r = e.trim();
+    return r.length > 0 && this.cssFragments.set(`raw:${r}`, { kind: "raw", css: r }), this;
+  }
+  /** @internal Collect a host-relative component template without resolving it yet. */
+  registerHostCSS(e, r) {
+    if (typeof e != "string") throw new TypeError("Component CSS must be a string");
+    if (typeof r != "string" || r.trim().length === 0)
+      throw new TypeError("Component CSS host must be a non-empty selector");
+    const i = e.trim();
+    if (i.length === 0) return this;
+    if (!i.includes("&")) return this.registerCSS(i);
+    const n = `host:${i}`, s = this.cssFragments.get(n);
+    return s == null ? this.cssFragments.set(n, {
+      kind: "host",
+      css: i,
+      hosts: /* @__PURE__ */ new Set([r.trim()])
+    }) : s.kind === "host" && s.hosts.add(r.trim()), this;
+  }
+  generateCSS() {
+    return [...this.cssFragments.values()].map((e) => e.kind === "raw" ? e.css : it(e.css, [...e.hosts])).join(`
+
+`);
+  }
+  injectAll(e = globalThis.document) {
+    if ((e == null ? void 0 : e.head) == null)
+      throw new TypeError("StyleRegistry.injectAll requires a document with a head");
+    const r = `style[${Be}="${Gt(this.id)}"]`;
+    let i = e.head.querySelector(r);
+    i == null && (i = e.createElement("style"), i.setAttribute(Be, this.id), e.head.prepend(i));
+    const n = this.generateCSS();
+    return i.textContent !== n && (i.textContent = n), i;
+  }
+  reset() {
+    this.cssFragments.clear();
+  }
+}
+function Vt() {
+  return new rt();
+}
+const Yt = new rt("");
+function Gt(t) {
+  return t.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function it(t, e) {
+  let r = "", i = 0;
+  for (; i < t.length; ) {
+    const n = Zt(t, i);
+    if (n < 0) return r + t.slice(i);
+    const s = Jt(t, n);
+    if (s < 0) return r + t.slice(i);
+    const o = t.slice(i, n), a = t.slice(n + 1, s), l = o.trim();
+    r += l.startsWith("@") ? `${o}{${it(a, e)}}` : `${Wt(o, e)}{${a}}`, i = s + 1;
+  }
+  return r;
+}
+function Wt(t, e) {
+  var o, a, l;
+  if (e.length === 1 || !t.includes("&"))
+    return e.length === 1 ? t.replaceAll("&", e[0]) : t;
+  const r = ((o = t.match(/^\s*/)) == null ? void 0 : o[0]) ?? "", i = ((a = t.match(/\s*$/)) == null ? void 0 : a[0]) ?? "", n = Xt(t.trim()), s = ((l = r.match(/(?:^|\n)([ \t]*)$/)) == null ? void 0 : l[1]) ?? "";
+  return r + n.flatMap((u) => u.includes("&") ? e.map((h) => u.replaceAll("&", h)) : [u]).join(`,
+${s}`) + i;
+}
+function Xt(t) {
+  const e = [];
+  let r = 0, i = 0, n = 0, s = null;
+  for (let o = 0; o < t.length; o += 1) {
+    const a = t[o];
+    if (s != null) {
+      a === "\\" ? o += 1 : a === s && (s = null);
+      continue;
+    }
+    a === '"' || a === "'" ? s = a : a === "(" ? i += 1 : a === ")" ? i -= 1 : a === "[" ? n += 1 : a === "]" ? n -= 1 : a === "," && i === 0 && n === 0 && (e.push(t.slice(r, o).trim()), r = o + 1);
+  }
+  return e.push(t.slice(r).trim()), e.filter(Boolean);
+}
+function Zt(t, e) {
+  for (let r = e; r < t.length; r += 1) {
+    const i = t[r];
+    if (i === '"' || i === "'")
+      r = nt(t, r);
+    else if (i === "/" && t[r + 1] === "*")
+      r = st(t, r);
+    else if (i === "{")
+      return r;
+  }
+  return -1;
+}
+function Jt(t, e) {
+  let r = 1;
+  for (let i = e + 1; i < t.length; i += 1) {
+    const n = t[i];
+    if (n === '"' || n === "'")
+      i = nt(t, i);
+    else if (n === "/" && t[i + 1] === "*")
+      i = st(t, i);
+    else if (n === "{")
+      r += 1;
+    else if (n === "}" && --r === 0)
+      return i;
+  }
+  return -1;
+}
+function nt(t, e) {
+  const r = t[e];
+  for (let i = e + 1; i < t.length; i += 1)
+    if (t[i] === "\\") i += 1;
+    else if (t[i] === r) return i;
+  return t.length;
+}
+function st(t, e) {
+  const r = t.indexOf("*/", e + 2);
+  return r < 0 ? t.length : r + 1;
+}
+const Qt = /* @__PURE__ */ new WeakSet(), er = /* @__PURE__ */ new WeakSet();
+class ot {
+  constructor(e = []) {
+    c(this, "providers", /* @__PURE__ */ new Map());
+    c(this, "instances", /* @__PURE__ */ new Map());
+    c(this, "creationOrder", []);
+    c(this, "resolving", []);
+    c(this, "disposed", !1);
+    if (!Array.isArray(e))
+      throw new TypeError("ServiceScope providers must be an array");
+    for (const r of e) {
+      if (ir(r), this.providers.has(r.key))
+        throw new Error(`Service "${r.key.name}" is registered more than once`);
+      this.providers.set(r.key, r);
+    }
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  has(e) {
+    return this.assertActive(), Fe(e), this.providers.has(e);
+  }
+  require(e) {
+    if (this.assertActive(), Fe(e), this.instances.has(e)) return this.instances.get(e);
+    const r = this.providers.get(e);
+    if (r == null) throw new Error(`Service "${e.name}" is not registered`);
+    const i = this.resolving.indexOf(e);
+    if (i >= 0) {
+      const n = [...this.resolving.slice(i), e].map((s) => s.name).join(" -> ");
+      throw new Error(`Circular service dependency: ${n}`);
+    }
+    this.resolving.push(e);
+    try {
+      const n = r.create(this);
+      return this.instances.set(e, n), this.creationOrder.push(e), n;
+    } finally {
+      this.resolving.pop();
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = !0;
+    const e = [];
+    for (const r of [...this.creationOrder].reverse()) {
+      const i = this.instances.get(r);
+      try {
+        const n = nr(i);
+        n != null && n.call(i);
+      } catch (n) {
+        e.push(n);
+      }
+    }
+    if (this.instances.clear(), this.creationOrder.length = 0, this.resolving.length = 0, e.length === 1) throw e[0];
+    if (e.length > 1)
+      throw new AggregateError(e, "Several services failed during disposal");
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("ServiceScope has been disposed");
+  }
+}
+function tr(t = []) {
+  return new ot(t);
+}
+function rr(t) {
+  return t != null && (typeof t == "object" || typeof t == "function") && Qt.has(t);
+}
+function Fe(t) {
+  if (!rr(t)) throw new TypeError("Expected a service key created by defineService()");
+}
+function ir(t) {
+  if (t == null || typeof t != "object" && typeof t != "function" || !er.has(t))
+    throw new TypeError("Expected a service provider created by provideService()");
+}
+function nr(t) {
+  if (t == null || typeof t != "object" && typeof t != "function") return null;
+  const e = Reflect.get(t, "dispose");
+  return typeof e == "function" ? e : null;
+}
+const ne = Object.freeze({
+  breadcrumbLabel: "Breadcrumb",
+  calendarGridLabel: "Choose a date",
+  calendarNextMonthLabel: "Next month",
+  calendarPreviousMonthLabel: "Previous month",
+  checkboxOptionLabel: "Option",
+  checkboxStateLabel: (t, e) => `${t}: ${e}`,
+  colorOptionGrayLabel: "Gray",
+  colorOptionGreenLabel: "Green",
+  colorOptionIceBlueLabel: "Ice blue",
+  colorOptionOceanLabel: "Ocean",
+  colorOptionOrangeLabel: "Orange",
+  colorOptionPurpleLabel: "Purple",
+  colorOptionRedLabel: "Red",
+  colorOptionYellowLabel: "Yellow",
+  dataTableEmpty: "No rows",
+  dataTableLoadError: "Unable to load rows",
+  dataTableLoading: "Loading rows…",
+  dataTableRetry: "Retry",
+  datePickerDialogLabel: "Choose a date",
+  datePickerOpenCalendarLabel: "Open calendar",
+  dateTimePickerDateLabel: "Date",
+  dateTimePickerTimeLabel: "Time",
+  dialogCloseLabel: "Close",
+  dropdownLoadError: "Unable to load options",
+  dropdownPlaceholder: "Select…",
+  filterModeDenyLabel: "deny",
+  filterModeNeutralLabel: "neutral",
+  filterModePreferLabel: "prefer",
+  filterModeRequireLabel: "require",
+  filterPanelEmpty: "No filter options",
+  filterPanelLabel: "Filter options",
+  filterPanelLoadError: "Unable to load filter options",
+  filterPanelLoading: "Loading filter options…",
+  listViewEmpty: "No items",
+  listViewLabel: "Items",
+  listViewLoadError: "Unable to load items",
+  listViewLoading: "Loading items…",
+  progressInProgress: "In progress",
+  radioOptionLabel: "Option",
+  splitViewSeparatorLabel: "Resize panes",
+  tabLineLabel: "Sections",
+  tableFilterColumnLabel: (t) => `Filter ${t}`,
+  tableSortColumnLabel: (t) => `Sort ${t}`,
+  themeOptionJavaLabel: "Java",
+  themeOptionMinimalLabel: "Minimal",
+  themeOptionShinyLabel: "Shiny",
+  timePickerPlaceholder: "Select time…",
+  toolbarLabel: "Actions",
+  treeViewEmpty: "No tree items",
+  treeViewLoadError: "Unable to load tree items",
+  treeViewLoading: "Loading tree items…"
+});
+class at {
+  constructor(e, r) {
+    c(this, "locale");
+    c(this, "messages");
+    this.locale = e, this.messages = r, Object.freeze(this);
+  }
+  message(e) {
+    return this.messages[e];
+  }
+}
+const sr = new at(
+  void 0,
+  ne
+);
+function or(t) {
+  if (t == null) return sr;
+  if (typeof t != "object" || Array.isArray(t))
+    throw new TypeError("Capillary UI localization must be an object");
+  const e = ar(t.locale), r = t.messages;
+  if (r != null && (typeof r != "object" || Array.isArray(r)))
+    throw new TypeError("Capillary UI localization messages must be an object");
+  const i = { ...ne };
+  if (r != null)
+    for (const n of Object.keys(ne)) {
+      const s = r[n];
+      if (s === void 0) continue;
+      const o = ne[n];
+      if (typeof s != typeof o)
+        throw new TypeError(`Capillary UI localization message "${n}" has the wrong type`);
+      Object.assign(i, { [n]: s });
+    }
+  return new at(e, Object.freeze(i));
+}
+function ar(t) {
+  if (typeof t != "string" || t.trim() === "")
+    throw new TypeError("Capillary UI localization locale must be a non-empty BCP 47 language tag");
+  try {
+    return Intl.getCanonicalLocales(t)[0];
+  } catch (e) {
+    throw new RangeError(`Invalid Capillary UI localization locale: ${t}`, { cause: e });
+  }
+}
+const lr = /* @__PURE__ */ new Set([
+  "annotation-xml",
+  "color-profile",
+  "font-face",
+  "font-face-src",
+  "font-face-uri",
+  "font-face-format",
+  "font-face-name",
+  "missing-glyph"
+]);
+class lt {
+  constructor(e = {}, r = Vt()) {
+    c(this, "styleRegistry");
+    c(this, "services");
+    c(this, "router");
+    c(this, "localization");
+    c(this, "routedRoots", /* @__PURE__ */ new WeakSet());
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError("CapillaryUiRuntime options must be an object");
+    if (Object.hasOwn(e, "elementNames"))
+      throw new TypeError("CapillaryUiRuntime no longer supports configurable element names");
+    if (this.styleRegistry = r, this.localization = or(e.localization), this.services = e.services ?? tr(), !(this.services instanceof ot))
+      throw new TypeError("Capillary UI services must be a ServiceScope");
+    if (this.router = e.router ?? null, this.router != null && (typeof this.router != "object" || typeof this.router.openScope != "function" || typeof this.router.completeScope != "function"))
+      throw new TypeError("Capillary UI router must be a BrowserRouter");
+  }
+  /** Resolve a fixed one-hyphen public host name for a built-in component. */
+  resolveElementName(e) {
+    ct(e, "Capillary UI component host name");
+    const r = `cap-${e.replaceAll("-", "")}`;
+    return cr(r), r;
+  }
+  resolveHostSelector(e, r) {
+    if (typeof e != "string") throw new TypeError("Host selector must be a string");
+    return e.replaceAll("&", this.resolveElementName(r));
+  }
+  resolveHostCSS(e, r) {
+    if (typeof e != "string") throw new TypeError("Host CSS must be a string");
+    return e.replaceAll("&", this.resolveElementName(r));
+  }
+  create(e, ...r) {
+    const i = new e(...r);
+    return i._setRuntime(this), i;
+  }
+  mount(e, r, i = null) {
+    e._setRuntime(this);
+    let n = null;
+    this.router != null && !this.routedRoots.has(e) && (this.routedRoots.add(e), n = this.router.openScope(this.router.root, e), e.onCleanup(n));
+    try {
+      e.mount(r, i), this.router != null && n != null && this.router.completeScope(this.router.root, e);
+    } catch (s) {
+      throw n == null || n(), s;
+    }
+    return e;
+  }
+  registerStyles(e) {
+    if (e == null || typeof e.registerStyles != "function")
+      throw new TypeError("registerStyles requires a Capillary UI component dependency");
+    return e.registerStyles(this), this;
+  }
+  injectStyles(e = globalThis.document) {
+    return this.styleRegistry.injectAll(e);
+  }
+}
+const qe = new lt({}, Yt);
+function ct(t, e) {
+  if (typeof t != "string" || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(t))
+    throw new TypeError(`${e} must be a lowercase kebab-case name`);
+}
+function cr(t) {
+  if (ct(t, "Capillary UI element name"), !t.includes("-") || lr.has(t))
+    throw new TypeError(`Capillary UI element name must be a non-reserved name containing a hyphen: ${t}`);
+}
+const le = Symbol.for("@capillaryjs/capillary-ui.Fragment"), ur = /* @__PURE__ */ new WeakSet(), hr = /* @__PURE__ */ new Set([
+  "allowFullScreen",
+  "async",
+  "autoFocus",
+  "autoPlay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formNoValidate",
+  "hidden",
+  "inert",
+  "loop",
+  "multiple",
+  "muted",
+  "noModule",
+  "noValidate",
+  "open",
+  "playsInline",
+  "readOnly",
+  "required",
+  "reversed",
+  "selected"
+]), dr = /* @__PURE__ */ new Set([
+  "checked",
+  "defaultChecked",
+  "defaultValue",
+  "disabled",
+  "indeterminate",
+  "multiple",
+  "muted",
+  "readOnly",
+  "required",
+  "selected",
+  "selectedIndex",
+  "tabIndex",
+  "value"
+]), _e = "data-cap";
+function ce(t, e = null, ...r) {
+  const i = e ?? {};
+  if (typeof i != "object" || Array.isArray(i))
+    throw new TypeError("VNode props must be an object or null");
+  const {
+    children: n,
+    key: s = null,
+    ...o
+  } = i;
+  return {
+    type: t,
+    key: s,
+    props: {
+      ...o,
+      children: ut([n, r])
+    }
+  };
+}
+function pr(t, ...e) {
+  return t.reduce((r, i, n) => r + i + String(e[n] ?? ""), "");
+}
+const $ = class $ {
+  constructor(e = {}) {
+    c(this, "props");
+    c(this, "dom", null);
+    /** @internal */
+    c(this, "_rendered", null);
+    /** @internal */
+    c(this, "_childComponents", /* @__PURE__ */ new Set());
+    /** @internal Component ancestry used to enforce structural invariants. */
+    c(this, "_parentComponent", null);
+    c(this, "initialized", !1);
+    c(this, "mounted", !1);
+    c(this, "destroyed", !1);
+    c(this, "updating", !1);
+    c(this, "updateRequested", !1);
+    c(this, "cleanupFunctions", /* @__PURE__ */ new Set());
+    c(this, "watched", /* @__PURE__ */ new Map());
+    c(this, "renderReadSubscriptions", /* @__PURE__ */ new Map());
+    c(this, "collectingRenderReads", null);
+    /** @internal */
+    c(this, "_runtime", qe);
+    /** @internal Route lineage inherited by nested routed components. */
+    c(this, "_routeContext", null);
+    /** JSX component for this instance's runtime-configured custom host. */
+    c(this, "Host", ({
+      children: e = [],
+      ...r
+    }) => this.host(r, e));
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError(`${this.constructor.name} props must be an object`);
+    this.props = e;
+  }
+  static new(...e) {
+    const r = new this(...e);
+    if (!(r instanceof $))
+      throw new TypeError("Component.new() requires a Component constructor");
+    return r.mount();
+  }
+  static registerStyles(e = qe, r = /* @__PURE__ */ new Set()) {
+    if (r.has(this)) return;
+    r.add(this);
+    const i = this.hostName ?? null, n = Ar(this);
+    for (const s of n)
+      Object.hasOwn(s, "css") && s.css && (i == null ? e.styleRegistry.registerCSS(s.css) : e.styleRegistry.registerHostCSS(
+        s.css,
+        e.resolveElementName(i)
+      ));
+    for (const s of n)
+      if (Object.hasOwn(s, "dependencies"))
+        for (const o of s.dependencies ?? [])
+          o.registerStyles(e, r);
+  }
+  /** One-time setup hook. Constructors must not subscribe or render. */
+  initialize() {
+  }
+  render() {
+    throw new Error(`${this.constructor.name} must implement render()`);
+  }
+  /** Render this component's configured custom host element. */
+  host(e = null, ...r) {
+    const n = this.constructor.hostName;
+    if (n == null)
+      throw new Error(`${this.constructor.name} does not declare a custom host name`);
+    const {
+      class: s,
+      className: o,
+      ...a
+    } = e ?? {}, l = o ?? s, u = this.props.island === !0 ? Or(l, "island") : l;
+    return ce(this._runtime.resolveElementName(n), {
+      ...a,
+      ...u == null ? {} : { className: u },
+      "data-cap-component": n
+    }, ...r);
+  }
+  /** @internal Assign an immutable application runtime before initialization or mounting. */
+  _setRuntime(e) {
+    var r;
+    if (!(e instanceof lt))
+      throw new TypeError("Component runtime must be a CapillaryUiRuntime");
+    if (e === this._runtime) return this;
+    if (this.initialized || this.mounted || this._rendered != null)
+      throw new Error("Cannot change a component runtime after initialization");
+    return this._runtime = e, this._routeContext == null && (this._routeContext = ((r = e.router) == null ? void 0 : r.root) ?? null), this;
+  }
+  /** @internal Assign contextual route lineage before initialization. */
+  _setRouteContext(e) {
+    if (this.initialized || this.mounted || this._rendered != null)
+      throw new Error("Cannot change a component route context after initialization");
+    return this._routeContext = e, this;
+  }
+  /** @internal Route lineage inherited by component children. */
+  _routeContextForChildren() {
+    return this._routeContext;
+  }
+  /** @internal Assign the renderer-owned component ancestry. */
+  _setParentComponent(e) {
+    if (this._parentComponent != null && this._parentComponent !== e)
+      throw new Error("A component instance cannot move between component owners");
+    return this._parentComponent = e, this.validateIslandAncestry(this.props), this;
+  }
+  mount(e = null, r = null) {
+    if (this.destroyed) throw new Error("Cannot mount a destroyed component");
+    this.validateIslandAncestry(this.props);
+    let i = !1;
+    return this.initialized || (this.validateRequiredServices(), this.initialized = !0, this.initialize()), this.mounted || (this.mounted = !0, this.update(), i = !0), e != null && (Rr(e), je(e, this._rendered, r)), i && this.afterMount(this.dom), this;
+  }
+  attachTo(e) {
+    return this.mount(e), this;
+  }
+  update(e) {
+    if (this.destroyed) return this;
+    if (!this.mounted) return this.mount();
+    if (this.updating)
+      return this.updateRequested = !0, this;
+    this.updating = !0;
+    try {
+      do {
+        this.updateRequested = !1;
+        const r = /* @__PURE__ */ new Set();
+        this.collectingRenderReads = r;
+        let i;
+        try {
+          i = H(this.render());
+        } finally {
+          this.collectingRenderReads = null;
+        }
+        this._rendered = Re(this._rendered, i, this), this.dom = mt(this._rendered), this.reconcileRenderReads(r), this.afterUpdate(this.dom);
+      } while (this.updateRequested && !this.destroyed);
+    } finally {
+      this.updating = !1;
+    }
+    return this;
+  }
+  setProps(e) {
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError(`${this.constructor.name} props must be an object`);
+    return this.validateIslandAncestry(e), this.props = e, this.mounted && this.update(), this;
+  }
+  afterMount(e) {
+  }
+  afterUpdate(e) {
+  }
+  watch(...e) {
+    for (const r of e) {
+      if (r == null || typeof r.subscribe != "function")
+        throw new TypeError("watch requires emitter-like values");
+      if (this.watched.has(r)) continue;
+      const i = r.subscribe(({ event: n }) => {
+        this.mounted && !this.destroyed && this.update(n);
+      }, { emitCurrent: !1 });
+      this.watched.set(r, i), this.onCleanup(() => {
+        i(), this.watched.delete(r);
+      });
+    }
+    return this;
+  }
+  watchFutureValues(...e) {
+    return this.watch(...e);
+  }
+  /** Read an emitter during render and rerender when that dependency changes. */
+  read(e) {
+    return this.trackRenderRead(e), e.get();
+  }
+  /** Read a Capillary value, fetch state, and error as one tracked render dependency. */
+  snapshot(e) {
+    return this.trackRenderRead(e), Object.freeze({
+      value: e.get(),
+      fetchState: e.getFetchState(),
+      error: e.getError()
+    });
+  }
+  onCleanup(e) {
+    if (typeof e != "function") throw new TypeError("cleanup must be a function");
+    if (this.destroyed)
+      return e(), () => {
+      };
+    this.cleanupFunctions.add(e);
+    let r = !0;
+    return () => {
+      r && (r = !1, this.cleanupFunctions.delete(e), e());
+    };
+  }
+  /** Resolve one explicitly declared application service from this component's runtime. */
+  requireService(e) {
+    if (!this.initialized)
+      throw new Error("Components may resolve services during initialize() or later");
+    const r = this.constructor;
+    if (!r.requiredServices.includes(e))
+      throw new Error(
+        `${r.name} must declare service "${e.name}" in requiredServices`
+      );
+    return this._runtime.services.require(e);
+  }
+  /** Read the immutable Capillary UI localization selected for this component's runtime. */
+  get localization() {
+    return this._runtime.localization;
+  }
+  /** Resolve one Capillary UI-authored message with the runtime's English fallback. */
+  capillaryUiMessage(e) {
+    return this.localization.message(e);
+  }
+  listen(e, r, i, n) {
+    if (e == null || typeof e.addEventListener != "function")
+      throw new TypeError("listen target must be an EventTarget");
+    const s = i;
+    return e.addEventListener(r, s, n), this.onCleanup(() => e.removeEventListener(r, s, n)), this;
+  }
+  registerChild(e) {
+    if (!(e instanceof $))
+      throw new TypeError("registerChild requires a Component");
+    return this._childComponents.add(e), e;
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0, this.mounted = !1;
+      for (const e of [...this.cleanupFunctions]) e();
+      this.cleanupFunctions.clear(), this.watched.clear();
+      for (const e of this.renderReadSubscriptions.values()) e();
+      this.renderReadSubscriptions.clear(), this.collectingRenderReads = null, this._rendered && R(this._rendered, !0), this._rendered = null, this.dom = null, this._childComponents.clear(), this.onDestroy();
+    }
+  }
+  validateRequiredServices() {
+    const e = this.constructor;
+    for (const r of e.requiredServices)
+      if (!this._runtime.services.has(r))
+        throw new Error(`${e.name} requires unregistered service "${r.name}"`);
+  }
+  validateIslandAncestry(e) {
+    if (!ke(e)) return;
+    if (this.hasIslandDescendant())
+      throw new Error("An island component cannot contain another island");
+    let r = this._parentComponent;
+    for (; r != null; ) {
+      if (ke(r.props))
+        throw new Error("An island component cannot be nested inside another island");
+      r = r._parentComponent;
+    }
+  }
+  hasIslandDescendant() {
+    for (const e of this._childComponents)
+      if (ke(e.props) || e.hasIslandDescendant()) return !0;
+    return !1;
+  }
+  onDestroy() {
+  }
+  trackRenderRead(e) {
+    if (wt(e, "Component.read"), this.collectingRenderReads == null)
+      throw new Error("Component.read() and snapshot() may only be called during render()");
+    this.collectingRenderReads.add(e);
+  }
+  reconcileRenderReads(e) {
+    for (const [r, i] of this.renderReadSubscriptions)
+      e.has(r) || (i(), this.renderReadSubscriptions.delete(r));
+    for (const r of e) {
+      if (this.watched.has(r) || this.renderReadSubscriptions.has(r)) continue;
+      const i = r.subscribe(({ event: n }) => {
+        this.mounted && !this.destroyed && this.update(n);
+      }, { emitCurrent: !1 });
+      this.renderReadSubscriptions.set(r, i);
+    }
+  }
+};
+c($, "dependencies", []), c($, "requiredServices", []), /** Component `live()` bindings are opt-in; subclasses declare their allowlist. */
+c($, "liveProps", []), c($, "css", pr`
+        .cap-fill-horizontal,
+        .cap-fill-vertical {
+            box-sizing: border-box;
+            background: var(--application-background);
+            color: var(--ui-color);
+            font-family: var(--font-family);
+            font-size: var(--font-size);
+            line-height: var(--line-height);
+        }
+
+        .cap-fill-horizontal {
+            width: 100vw;
+            max-width: 100vw;
+            min-width: 0;
+            overflow-x: auto;
+        }
+
+        .cap-fill-vertical {
+            height: 100vh;
+            max-height: 100vh;
+            min-height: 0;
+            overflow-y: auto;
+        }
+
+        .cap-layout-horizontal,
+        .cap-layout-vertical {
+            display: flex;
+            align-items: stretch;
+            min-inline-size: 0;
+            min-block-size: 0;
+        }
+
+        .cap-layout-horizontal {
+            flex-direction: row;
+        }
+
+        .cap-layout-vertical {
+            flex-direction: column;
+        }
+
+        .cap-size-natural {
+            flex: 0 0 auto;
+        }
+
+        .cap-size-flexible {
+            flex: 1 1 0;
+            min-inline-size: 0;
+            min-block-size: 0;
+        }
+
+        .cap-scroll {
+            overflow: auto;
+            min-inline-size: 0;
+            min-block-size: 0;
+        }
+
+        .colored {
+            --colored-base-bg:
+                    linear-gradient(
+                            15deg,
+                            var(--c1) 0%,
+                            var(--c2) 65%,
+                            var(--c2) 65%,
+                            var(--c3) 100%
+                    );
+
+            background: var(--colored-base-bg);
+            box-shadow: var(--colored-shadow);
+            border-radius: var(--ui-border-radius);
+        }
+
+        .app-footer.island,
+        .island {
+            box-sizing: border-box;
+            min-width: 0;
+            min-height: 0;
+            margin: var(--island-margin);
+            padding: var(--island-padding);
+            background: var(--island-background);
+            border: var(--island-border);
+            border-radius: var(--island-radius);
+            box-shadow: var(--island-shadow);
+        }
+
+        .cap-fill-horizontal.island,
+        .cap-fill-horizontal .island {
+            max-width: calc(100% - (2 * var(--island-margin)));
+            overflow-x: auto;
+        }
+
+        .cap-fill-vertical.island,
+        .cap-fill-vertical .island {
+            max-height: calc(100% - (2 * var(--island-margin)));
+            overflow-y: auto;
+        }
+
+        label[data-cap] {
+            user-select: none;
+        }
+    `), c($, "hostName", null);
+let C = $;
+function H(t) {
+  return Array.isArray(t) ? ce(le, null, t) : t == null || typeof t == "boolean" ? ce(le) : t;
+}
+function ut(t) {
+  const e = [], r = (i) => {
+    if (Array.isArray(i))
+      for (const n of i) r(n);
+    else i != null && typeof i != "boolean" && e.push(i);
+  };
+  return r(t), e;
+}
+function Y(t, e) {
+  if (typeof t == "string" || typeof t == "number")
+    return {
+      kind: "text",
+      key: null,
+      value: t,
+      node: document.createTextNode(String(t)),
+      owner: e
+    };
+  if (fe(t)) {
+    const s = document.createComment("cap-emitter-start"), o = document.createComment("cap-emitter-end"), a = t.get();
+    if (Object.is(a, t))
+      throw new TypeError("A Capillary UI emitter child cannot render itself");
+    const l = document.createDocumentFragment();
+    l.append(s, o);
+    const u = Y(H(a), e);
+    je(l, u, o);
+    const h = {
+      kind: "emitter",
+      key: null,
+      source: t,
+      start: s,
+      end: o,
+      child: u,
+      unsubscribe: () => {
+      },
+      owner: e
+    };
+    return h.unsubscribe = t.subscribe(({ value: p }) => {
+      if (Object.is(p, t))
+        throw new TypeError("A Capillary UI emitter child cannot render itself");
+      h.child = Re(h.child, H(p), e);
+    }, { emitCurrent: !1 }), h;
+  }
+  if (t instanceof C)
+    return t._setRuntime(e._runtime), t._setRouteContext(e._routeContextForChildren()), t._setParentComponent(e), t.mount(), e.registerChild(t), {
+      kind: "component",
+      key: yt(t.props),
+      type: t.constructor,
+      instance: t,
+      prebuilt: !0,
+      props: t.props,
+      liveProps: /* @__PURE__ */ new Map(),
+      owner: e
+    };
+  if (!T(t))
+    throw new TypeError(`Invalid Capillary UI child: ${Ve(t)}`);
+  const { type: r, key: i = null, props: n } = t;
+  if (r === le) {
+    const s = document.createComment("cap-fragment-start"), o = document.createComment("cap-fragment-end"), a = {
+      kind: "fragment",
+      key: i,
+      type: r,
+      start: s,
+      end: o,
+      children: [],
+      owner: e
+    }, l = document.createDocumentFragment();
+    return l.append(s, o), a.children = ue(
+      l,
+      [],
+      n.children,
+      e,
+      o,
+      s
+    ), a;
+  }
+  if (typeof r == "string") {
+    const s = document.createElement(r), o = {
+      kind: "element",
+      key: i,
+      type: r,
+      node: s,
+      props: {},
+      listeners: /* @__PURE__ */ new Map(),
+      liveProps: /* @__PURE__ */ new Map(),
+      nativeBindings: /* @__PURE__ */ new Map(),
+      ref: null,
+      children: [],
+      owner: e
+    };
+    return ft(o, n), o.children = ue(s, [], n.children, e), o;
+  }
+  if (bt(r)) {
+    const s = n;
+    pt(r, s);
+    const o = Ue(s), a = new r(o);
+    a._setRuntime(e._runtime), a._setRouteContext(e._routeContextForChildren()), a._setParentComponent(e);
+    const l = {
+      kind: "component",
+      key: i,
+      type: r,
+      instance: a,
+      prebuilt: !1,
+      props: o,
+      liveProps: /* @__PURE__ */ new Map(),
+      owner: e
+    };
+    return dt(l, s), a.mount(), e.registerChild(a), l;
+  }
+  if (typeof r == "function") {
+    const s = r, o = n, a = Ue(o), l = H(s(a)), u = {
+      kind: "function",
+      key: i,
+      type: s,
+      props: a,
+      sourceProps: o,
+      liveProps: /* @__PURE__ */ new Map(),
+      child: Y(l, e),
+      owner: e
+    };
+    return mr(u), u;
+  }
+  throw new TypeError(`Unsupported vnode type: ${Ve(r)}`);
+}
+function Re(t, e, r) {
+  if (t == null) return Y(e, r);
+  if (gt(t, e)) return ht(t, e, r);
+  const i = Y(e, r), n = mt(t), s = (n == null ? void 0 : n.parentNode) ?? null;
+  return s && je(s, i, n), R(t, !0), i;
+}
+function ht(t, e, r) {
+  return t.kind === "text" ? (typeof e != "string" && typeof e != "number" || Object.is(t.value, e) || (t.value = e, t.node.data = String(e)), t) : t.kind === "emitter" ? (!fe(e) || t.source !== e, t) : t.kind === "component" ? (e instanceof C || T(e) && fr(t, e.props), t) : T(e) ? t.kind === "function" ? (yr(t, e.props), t) : t.kind === "fragment" ? (t.children = ue(
+    t.start.parentNode,
+    t.children,
+    e.props.children,
+    r,
+    t.end,
+    t.start
+  ), t) : (ft(t, e.props), t.children = ue(
+    t.node,
+    t.children,
+    e.props.children,
+    r
+  ), t) : t;
+}
+function Ue(t) {
+  return Object.fromEntries(Object.entries(t).map(([e, r]) => [
+    e,
+    N(r) ? r.emitter.get() : r
+  ]));
+}
+function dt(t, e) {
+  Ae(t.liveProps, e, (r, i) => {
+    t.props = { ...t.props, [r]: i }, t.instance.setProps(t.props);
+  }), t.props = Oe(t.liveProps, e), t.instance.setProps(t.props);
+}
+function fr(t, e) {
+  pt(t.type, e), dt(t, e);
+}
+function pt(t, e) {
+  const r = Reflect.get(t, "liveProps");
+  if (r == null) return;
+  if (!Array.isArray(r) || r.some((n) => typeof n != "string"))
+    throw new TypeError(`${t.name || "Component"}.liveProps must be an array`);
+  const i = new Set(r);
+  for (const [n, s] of Object.entries(e))
+    if (N(s) && !i.has(n))
+      throw new TypeError(
+        `${t.name || "Component"} prop "${n}" does not support live()`
+      );
+}
+function mr(t) {
+  Ae(t.liveProps, t.sourceProps, (e, r) => {
+    t.props = { ...t.props, [e]: r }, $e(t);
+  }), t.props = Oe(t.liveProps, t.sourceProps);
+}
+function yr(t, e) {
+  t.sourceProps = e, Ae(t.liveProps, e, (r, i) => {
+    t.props = { ...t.props, [r]: i }, $e(t);
+  }), t.props = Oe(t.liveProps, e), $e(t);
+}
+function $e(t) {
+  const e = H(t.type(t.props));
+  t.child = Re(t.child, e, t.owner);
+}
+function Ae(t, e, r) {
+  for (const [i, n] of t) {
+    const s = e[i];
+    N(s) && s.emitter === n.source || (n.unsubscribe(), t.delete(i));
+  }
+  for (const [i, n] of Object.entries(e)) {
+    if (!N(n) || t.has(i)) continue;
+    const s = {
+      source: n.emitter,
+      value: n.emitter.get(),
+      unsubscribe: () => {
+      }
+    };
+    s.unsubscribe = n.emitter.subscribe(({ value: o }) => {
+      t.get(i) === s && (s.value = o, r(i, o));
+    }, { emitCurrent: !1 }), t.set(i, s);
+  }
+}
+function Oe(t, e) {
+  return Object.fromEntries(Object.entries(e).map(([r, i]) => {
+    var n;
+    return [
+      r,
+      N(i) ? ((n = t.get(r)) == null ? void 0 : n.value) ?? i.emitter.get() : i
+    ];
+  }));
+}
+function ue(t, e, r, i, n = null, s = null) {
+  if (t == null) throw new Error("Cannot patch a detached fragment range");
+  const o = ut(r), a = /* @__PURE__ */ new Map(), l = [];
+  for (const g of e)
+    g.key == null ? l.push(g) : a.has(g.key) || a.set(g.key, g);
+  const u = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), p = [];
+  let b = 0;
+  for (const g of o) {
+    const f = U(g);
+    if (f != null) {
+      if (u.has(f)) throw new Error(`Duplicate sibling key: ${String(f)}`);
+      u.add(f);
+    }
+    const E = f == null ? l[b++] : a.get(f);
+    E && gt(E, g) ? (h.add(E), p.push(ht(E, g, i))) : p.push(Y(g, i));
+  }
+  for (const g of e)
+    h.has(g) || R(g, !0);
+  let y = s ? s.nextSibling : t.firstChild;
+  for (const g of p)
+    for (const f of O(g))
+      f === y ? y = y.nextSibling : (t.insertBefore(f, y ?? n), y = f.nextSibling);
+  return p;
+}
+function ft(t, e) {
+  const r = Object.fromEntries(Object.entries(e).filter(
+    ([s]) => s !== "children" && se(s) !== _e
+  )), i = t.props, n = /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(r)]);
+  for (const s of ["value", "checked"])
+    if (Object.hasOwn(r, s) && Object.hasOwn(r, `bind:${s}`))
+      throw new Error(`${s} and bind:${s} cannot be used together`);
+  for (const s of n) {
+    const o = i[s], a = r[s];
+    if (Cr(s))
+      br(t, s, a);
+    else if (s === "ref")
+      o !== a && vr(t, a);
+    else if ($r(s))
+      wr(t, s, a);
+    else if (N(a))
+      gr(t, s, a);
+    else {
+      const l = t.liveProps.get(s);
+      l && (l.unsubscribe(), t.liveProps.delete(s));
+      const u = (l == null ? void 0 : l.value) ?? o;
+      Object.is(u, a) || M(t.node, s, u, a);
+    }
+  }
+  t.node.setAttribute(_e, ""), t.props = { ...r };
+}
+function gr(t, e, r) {
+  const i = t.liveProps.get(e);
+  if ((i == null ? void 0 : i.source) === r.emitter) return;
+  i == null || i.unsubscribe();
+  const n = r.emitter.get();
+  M(t.node, e, (i == null ? void 0 : i.value) ?? t.props[e], n);
+  const s = {
+    source: r.emitter,
+    value: n,
+    unsubscribe: () => {
+    }
+  };
+  s.unsubscribe = r.emitter.subscribe(({ value: o }) => {
+    const a = s.value;
+    s.value = o, Object.is(a, o) || M(t.node, e, a, o);
+  }, { emitCurrent: !1 }), t.liveProps.set(e, s);
+}
+function br(t, e, r) {
+  const i = e.slice(5), n = t.nativeBindings.get(e);
+  if (r == null) {
+    n && (n.unsubscribe(), t.node.removeEventListener(n.eventName, n.listener), t.nativeBindings.delete(e), M(t.node, i, n.value, void 0));
+    return;
+  }
+  if (xr(r, e), (n == null ? void 0 : n.source) === r) return;
+  n && (n.unsubscribe(), t.node.removeEventListener(n.eventName, n.listener)), Tr(t.node, i);
+  const s = zr(t.node, i), o = r.get();
+  M(t.node, i, n == null ? void 0 : n.value, o);
+  const a = () => {
+    r.set(Reflect.get(t.node, i), `${e} changed`);
+  }, l = {
+    source: r,
+    value: o,
+    eventName: s,
+    listener: a,
+    unsubscribe: () => {
+    }
+  };
+  l.unsubscribe = r.subscribe(({ value: u }) => {
+    const h = l.value;
+    l.value = u, Object.is(h, u) || M(t.node, i, h, u);
+  }, { emitCurrent: !1 }), t.node.addEventListener(s, a), t.nativeBindings.set(e, l);
+}
+function wr(t, e, r) {
+  const i = e.slice(2).toLowerCase(), n = t.listeners.get(e);
+  if (n && n !== r && (t.node.removeEventListener(i, n), t.listeners.delete(e)), r != null && typeof r != "function")
+    throw new TypeError(`${e} must be a function or null`);
+  if (typeof r == "function" && n !== r) {
+    const s = r;
+    t.node.addEventListener(i, s), t.listeners.set(e, s);
+  }
+}
+function vr(t, e) {
+  if (Ce(t.ref, null), e != null && typeof e != "function" && typeof e != "object")
+    throw new TypeError("ref must be a function, object, or null");
+  t.ref = e, Ce(t.ref, t.node);
+}
+function M(t, e, r, i) {
+  if (e === "class" || e === "className") {
+    ve(t, "class", i);
+    return;
+  }
+  if (e === "for" || e === "htmlFor") {
+    ve(t, "for", i);
+    return;
+  }
+  if (e === "dataset") {
+    kr(t, r, i);
+    return;
+  }
+  if (e === "style") {
+    Sr(t, r, i);
+    return;
+  }
+  if (e === "dangerouslySetInnerHTML")
+    throw new Error("dangerouslySetInnerHTML is not supported");
+  const n = Er(e);
+  if (hr.has(n)) {
+    const s = !!i;
+    n in t && Reflect.set(t, n, s), t.toggleAttribute(se(e), s);
+    return;
+  }
+  if (dr.has(n) && n in t) {
+    const s = i ?? (n === "value" ? "" : !1);
+    Object.is(Reflect.get(t, n), s) || Reflect.set(t, n, s), i == null && t.removeAttribute(se(e));
+    return;
+  }
+  ve(t, se(e), i);
+}
+function kr(t, e, r) {
+  const i = he(e, "dataset"), n = he(r, "dataset");
+  for (const s of /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(n)])) {
+    const o = n[s];
+    o == null ? delete t.dataset[s] : t.dataset[s] = String(o);
+  }
+}
+function Sr(t, e, r) {
+  if (typeof r == "string") {
+    t.style.cssText = r;
+    return;
+  }
+  const i = typeof e == "string" ? {} : he(e, "style"), n = he(r, "style");
+  typeof e == "string" && (t.style.cssText = "");
+  for (const s of /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(n)])) {
+    const o = n[s];
+    s.startsWith("--") ? o == null ? t.style.removeProperty(s) : t.style.setProperty(s, String(o)) : Reflect.set(t.style, s, o == null ? "" : String(o));
+  }
+}
+function he(t, e) {
+  if (t == null) return {};
+  if (typeof t != "object" || Array.isArray(t))
+    throw new TypeError(`${e} must be an object or null`);
+  return t;
+}
+function ve(t, e, r) {
+  r == null || r === !1 ? t.removeAttribute(e) : r === !0 ? t.setAttribute(e, "") : t.setAttribute(e, String(r));
+}
+function Er(t) {
+  return t === "readonly" ? "readOnly" : t === "autofocus" ? "autoFocus" : t;
+}
+function se(t) {
+  return t === "className" ? "class" : t === "htmlFor" ? "for" : t === "minLength" ? "minlength" : t === "maxLength" ? "maxlength" : t === "autoComplete" ? "autocomplete" : t === "inputMode" ? "inputmode" : /^aria[A-Z]/.test(t) || /^data[A-Z]/.test(t) ? He(t) : t.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`);
+}
+function He(t) {
+  return t.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`);
+}
+function Ce(t, e) {
+  t != null && (typeof t == "function" ? t(e) : t.current = e);
+}
+function R(t, e) {
+  if (t.kind === "emitter") {
+    if (t.unsubscribe(), R(t.child, !1), e)
+      for (const r of O(t)) r.remove();
+    return;
+  }
+  if (t.kind === "component") {
+    for (const r of t.liveProps.values()) r.unsubscribe();
+    t.liveProps.clear(), t.owner._childComponents.delete(t.instance), t.instance.destroy();
+    return;
+  }
+  if (t.kind === "function") {
+    for (const r of t.liveProps.values()) r.unsubscribe();
+    t.liveProps.clear(), R(t.child, e);
+    return;
+  }
+  if (t.kind === "element") {
+    Ce(t.ref, null);
+    for (const [r, i] of t.listeners)
+      t.node.removeEventListener(r.slice(2).toLowerCase(), i);
+    t.listeners.clear();
+    for (const r of t.liveProps.values()) r.unsubscribe();
+    t.liveProps.clear();
+    for (const r of t.nativeBindings.values())
+      r.unsubscribe(), t.node.removeEventListener(r.eventName, r.listener);
+    t.nativeBindings.clear();
+    for (const r of t.children) R(r, !1);
+    e && t.node.remove();
+    return;
+  }
+  if (t.kind === "fragment") {
+    for (const r of t.children) R(r, !1);
+    if (e)
+      for (const r of O(t)) r.remove();
+    return;
+  }
+  e && t.node.remove();
+}
+function je(t, e, r = null) {
+  if (e != null)
+    for (const i of O(e)) t.insertBefore(i, r);
+}
+function O(t) {
+  if (t == null) return [];
+  if (t.kind === "text" || t.kind === "element") return [t.node];
+  if (t.kind === "component") return O(t.instance._rendered);
+  if (t.kind === "function") return O(t.child);
+  const e = [];
+  let r = t.start;
+  for (; r && (e.push(r), r !== t.end); )
+    r = r.nextSibling;
+  return e;
+}
+function mt(t) {
+  return O(t)[0] ?? null;
+}
+function U(t) {
+  return t instanceof C ? yt(t.props) : T(t) ? t.key : null;
+}
+function yt(t) {
+  const e = t.key;
+  return typeof e == "string" || typeof e == "number" ? e : null;
+}
+function gt(t, e) {
+  return t.kind === "text" ? typeof e == "string" || typeof e == "number" : t.kind === "emitter" ? fe(e) && t.source === e : t.kind === "component" ? e instanceof C ? t.instance === e : T(e) && bt(e.type) && t.type === e.type && t.key === U(e) : t.kind === "function" ? T(e) && t.type === e.type && t.key === U(e) : t.kind === "fragment" ? T(e) && e.type === le && t.key === U(e) : T(e) && typeof e.type == "string" && t.type === e.type && t.key === U(e);
+}
+function T(t) {
+  return t != null && typeof t == "object" && Object.hasOwn(t, "type");
+}
+function bt(t) {
+  return typeof t == "function" && (t === C || t.prototype instanceof C);
+}
+function $r(t) {
+  return /^on[A-Z]/.test(t);
+}
+function Cr(t) {
+  return t === "bind:value" || t === "bind:checked";
+}
+function N(t) {
+  return t != null && typeof t == "object" && ur.has(t);
+}
+function fe(t) {
+  return (typeof t != "object" || t == null) && typeof t != "function" ? !1 : typeof Reflect.get(t, "get") == "function" && typeof Reflect.get(t, "getFetchState") == "function" && typeof Reflect.get(t, "getError") == "function" && typeof Reflect.get(t, "subscribe") == "function";
+}
+function wt(t, e) {
+  if (!fe(t)) throw new TypeError(`${e} requires a readable emitter`);
+}
+function xr(t, e) {
+  if (wt(t, e), typeof Reflect.get(t, "set") != "function")
+    throw new TypeError(`${e} requires a writable emitter`);
+}
+function Tr(t, e) {
+  const r = t.localName;
+  if (!(e === "checked" ? r === "input" : r === "input" || r === "textarea" || r === "select")) throw new TypeError(`bind:${e} is not supported on ${r}`);
+}
+function zr(t, e) {
+  return e === "value" && t.localName !== "select" ? "input" : "change";
+}
+function Rr(t) {
+  if (t == null || typeof t != "object" && typeof t != "function" || typeof Reflect.get(t, "insertBefore") != "function")
+    throw new TypeError("Component parent must be a DOM ParentNode");
+}
+function Ve(t) {
+  try {
+    return String(t);
+  } catch {
+    return Object.prototype.toString.call(t);
+  }
+}
+function Ar(t) {
+  const e = [];
+  let r = t;
+  for (; r != null && typeof r == "function" && (e.unshift(r), r !== C); )
+    r = Object.getPrototypeOf(r);
+  return e;
+}
+function Or(...t) {
+  return [...new Set(t.flatMap((e) => typeof e == "string" ? e.split(/\s+/) : []).filter(Boolean))].join(" ");
+}
+function ke(t) {
+  if (t.island === !0) return !0;
+  const e = t.className ?? t.class;
+  return typeof e == "string" && e.split(/\s+/).includes("island");
+}
+function d(t, e, r) {
+  const i = e == null ? {} : { ...e };
+  return r !== void 0 && (i.key = r), ce(t, i);
+}
+const m = d, jr = [
+  "var(--colored-dark)",
+  "var(--colored-base)",
+  "var(--colored-light)"
+];
+class ee extends Te {
+  render() {
+    var b;
+    const {
+      model: e,
+      label: r = "Block graph",
+      description: i = "Area is proportional to item count.",
+      emptyMessage: n = "No items are available."
+    } = this.props, s = this.snapshot(e.layout$), o = this.read(e.selectedPath$), a = s.value, l = D(a.root, o), u = a.root.children.length === 0 ? [a.root] : a.root.children, h = (b = u[0]) == null ? void 0 : b.key, p = this.Host;
+    return /* @__PURE__ */ m(
+      p,
+      {
+        className: (this.props.className ?? this.props.class ?? "") || null,
+        "aria-label": r,
+        "aria-busy": s.fetchState !== k.Ready ? "true" : null,
+        children: [
+          /* @__PURE__ */ m("header", { children: [
+            /* @__PURE__ */ m("cap-summary", { children: [
+              /* @__PURE__ */ d("h2", { children: r }),
+              /* @__PURE__ */ m("p", { children: [
+                i,
+                " ",
+                a.root.count,
+                " items."
+              ] }),
+              /* @__PURE__ */ m("output", { children: [
+                /* @__PURE__ */ d("strong", { children: "Selection:" }),
+                " ",
+                l == null ? "None" : l.path.length === 0 ? l.label : l.path.map((y, g) => {
+                  var E;
+                  const f = l.path.slice(0, g + 1);
+                  return ((E = D(a.root, f)) == null ? void 0 : E.label) ?? y.categoryKey;
+                }).join(" → ")
+              ] })
+            ] }),
+            /* @__PURE__ */ d(
+              oe,
+              {
+                label: "Clear selection",
+                disabled: o == null,
+                onClick: () => e.clear()
+              }
+            )
+          ] }),
+          s.fetchState === k.Error ? /* @__PURE__ */ d("p", { role: "alert", children: "The block graph could not be calculated." }) : s.fetchState !== k.Ready ? /* @__PURE__ */ d("p", { role: "status", "aria-live": "polite", children: "Loading block graph…" }) : a.valid ? a.root.count === 0 ? /* @__PURE__ */ d("p", { role: "status", children: n }) : /* @__PURE__ */ d(
+            "cap-scroller",
+            {
+              tabIndex: 0,
+              "aria-label": `Scrollable ${r}`,
+              children: /* @__PURE__ */ d(
+                "cap-blocks",
+                {
+                  role: "tree",
+                  "aria-label": r,
+                  className: a.root.childOrientation,
+                  onClick: (y) => {
+                    y.target === y.currentTarget && e.clear();
+                  },
+                  children: u.map((y) => this.renderBlock(
+                    y,
+                    o,
+                    (l == null ? void 0 : l.key) ?? h ?? null
+                  ))
+                }
+              )
+            }
+          ) : this.renderPartitionError(a.issues)
+        ]
+      }
+    );
+  }
+  renderBlock(e, r, i) {
+    const n = Lr(e.path, r), s = e.colors, o = Xe(s ?? jr);
+    return /* @__PURE__ */ m(
+      "article",
+      {
+        role: "treeitem",
+        className: "colored",
+        tabIndex: n || r == null && e.key === i ? 0 : -1,
+        "aria-level": Math.max(1, e.depth + 1),
+        "aria-selected": n ? "true" : "false",
+        "aria-label": `${e.criterionLabel ?? "Items"}: ${e.label}, ${e.count} ${e.count === 1 ? "item" : "items"}`,
+        "data-block-key": e.key,
+        onClick: (a) => {
+          a.target.closest('[role="treeitem"]') === a.currentTarget && this.props.model.select(e.path);
+        },
+        onKeyDown: (a) => this.blockKeyDown(a, e),
+        style: {
+          flexGrow: e.count,
+          ...o,
+          ...s == null ? {} : {
+            borderColor: s[0]
+          }
+        },
+        children: [
+          /* @__PURE__ */ m("cap-blocklabel", { children: [
+            /* @__PURE__ */ m("cap-blockname", { children: [
+              /* @__PURE__ */ m("small", { children: [
+                e.criterionLabel ?? "Items",
+                ":"
+              ] }),
+              /* @__PURE__ */ d("strong", { children: e.label })
+            ] }),
+            /* @__PURE__ */ d("data", { value: String(e.count), children: e.count })
+          ] }),
+          e.children.length === 0 ? null : /* @__PURE__ */ d(
+            "cap-blockgroup",
+            {
+              role: "group",
+              className: e.childOrientation,
+              children: e.children.map((a) => this.renderBlock(
+                a,
+                r,
+                i
+              ))
+            }
+          )
+        ]
+      },
+      e.key
+    );
+  }
+  renderPartitionError(e) {
+    const r = e[0], i = r == null ? "The selected criteria do not form a complete partition." : r.kind === "unmatched" ? `${r.criterionLabel} has an item with no category.` : `${r.criterionLabel} has an item matching multiple categories.`;
+    return /* @__PURE__ */ m("div", { role: "alert", children: [
+      /* @__PURE__ */ d("strong", { children: "Invalid block partition" }),
+      /* @__PURE__ */ m("p", { children: [
+        i,
+        " ",
+        e.length,
+        " partition issue",
+        e.length === 1 ? "" : "s",
+        " detected."
+      ] })
+    ] });
+  }
+  blockKeyDown(e, r) {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault(), this.props.model.select(r.path, "block selected by keyboard");
+      return;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault(), this.props.model.clear("block selection cleared by keyboard");
+      return;
+    }
+    const i = this.props.model.layout$.get().root, n = vt(i.children.length === 0 ? [i] : i.children), s = n.findIndex(({ key: a }) => a === r.key);
+    let o;
+    if (e.key === "ArrowDown") o = n[s + 1];
+    else if (e.key === "ArrowUp") o = n[s - 1];
+    else if (e.key === "Home") o = n[0];
+    else if (e.key === "End") o = n.at(-1);
+    else if (e.key === "ArrowRight") o = r.children[0] ?? n[s + 1];
+    else if (e.key === "ArrowLeft")
+      o = r.path.length <= 1 ? n[s - 1] : D(i, r.path.slice(0, -1)) ?? void 0;
+    else return;
+    o != null && (e.preventDefault(), this.focusBlock(o.key));
+  }
+  focusBlock(e) {
+    if (this.dom instanceof Element) {
+      for (const r of this.dom.querySelectorAll('[role="treeitem"]'))
+        if (r.dataset.blockKey === e) {
+          r.focus();
+          return;
+        }
+    }
+  }
+}
+c(ee, "liveProps", []), c(ee, "hostName", "block-graph"), c(ee, "dependencies", [oe]), c(ee, "css", G`
+        & {
+            display: flex;
+            min-width: 0;
+            min-height: var(--viz-block-graph-min-height, 24rem);
+            flex-direction: column;
+            padding: var(--viz-space, 0.7rem);
+            overflow: hidden;
+            user-select: none;
+        }
+
+        & > header {
+            display: flex;
+            flex: 0 0 auto;
+            flex-wrap: wrap;
+            justify-content: space-between;
+            gap: 0.5rem;
+            margin-block-end: 0.6rem;
+        }
+
+        & h2,
+        & p {
+            margin: 0;
+        }
+
+        & header output {
+            display: block;
+            margin-block-start: 0.25rem;
+        }
+
+        & > cap-scroller {
+            flex: 1;
+            min-width: 0;
+            min-height: 20rem;
+            overflow: auto;
+        }
+
+        & cap-blocks,
+        & cap-blockgroup {
+            display: flex;
+            min-width: 0;
+            min-height: 0;
+            align-items: stretch;
+        }
+
+        & cap-blocks {
+            width: 100%;
+            min-width: 34rem;
+            height: 100%;
+            min-height: 24rem;
+        }
+
+        & .horizontal {
+            flex-direction: row;
+        }
+
+        & .vertical {
+            flex-direction: column;
+        }
+
+        & [role="treeitem"] {
+            position: relative;
+            display: flex;
+            min-width: 0;
+            min-height: 0;
+            flex-basis: 0;
+            flex-direction: column;
+            overflow: hidden;
+            border: var(--block-graph-block-border, 1px solid var(--c1, var(--colored-dark)));
+            border-radius: var(--block-graph-block-radius, 0.25em);
+            box-shadow: var(--block-graph-block-shadow, none);
+            color: var(--colored-contrast);
+        }
+
+        & [role="treeitem"] > cap-blocklabel {
+            position: absolute;
+            z-index: 1;
+            inset-block-start: 0;
+            inset-inline-start: 0;
+            box-sizing: border-box;
+            display: grid;
+            grid-template-columns: minmax(0, 1fr) auto;
+            grid-template-areas: "label count";
+            align-items: center;
+            gap: 0 0.35rem;
+            width: 100%;
+            padding: 0.25rem 0.4rem;
+            overflow: hidden;
+            text-align: start;
+            border: 0;
+            cursor: pointer;
+        }
+
+        & [role="treeitem"][aria-selected="true"] {
+            z-index: 3;
+            outline: 3px solid var(--viz-selection-color, var(--colored-contrast, Highlight));
+            outline-offset: -3px;
+        }
+
+        & [role="treeitem"]:focus-visible {
+            z-index: 2;
+            outline: 3px solid var(--viz-focus-color, Highlight);
+            outline-offset: -3px;
+        }
+
+        & cap-blocklabel > cap-blockname {
+            grid-area: label;
+            display: grid;
+            grid-template-columns: auto minmax(0, 1fr);
+            align-items: baseline;
+            gap: 0.2rem;
+            min-width: 0;
+            overflow: hidden;
+            white-space: nowrap;
+        }
+
+        & cap-blockname > small {
+            overflow: hidden;
+            font-size: 0.68rem;
+            opacity: 0.82;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        & cap-blockname > strong {
+            min-width: 0;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        & cap-blocklabel > data {
+            grid-area: count;
+            align-self: center;
+            font-weight: 750;
+        }
+
+        & cap-blockgroup {
+            position: relative;
+            z-index: 1;
+            box-sizing: border-box;
+            flex: 1;
+            padding: var(--viz-block-graph-child-inset, 1.6em);
+        }
+
+        & [role="treeitem"]:hover:not(:has([role="treeitem"]:hover)) {
+            filter: saturate(1.35) brightness(1.15);
+        }
+
+        @media (forced-colors: active) {
+            & [role="treeitem"] {
+                color: CanvasText;
+                background: Canvas;
+                border-color: CanvasText;
+                forced-color-adjust: auto;
+            }
+
+            & [role="treeitem"] > cap-blocklabel {
+                color: ButtonText;
+                background: ButtonFace;
+            }
+        }
+    `);
+function vt(t) {
+  return t.flatMap((e) => [e, ...vt(e.children)]);
+}
+function Lr(t, e) {
+  return e != null && t.length === e.length && t.every((r, i) => {
+    var n, s;
+    return r.criterionKey === ((n = e[i]) == null ? void 0 : n.criterionKey) && r.categoryKey === ((s = e[i]) == null ? void 0 : s.categoryKey);
+  });
+}
+class de extends At {
+  constructor(r) {
+    super(r);
+    c(this, "contentId");
+    c(this, "collapsed");
+    this.collapsed = r.collapsed ?? !1, this.contentId = `${this.groupId}-content`;
+  }
+  render() {
+    if (this.props.headerEnd != null)
+      throw new Error(
+        "CollapsibleOptionGroup trailing header content must use a direct OptionGroupHeaderEnd child"
+      );
+    const { content: r, regions: i } = Ot(
+      "CollapsibleOptionGroup",
+      this.props.children,
+      { headerEnd: jt }
+    );
+    return this.renderOptionGroup(r, i.headerEnd ?? null);
+  }
+  toggle() {
+    this.collapsed = !this.collapsed, this.update();
+  }
+  renderOptionGroup(r, i) {
+    const n = this.Host, {
+      label: s,
+      ariaLabel: o,
+      disabled: a = !1,
+      required: l = !1,
+      busy: u = !1,
+      error: h = null
+    } = this.props;
+    return /* @__PURE__ */ m(n, { className: this.props.className ?? this.props.class ?? null, children: [
+      /* @__PURE__ */ m(
+        "fieldset",
+        {
+          id: this.groupId,
+          disabled: a,
+          "aria-label": s == null ? o : null,
+          "aria-required": l ? "true" : null,
+          "aria-busy": u ? "true" : null,
+          "aria-invalid": h == null ? null : "true",
+          "aria-describedby": h == null ? null : this.errorId,
+          children: [
+            /* @__PURE__ */ m("legend", { children: [
+              /* @__PURE__ */ d(
+                "button",
+                {
+                  type: "button",
+                  className: "cap-collapse-toggle",
+                  "aria-expanded": !this.collapsed,
+                  "aria-controls": this.contentId,
+                  onClick: () => this.toggle(),
+                  children: this.collapsed ? "▸" : "▾"
+                }
+              ),
+              s != null ? /* @__PURE__ */ d("span", { children: s }) : null,
+              i
+            ] }),
+            /* @__PURE__ */ d("div", { id: this.contentId, hidden: this.collapsed, children: r })
+          ]
+        }
+      ),
+      this.renderOptionGroupError(h)
+    ] });
+  }
+}
+c(de, "hostName", "collapsible-option-group"), c(de, "css", G`
+        & > fieldset > legend > button.cap-collapse-toggle {
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            width: 1.2em;
+            height: 1.2em;
+            padding: 0;
+            border: 0;
+            border-radius: var(--ui-border-radius);
+            background: transparent;
+            color: inherit;
+            font: inherit;
+            cursor: pointer;
+            flex: 0 0 auto;
+            user-select: none;
+        }
+
+        & > fieldset > legend > button.cap-collapse-toggle:hover {
+            background: var(--button-background-hover, rgba(0, 0, 0, 0.05));
+        }
+
+        & > fieldset > legend > button.cap-collapse-toggle:focus-visible {
+            outline: 2px solid var(--focus-color, var(--ui-accent-color));
+            outline-offset: 1px;
+        }
+
+        & > fieldset > div {
+            display: contents;
+        }
+
+        & > fieldset > div[hidden] {
+            display: none;
+        }
+    `);
+const Dr = [
+  ["☐", "hidden"],
+  ["✓", "visible"]
+];
+class te extends Lt {
+  render() {
+    const {
+      criteria: e,
+      label: r = "Show or hide categories",
+      description: i = ""
+    } = this.props, n = this.snapshot(this.props.items$), s = Array.isArray(n.value) ? n.value : [];
+    return this.renderGroupBox(
+      r,
+      /* @__PURE__ */ m("cap-categoryhidecontent", { children: [
+        /* @__PURE__ */ d("p", { children: i }),
+        n.fetchState === k.Error ? /* @__PURE__ */ d("p", { role: "alert", children: "Category counts are unavailable." }) : null,
+        /* @__PURE__ */ d("cap-criteriongroups", { children: e.map((o) => {
+          const a = this.snapshot(o.categories$), l = Array.isArray(a.value) ? a.value : [];
+          return /* @__PURE__ */ m(
+            de,
+            {
+              label: o.label,
+              children: [
+                a.fetchState === k.Error ? /* @__PURE__ */ m("p", { role: "alert", children: [
+                  o.label,
+                  " categories are unavailable."
+                ] }) : null,
+                a.fetchState !== k.Ready ? /* @__PURE__ */ m("p", { role: "status", "aria-live": "polite", children: [
+                  "Loading ",
+                  o.label,
+                  "…"
+                ] }) : null,
+                /* @__PURE__ */ d("cap-categories", { children: l.map((u) => {
+                  const h = Mr(s, u.predicate);
+                  return /* @__PURE__ */ m(
+                    "cap-categoryoption",
+                    {
+                      style: { ...Xe(u.colors) },
+                      children: [
+                        /* @__PURE__ */ d("cap-categoryswatch", { "aria-hidden": "true" }),
+                        /* @__PURE__ */ d(
+                          ae,
+                          {
+                            symbols: Dr,
+                            label: `${u.label} (${h})`,
+                            valueEmitter: o.visibility(u.key)
+                          }
+                        )
+                      ]
+                    },
+                    u.key
+                  );
+                }) })
+              ]
+            },
+            o.key
+          );
+        }) })
+      ] })
+    );
+  }
+}
+c(te, "liveProps", []), c(te, "hostName", "category-hide-panel"), c(te, "dependencies", [ae, de]), c(te, "css", G`
+        & {
+            flex: 0 0 auto;
+            min-width: 0;
+            user-select: none;
+        }
+
+        & > cap-content > cap-categoryhidecontent {
+            display: grid;
+            align-content: start;
+            gap: var(--viz-space, 0.6rem);
+            min-width: 0;
+        }
+
+        & > cap-content > cap-categoryhidecontent > p {
+            margin: 0;
+            color: var(--viz-muted-color, var(--ui-muted-text-color, currentColor));
+            font-size: 0.875em;
+        }
+
+        & > cap-content > cap-categoryhidecontent > cap-criteriongroups {
+            display: grid;
+            gap: 1em;
+            min-width: 0;
+        }
+
+        & cap-collapsible-option-group > fieldset > legend small {
+            white-space: nowrap;
+        }
+
+        & cap-categories {
+            display: flex;
+            box-sizing: border-box;
+            gap: .31em;
+            min-width: 0;
+            flex-flow: column;
+            padding: 0;
+            overflow: visible;
+        }
+
+        & cap-categoryoption {
+            display: flex;
+            flex-flow: row nowrap;
+            align-items: center;
+            gap: 0.45rem;
+            min-width: 0;
+            max-height: 1em;
+        }
+
+        & cap-categoryswatch {
+            display: block;
+            width: 1rem;
+            height: 1rem;
+            border: 1px solid var(--c1);
+            border-radius: 0.2rem;
+            background: linear-gradient(15deg, var(--c1) 0%, var(--c2) 65%, var(--c2) 65%, var(--c3) 100%);
+        }
+
+        & cap-categoryoption:has(input:not(:checked)) > cap-categoryswatch {
+            opacity: 0.22;
+        }
+
+        & cap-categoryoption > cap-checkbox,
+        & cap-categoryoption > cap-checkbox > label {
+            min-width: 0;
+            width: 100%;
+            height: unset;
+        }
+
+        & cap-categoryoption > cap-checkbox > label {
+            justify-content: flex-start;
+            text-align: start;
+            white-space: nowrap;
+        }
+    `);
+function Mr(t, e) {
+  let r = 0;
+  for (const i of t)
+    e(i) && (r += 1);
+  return r;
+}
+const kt = 864e5, Pr = /^(\d{4})-(\d{2})-(\d{2})$/;
+function S(t) {
+  const e = Pr.exec(t);
+  if (e == null) throw new TypeError(`Invalid civil date "${t}"; expected YYYY-MM-DD`);
+  const r = Number(e[1]), i = Number(e[2]), n = Number(e[3]), s = Date.UTC(r, i - 1, n), o = new Date(s);
+  if (o.getUTCFullYear() !== r || o.getUTCMonth() !== i - 1 || o.getUTCDate() !== n)
+    throw new TypeError(`Invalid civil date "${t}"`);
+  return Math.floor(s / kt);
+}
+function K(t) {
+  if (!Number.isInteger(t)) throw new TypeError("Civil day must be an integer");
+  return new Date(t * kt).toISOString().slice(0, 10);
+}
+function Nr(t, e) {
+  if (!Number.isInteger(e)) throw new TypeError("Civil date offset must be an integer");
+  return K(S(t) + e);
+}
+function Kr(t = /* @__PURE__ */ new Date()) {
+  if (!(t instanceof Date) || Number.isNaN(t.getTime()))
+    throw new TypeError("todayCivilDate requires a valid Date");
+  return `${String(t.getUTCFullYear()).padStart(4, "0")}-${String(
+    t.getUTCMonth() + 1
+  ).padStart(2, "0")}-${String(t.getUTCDate()).padStart(2, "0")}`;
+}
+function Ir(t, e) {
+  return S(t) - S(e);
+}
+function Br(t, e = {}) {
+  var Me, Pe, Ne, Ke;
+  Vr(t);
+  const r = Ye(e.width ?? 960, "Chart width"), i = Ye(e.height ?? 420, "Chart height"), n = Math.min(72, r * 0.18), s = 24, o = Math.max(1, r - n - 24), a = Math.max(1, i - s - 58), l = t.flatMap((w) => Object.keys(w.values)), u = e.today ?? Kr(), h = ((Me = e.range) == null ? void 0 : Me.minX) ?? Yr(l) ?? u, p = ((Pe = e.range) == null ? void 0 : Pe.maxX) ?? u, b = S(h), y = S(p);
+  if (b > y) throw new RangeError("Line graph minX must not be after maxX");
+  const g = Ur(t, b, y), f = e.stacked ?? !1, E = t.map((w) => ({
+    shape: w,
+    values: g.map((F) => Et(w, F))
+  }));
+  let B = ((Ne = e.range) == null ? void 0 : Ne.minY) ?? 0, X = B;
+  const Le = Array.from({ length: g.length }, () => 0), $t = E.map(({ shape: w, values: F }) => {
+    const q = F.map((Z, L) => {
+      const J = f ? Le[L] : 0, Q = J + Z;
+      return f && (Le[L] = Q), B = Math.min(B, J, Q), X = Math.max(X, J, Q), { value: Z, baseValue: J, displayValue: Q };
+    });
+    return { shape: w, entries: q };
+  }), Ct = Math.max(1, X - B), j = X + Ct * 0.05, me = ((Ke = e.range) == null ? void 0 : Ke.minY) ?? B, ye = Math.max(1, j - me), De = Math.max(1, y - b), xt = $t.map(({ shape: w, entries: F }) => ({
+    key: w.key,
+    label: w.label,
+    color: w.color,
+    ...w.colorKey === void 0 ? {} : { colorKey: w.colorKey },
+    shape: w,
+    points: Object.freeze(F.map((q, Z) => {
+      const L = g[Z];
+      return Object.freeze({
+        date: K(L),
+        day: L,
+        ...q,
+        x: n + (L - b) / De * o,
+        y: s + (j - q.displayValue) / ye * a,
+        baseY: s + (j - q.baseValue) / ye * a
+      });
+    }))
+  }));
+  return Object.freeze({
+    minDate: h,
+    maxDate: p,
+    minDay: b,
+    maxDay: y,
+    minY: me,
+    maxY: j,
+    width: r,
+    height: i,
+    plotLeft: n,
+    plotTop: s,
+    plotWidth: o,
+    plotHeight: a,
+    stacked: f,
+    series: Object.freeze(xt),
+    dateMarks: Object.freeze(Hr(b, y, e.maxDateMarks ?? 8).map((w) => ({
+      date: K(w),
+      day: w,
+      x: n + (w - b) / De * o
+    }))),
+    valueTicks: Object.freeze(_r(me, j).map((w) => ({
+      value: w,
+      y: s + (j - w) / ye * a
+    })))
+  });
+}
+function Fr(t, e) {
+  return Et(t, S(e));
+}
+function St(t, e) {
+  const r = t[0];
+  if (r == null) return "";
+  let i = `M ${v(r.x)} ${v(r.y)}`;
+  for (let n = 1; n < t.length; n += 1) {
+    const s = t[n - 1], o = t[n];
+    if (e) {
+      const a = (s.x + o.x) / 2;
+      i += ` C ${v(a)} ${v(s.y)}, ${v(a)} ${v(o.y)}, ${v(o.x)} ${v(o.y)}`;
+    } else
+      i += ` H ${v(o.x)} V ${v(o.y)}`;
+  }
+  return i;
+}
+function qr(t, e) {
+  if (t.length === 0) return "";
+  const r = St(t, e), i = [...t].reverse();
+  let n = "";
+  for (let s = 0; s < i.length; s += 1) {
+    const o = i[s];
+    if (s === 0) n += ` L ${v(o.x)} ${v(o.baseY)}`;
+    else if (e) {
+      const a = i[s - 1], l = (a.x + o.x) / 2;
+      n += ` C ${v(l)} ${v(a.baseY)}, ${v(l)} ${v(o.baseY)}, ${v(o.x)} ${v(o.baseY)}`;
+    } else
+      n += ` H ${v(o.x)} V ${v(o.baseY)}`;
+  }
+  return `${r}${n} Z`;
+}
+function _r(t, e, r = 6) {
+  if (!Number.isFinite(t) || !Number.isFinite(e) || t > e)
+    throw new RangeError("Tick range must contain finite ascending values");
+  if (!Number.isInteger(r) || r < 2) throw new RangeError("Tick target must be at least two");
+  const n = Math.max(1, e - t) / (r - 1), s = 10 ** Math.floor(Math.log10(n)), o = n / s, a = o <= 1 ? 1 : o <= 2 ? 2 : o <= 5 ? 5 : 10, l = Math.max(1, a * s), u = Math.ceil(t / l) * l, h = [];
+  for (let p = u; p <= e + l / 1e3; p += l)
+    h.push(Number(p.toFixed(10)));
+  return h.length === 0 && h.push(Math.ceil(t)), h;
+}
+function Ur(t, e, r) {
+  const i = /* @__PURE__ */ new Set([e, r]);
+  for (const n of t)
+    for (const s of Object.keys(n.values)) {
+      const o = S(s);
+      o >= e && o <= r && i.add(o);
+    }
+  return [...i].sort((n, s) => n - s);
+}
+function Et(t, e) {
+  const r = t.values[K(e)];
+  if (r !== void 0) return r;
+  if (t.carryForward !== !0) return 0;
+  let i = Number.NEGATIVE_INFINITY, n = 0;
+  for (const [s, o] of Object.entries(t.values)) {
+    const a = S(s);
+    a <= e && a > i && (i = a, n = o);
+  }
+  return n;
+}
+function Hr(t, e, r) {
+  if (!Number.isInteger(r) || r < 2)
+    throw new RangeError("Maximum date marks must be at least two");
+  const i = Math.max(0, e - t), n = i <= 62 ? 7 : i <= 730 ? 30 : 365, s = Math.max(n, Math.ceil(Math.max(1, i) / (r - 1))), o = [t];
+  for (let a = t + s; a < e; a += s) o.push(a);
+  return e !== t && o.push(e), o;
+}
+function Vr(t) {
+  if (!Array.isArray(t)) throw new TypeError("History shapes must be an array");
+  const e = /* @__PURE__ */ new Set();
+  for (const r of t) {
+    if (r == null || typeof r != "object") throw new TypeError("History shape must be an object");
+    if (typeof r.key != "string" || r.key.trim() === "" || e.has(r.key))
+      throw new Error("History shape keys must be non-empty and unique");
+    if (e.add(r.key), typeof r.label != "string" || r.label.trim() === "")
+      throw new TypeError("History shape label must be a non-empty string");
+    if (typeof r.color != "string" || r.color.trim() === "")
+      throw new TypeError("History shape color must be a non-empty CSS value");
+    for (const [i, n] of Object.entries(r.values))
+      if (S(i), !Number.isFinite(n)) throw new TypeError("History shape values must be finite");
+  }
+}
+function Yr(t) {
+  return t.length === 0 ? void 0 : t.reduce((e, r) => S(e) <= S(r) ? e : r);
+}
+function Ye(t, e) {
+  if (!Number.isFinite(t) || t <= 0) throw new RangeError(`${e} must be positive`);
+  return t;
+}
+function v(t) {
+  return Number(t.toFixed(3)).toString();
+}
+class Se extends Te {
+  constructor(r) {
+    super(r);
+    c(this, "cursorDate$", new A(null, {
+      owner: this,
+      purpose: "line graph cursor date"
+    }));
+    c(this, "shapes$");
+    c(this, "stacked$");
+    c(this, "smooth$");
+    c(this, "range$");
+    c(this, "ownedSources", []);
+    c(this, "chartHost", null);
+    c(this, "observedWidth", 960);
+    c(this, "currentModel", null);
+    c(this, "resizeObserver", null);
+    this.shapes$ = this.source(r.shapes$, "line graph shapes"), this.stacked$ = this.source(r.stacked$, "line graph stacked state"), this.smooth$ = this.source(r.smooth$, "line graph smooth state"), this.range$ = this.source(r.range$, "line graph range");
+  }
+  render() {
+    const r = this.snapshot(this.shapes$), i = this.snapshot(this.stacked$), n = this.snapshot(this.smooth$), s = this.snapshot(this.range$), o = this.read(this.cursorDate$), a = this.props.label ?? "History chart", l = [r, i, n, s].some(({ fetchState: f }) => f === k.Error) ? k.Error : [r, i, n, s].some(({ fetchState: f }) => f !== k.Ready) ? k.Loading : k.Ready;
+    let u = null;
+    if (this.currentModel = null, l === k.Ready)
+      try {
+        this.currentModel = Br(r.value, {
+          stacked: i.value,
+          range: s.value,
+          width: Math.max(480, this.observedWidth),
+          maxDateMarks: this.observedWidth < 640 ? 5 : 9
+        });
+      } catch (f) {
+        u = f;
+      }
+    const h = this.currentModel, p = h == null ? null : o ?? h.maxDate, b = this.props.formatDate ?? ((f) => f), y = this.props.formatValue ?? ((f) => String(f)), g = this.Host;
+    return /* @__PURE__ */ m(
+      g,
+      {
+        className: (this.props.className ?? this.props.class ?? "") || null,
+        "aria-label": a,
+        "aria-busy": l !== k.Ready ? "true" : null,
+        children: [
+          /* @__PURE__ */ m("header", { children: [
+            /* @__PURE__ */ d("h2", { children: a }),
+            /* @__PURE__ */ m("p", { children: [
+              i.value ? "Stacked area" : "Individual line",
+              " chart;",
+              " ",
+              n.value ? "smooth" : "step",
+              " rendering."
+            ] })
+          ] }),
+          l === k.Error || u != null ? /* @__PURE__ */ d("p", { role: "alert", children: "The history chart could not be calculated." }) : l !== k.Ready ? /* @__PURE__ */ d("p", { role: "status", "aria-live": "polite", children: "Loading history chart…" }) : r.value.length === 0 ? /* @__PURE__ */ d("p", { role: "status", children: this.props.emptyMessage ?? "No history values are available." }) : /* @__PURE__ */ d(
+            "cap-chart",
+            {
+              tabIndex: 0,
+              role: "group",
+              "aria-label": `${a}. Use Left and Right Arrow to move by day; hold Shift to move by week.`,
+              onPointerMove: (f) => this.pointerMove(f),
+              onKeyDown: (f) => this.cursorKeyDown(f),
+              ref: (f) => this.chartHost = f
+            }
+          ),
+          h == null || p == null ? null : /* @__PURE__ */ m("cap-readout", { children: [
+            /* @__PURE__ */ d("p", { "aria-live": "polite", children: /* @__PURE__ */ d("strong", { children: b(p) }) }),
+            /* @__PURE__ */ d("ul", { children: h.series.map(({ shape: f }) => /* @__PURE__ */ m("li", { children: [
+              /* @__PURE__ */ d(
+                "cap-swatch",
+                {
+                  style: { "--colored-base": f.color },
+                  "aria-hidden": "true"
+                }
+              ),
+              /* @__PURE__ */ d("span", { children: f.label }),
+              /* @__PURE__ */ d("strong", { children: y(Fr(f, p)) })
+            ] }, f.key)) })
+          ] })
+        ]
+      }
+    );
+  }
+  afterMount() {
+    this.observeSize(), this.drawChart();
+  }
+  afterUpdate() {
+    this.drawChart();
+  }
+  onDestroy() {
+    var r;
+    (r = this.resizeObserver) == null || r.disconnect(), this.resizeObserver = null, this.chartHost = null, this.cursorDate$.dispose();
+    for (const i of this.ownedSources) i.dispose();
+    this.ownedSources.length = 0;
+  }
+  observeSize() {
+    this.chartHost == null || typeof globalThis.ResizeObserver != "function" || (this.resizeObserver = new ResizeObserver((r) => {
+      var n;
+      const i = (n = r[0]) == null ? void 0 : n.contentRect.width;
+      i == null || i <= 0 || Math.abs(i - this.observedWidth) < 1 || (this.observedWidth = i, this.update());
+    }), this.resizeObserver.observe(this.chartHost));
+  }
+  source(r, i) {
+    if (Gr(r)) return r;
+    const n = new A(r, { owner: this, purpose: i });
+    return this.ownedSources.push(n), n;
+  }
+  pointerMove(r) {
+    const i = this.currentModel, n = this.chartHost;
+    if (i == null || n == null) return;
+    const s = n.getBoundingClientRect();
+    if (s.width <= 0) return;
+    const o = (r.clientX - s.left) / s.width * i.width, a = Math.max(0, Math.min(1, (o - i.plotLeft) / i.plotWidth)), l = Math.round(i.minDay + a * (i.maxDay - i.minDay));
+    this.cursorDate$.set(K(l), "line graph pointer moved");
+  }
+  cursorKeyDown(r) {
+    const i = this.currentModel;
+    if (i == null) return;
+    let n = S(this.cursorDate$.get() ?? i.maxDate);
+    if (r.key === "ArrowLeft") n -= r.shiftKey ? 7 : 1;
+    else if (r.key === "ArrowRight") n += r.shiftKey ? 7 : 1;
+    else if (r.key === "Home") n = i.minDay;
+    else if (r.key === "End") n = i.maxDay;
+    else if (r.key === "Escape") {
+      r.preventDefault(), this.cursorDate$.set(null, "line graph cursor cleared");
+      return;
+    } else return;
+    r.preventDefault();
+    const s = K(Math.max(i.minDay, Math.min(i.maxDay, n)));
+    this.cursorDate$.set(s, "line graph cursor moved by keyboard");
+  }
+  drawChart() {
+    const r = this.chartHost, i = this.currentModel;
+    if (r == null || i == null) return;
+    const n = this.smooth$.get(), s = x("svg");
+    s.setAttribute("viewBox", `0 0 ${i.width} ${i.height}`), s.setAttribute("role", "img"), s.setAttribute("aria-label", this.props.label ?? "History chart");
+    for (const a of i.valueTicks) {
+      const l = x("line");
+      l.classList.add("gridline"), _(l, {
+        x1: i.plotLeft,
+        x2: i.plotLeft + i.plotWidth,
+        y1: a.y,
+        y2: a.y
+      }), s.append(l);
+      const u = x("text");
+      u.classList.add("axismark"), _(u, { x: i.plotLeft - 8, y: a.y + 4, "text-anchor": "end" }), u.textContent = String(a.value), s.append(u);
+    }
+    for (const a of i.dateMarks) {
+      const l = x("line");
+      l.classList.add("gridline"), _(l, {
+        x1: a.x,
+        x2: a.x,
+        y1: i.plotTop,
+        y2: i.plotTop + i.plotHeight
+      }), s.append(l);
+      const u = x("text");
+      u.classList.add("axismark"), _(u, {
+        x: a.x,
+        y: i.plotTop + i.plotHeight + 22,
+        "text-anchor": "middle"
+      }), u.textContent = a.date, s.append(u);
+    }
+    for (const a of i.series) {
+      if (i.stacked) {
+        const u = x("path");
+        u.classList.add("seriesarea"), u.setAttribute("fill", a.color), u.setAttribute("d", qr(a.points, n)), s.append(u);
+      }
+      const l = x("path");
+      l.classList.add("seriesline"), l.setAttribute("stroke", a.color), l.setAttribute("d", St(a.points, n)), s.append(l);
+    }
+    const o = this.cursorDate$.get();
+    if (o != null) {
+      const a = S(o), l = i.plotLeft + (a - i.minDay) / Math.max(1, i.maxDay - i.minDay) * i.plotWidth, u = x("line");
+      u.classList.add("cursor"), _(u, {
+        x1: l,
+        x2: l,
+        y1: i.plotTop,
+        y2: i.plotTop + i.plotHeight
+      }), s.append(u);
+    }
+    r.replaceChildren(s);
+  }
+}
+c(Se, "liveProps", []), c(Se, "hostName", "line-graph"), c(Se, "css", G`
+        & {
+            display: flex;
+            min-width: 0;
+            min-height: var(--viz-line-graph-min-height, 24rem);
+            flex-direction: column;
+            padding: var(--viz-space, 0.7rem);
+            user-select: none;
+        }
+
+        & h2,
+        & p,
+        & ul {
+            margin: 0;
+        }
+
+        & > cap-chart {
+            flex: 1;
+            min-height: 20rem;
+            margin-block: 0.6rem;
+            overflow: auto;
+        }
+
+        & svg {
+            display: block;
+            width: 100%;
+            min-width: 30rem;
+            height: auto;
+        }
+
+        & .gridline {
+            stroke: var(--viz-grid-color, var(--ui-border-color));
+            stroke-width: 1;
+            vector-effect: non-scaling-stroke;
+        }
+
+        & .axismark {
+            fill: var(--viz-color, var(--ui-text-color));
+            font: 12px system-ui, sans-serif;
+        }
+
+        & .seriesline {
+            fill: none;
+            stroke-width: 3;
+            stroke-linecap: round;
+            stroke-linejoin: round;
+            vector-effect: non-scaling-stroke;
+        }
+
+        & .seriesarea {
+            opacity: var(--viz-area-opacity, 0.25);
+        }
+
+        & .cursor {
+            stroke: var(--viz-cursor-color, var(--ui-text-color));
+            stroke-width: 2;
+            stroke-dasharray: 4 3;
+            vector-effect: non-scaling-stroke;
+        }
+
+        & > cap-readout {
+            padding-block-start: 0.4rem;
+            border-block-start: 1px solid var(--viz-border-color, var(--ui-border-color));
+        }
+
+        & > cap-readout ul {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.4rem 1rem;
+            padding: 0;
+            list-style: none;
+        }
+
+        & > cap-readout li {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.35rem;
+        }
+
+        & cap-swatch {
+            display: block;
+            width: 0.8rem;
+            height: 0.8rem;
+            border-radius: 50%;
+            background: var(--colored-base);
+        }
+
+        @media (forced-colors: active) {
+            & .seriesline,
+            & .cursor,
+            & .gridline {
+                stroke: CanvasText;
+                forced-color-adjust: auto;
+            }
+
+            & .seriesarea {
+                fill: Canvas;
+                stroke: CanvasText;
+            }
+        }
+    `);
+function Gr(t) {
+  return t != null && (typeof t == "object" || typeof t == "function") && typeof Reflect.get(t, "get") == "function" && typeof Reflect.get(t, "subscribe") == "function";
+}
+const Wr = "http://www.w3.org/2000/svg";
+function x(t) {
+  return document.createElementNS(Wr, t);
+}
+function _(t, e) {
+  for (const [r, i] of Object.entries(e))
+    t.setAttribute(r, String(i));
+}
+class Xr {
+  constructor(e, r = {}) {
+    c(this, "criteria");
+    c(this, "presets");
+    c(this, "order$");
+    c(this, "activeSplits$");
+    c(this, "activePreset$");
+    c(this, "byKey");
+    c(this, "state$");
+    c(this, "orderEmitter");
+    c(this, "activeSplitsEmitter");
+    c(this, "activeEmitters", /* @__PURE__ */ new Map());
+    c(this, "disposed", !1);
+    if (!Array.isArray(e) || e.some((o) => !(o instanceof I)))
+      throw new TypeError("Split criteria must contain GroupingCriterion instances");
+    const i = new Map(
+      e.map((o) => [o.key, o])
+    );
+    if (i.size !== e.length) throw new Error("Split criteria keys must be unique");
+    this.criteria = Object.freeze([...e]), this.byKey = i, this.presets = Jr(r.presets ?? [], i);
+    const n = this.criteria.map(({ key: o }) => o), s = r.active ?? n;
+    V(s, i, "Active split keys"), this.state$ = new A(re(n, new Set(s)), {
+      owner: this,
+      purpose: "split selection state",
+      equals: Qr
+    }), this.orderEmitter = new z(
+      [this.state$],
+      ([o]) => Object.freeze(
+        o.order.map((a) => Ge(i, a))
+      ),
+      { owner: this, purpose: "ordered visualization criteria" }
+    ), this.order$ = this.orderEmitter, this.activeSplitsEmitter = new z(
+      [this.state$],
+      ([o]) => Object.freeze(o.order.filter((a) => o.active.has(a)).map((a) => Ge(i, a))),
+      { owner: this, purpose: "active ordered visualization splits" }
+    ), this.activeSplits$ = this.activeSplitsEmitter, this.activePreset$ = new A(null, {
+      owner: this,
+      purpose: "active visualization split preset"
+    });
+  }
+  activeState(e) {
+    this.assertActive();
+    const r = this.requireKey(e);
+    let i = this.activeEmitters.get(r);
+    return i == null && (i = new Zr(this, r), this.activeEmitters.set(r, i)), i;
+  }
+  isActive(e) {
+    return this.state$.get().active.has(this.requireKey(e));
+  }
+  toggle(e, r) {
+    this.assertActive();
+    const i = this.requireKey(e), n = this.state$.get(), s = new Set(n.active);
+    return s.has(i) ? s.delete(i) : s.add(i), this.activePreset$.set(null, "split selection customized"), this.state$.set(
+      re(n.order, s),
+      r ?? `${i} split toggled`
+    );
+  }
+  move(e, r, i) {
+    this.assertActive();
+    const n = this.requireKey(e);
+    if (!Number.isInteger(r)) throw new TypeError("Split target index must be an integer");
+    const s = this.state$.get(), o = s.order.indexOf(n), a = Math.max(0, Math.min(r, s.order.length - 1));
+    if (o === a) return !1;
+    const l = [...s.order];
+    return l.splice(o, 1), l.splice(a, 0, n), this.activePreset$.set(null, "split order customized"), this.state$.set(
+      re(l, s.active),
+      i ?? `${n} split moved`
+    );
+  }
+  moveBy(e, r, i) {
+    if (!Number.isInteger(r)) throw new TypeError("Split move offset must be an integer");
+    const n = this.requireKey(e);
+    return this.move(
+      n,
+      this.state$.get().order.indexOf(n) + r,
+      i
+    );
+  }
+  setSplits(e, r, i) {
+    this.assertActive(), V(e, this.byKey, "Active split keys");
+    const n = new Set(e), s = r ?? this.state$.get().order.filter((a) => !n.has(a));
+    V(s, this.byKey, "Inactive split keys");
+    const o = [...e, ...s];
+    if (new Set(o).size !== this.criteria.length || o.length !== this.criteria.length)
+      throw new Error("Active and inactive split keys must cover every criterion exactly once");
+    return this.activePreset$.set(null, "split selection replaced"), this.state$.set(
+      re(o, n),
+      i ?? "split selection replaced"
+    );
+  }
+  applyPreset(e) {
+    this.assertActive();
+    const r = this.presets.find(({ key: n }) => n === e);
+    if (r == null) throw new Error(`Unknown split preset "${e}"`);
+    const i = this.setSplits(r.active, r.inactive, `${r.key} preset applied`);
+    return this.activePreset$.set(r.key, `${r.key} preset applied`), i;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const e of this.activeEmitters.values()) e.dispose();
+      this.activeEmitters.clear(), this.activePreset$.dispose(), this.activeSplitsEmitter.dispose(), this.orderEmitter.dispose(), this.state$.dispose();
+    }
+  }
+  requireKey(e) {
+    if (typeof e != "string" || !this.byKey.has(e))
+      throw new Error(`Unknown criterion key "${String(e)}"`);
+    return e;
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("Split selection model is disposed");
+  }
+}
+function ui(t, e = {}) {
+  return new Xr(t, e);
+}
+class Zr extends xe {
+  constructor(r, i) {
+    super(r.isActive(i) ? "visible" : "hidden", {
+      owner: r,
+      purpose: `${i} split enabled`,
+      fetchState: r.activeSplits$.getFetchState(),
+      error: r.activeSplits$.getError()
+    });
+    c(this, "release");
+    this.model = r, this.criterionKey = i, this.release = r.activeSplits$.subscribe(
+      (n) => this.updateFromSource(n),
+      { emitCurrent: !1 }
+    );
+  }
+  set(r, i) {
+    if (r !== "hidden" && r !== "visible")
+      throw new TypeError("Split state must be hidden or visible");
+    return r === "visible" === this.model.isActive(this.criterionKey) ? !1 : this.model.toggle(this.criterionKey, i);
+  }
+  dispose() {
+    this.release(), super.dispose();
+  }
+  updateFromSource(r) {
+    this.setSnapshot({
+      value: r.value.some(({ key: i }) => i === this.criterionKey) ? "visible" : "hidden",
+      fetchState: r.fetchState,
+      error: r.error,
+      parentEvent: r.event,
+      cause: "active split membership changed"
+    });
+  }
+}
+function Jr(t, e) {
+  if (!Array.isArray(t)) throw new TypeError("Split presets must be an array");
+  const r = /* @__PURE__ */ new Set();
+  return Object.freeze(t.map((i) => {
+    if (i == null || typeof i != "object" || Array.isArray(i))
+      throw new TypeError("Split preset must be an object");
+    if (typeof i.key != "string" || i.key.trim() === "" || r.has(i.key))
+      throw new Error("Split preset keys must be non-empty and unique");
+    if (typeof i.label != "string" || i.label.trim() === "")
+      throw new TypeError("Split preset label must be a non-empty string");
+    r.add(i.key), V(i.active, e, `${i.key} active keys`);
+    const n = Object.freeze([...i.active]), s = i.inactive == null ? Object.freeze([...e.keys()].filter((o) => !n.includes(o))) : Object.freeze([...i.inactive]);
+    if (V(s, e, `${i.key} inactive keys`), (/* @__PURE__ */ new Set([...n, ...s])).size !== e.size || n.length + s.length !== e.size)
+      throw new Error(`Split preset "${i.key}" must cover every criterion exactly once`);
+    return Object.freeze({ ...i, active: n, inactive: s });
+  }));
+}
+function V(t, e, r) {
+  if (!Array.isArray(t)) throw new TypeError(`${r} must be an array`);
+  if (new Set(t).size !== t.length) throw new Error(`${r} must be unique`);
+  for (const n of t)
+    if (!e.has(n)) throw new Error(`${r} contains unknown criterion "${n}"`);
+}
+function Ge(t, e) {
+  const r = t.get(e);
+  if (r == null) throw new Error(`Missing criterion "${e}"`);
+  return r;
+}
+function re(t, e) {
+  return Object.freeze({ order: Object.freeze([...t]), active: new Set(e) });
+}
+function Qr(t, e) {
+  return t.order.length === e.order.length && t.order.every((r, i) => r === e.order[i]) && t.active.size === e.active.size && [...t.active].every((r) => e.active.has(r));
+}
+const ei = [
+  ["☐", "hidden"],
+  ["✓", "visible"]
+];
+class ie extends Te {
+  constructor() {
+    super(...arguments);
+    c(this, "draggingKey", null);
+    c(this, "pendingDrag", null);
+    c(this, "suppressClick", !1);
+    c(this, "suppressClickTimer", null);
+    c(this, "announcement", "");
+  }
+  initialize() {
+    this.listen(document, "pointermove", (r) => this.pointerMove(r)), this.listen(document, "pointerup", () => this.stopDragging()), this.listen(document, "pointercancel", () => this.stopDragging());
+  }
+  render() {
+    const {
+      model: r,
+      label: i = "Select and order splits",
+      description: n = "",
+      presetsLabel: s = "Split presets"
+    } = this.props, o = this.read(r.order$);
+    this.read(r.activeSplits$);
+    const a = this.read(r.activePreset$), l = this.Host;
+    return /* @__PURE__ */ m(l, { children: [
+      r.presets.length === 0 ? null : /* @__PURE__ */ d(ge, { header: s, children: /* @__PURE__ */ d("cap-presets", { children: r.presets.map((u) => /* @__PURE__ */ d(
+        oe,
+        {
+          label: u.label,
+          pressed: a === u.key,
+          onClick: () => {
+            r.applyPreset(u.key), this.announce(`${u.label} split preset applied`);
+          }
+        },
+        u.key
+      )) }) }),
+      /* @__PURE__ */ m(ge, { header: i, children: [
+        /* @__PURE__ */ d("p", { children: n }),
+        /* @__PURE__ */ d("ol", { children: o.map((u) => /* @__PURE__ */ m(
+          "li",
+          {
+            className: this.draggingKey === u.key ? "dragging" : void 0,
+            "data-split-key": u.key,
+            onPointerDown: (h) => this.startDragging(u.key, h),
+            onClick: (h) => this.suppressDraggedClick(h),
+            children: [
+              /* @__PURE__ */ d(
+                ae,
+                {
+                  symbols: ei,
+                  label: u.label,
+                  valueEmitter: r.activeState(u.key)
+                }
+              ),
+              /* @__PURE__ */ d(
+                "cap-draghandle",
+                {
+                  role: "button",
+                  tabIndex: 0,
+                  "aria-label": `Reorder ${u.label}`,
+                  title: "Drag to reorder; use Alt+Arrow keys from the keyboard",
+                  onKeyDown: (h) => {
+                    if (!h.altKey || h.key !== "ArrowUp" && h.key !== "ArrowDown")
+                      return;
+                    h.preventDefault();
+                    const p = h.key === "ArrowUp" ? -1 : 1;
+                    if (r.moveBy(u.key, p, "split reordered by keyboard")) {
+                      const b = r.order$.get().findIndex(({ key: y }) => y === u.key) + 1;
+                      this.announce(`${u.label} moved to position ${b}`), queueMicrotask(() => this.focusHandle(u.key));
+                    }
+                  }
+                }
+              )
+            ]
+          },
+          u.key
+        )) }),
+        /* @__PURE__ */ d("p", { role: "status", "aria-live": "polite", "aria-atomic": "true", children: this.announcement })
+      ] })
+    ] });
+  }
+  pointerMove(r) {
+    var a;
+    if (this.draggingKey == null && this.pendingDrag != null) {
+      const { clientX: l, clientY: u, key: h } = this.pendingDrag;
+      if (Math.hypot(r.clientX - l, r.clientY - u) < 4) return;
+      this.draggingKey = h, this.pendingDrag = null, this.update();
+    }
+    if (this.draggingKey == null || typeof document.elementFromPoint != "function") return;
+    const i = (a = document.elementFromPoint(r.clientX, r.clientY)) == null ? void 0 : a.closest("[data-split-key]");
+    if (i == null) return;
+    const n = i.dataset.splitKey;
+    if (n == null) return;
+    const s = this.props.model.order$.get().findIndex(({ key: l }) => l === n);
+    if (s < 0 || !this.props.model.move(
+      this.draggingKey,
+      s,
+      "split reordered by pointer"
+    )) return;
+    const o = this.props.model.criteria.find(({ key: l }) => l === this.draggingKey);
+    this.announce(`${(o == null ? void 0 : o.label) ?? this.draggingKey} moved to position ${s + 1}`);
+  }
+  stopDragging() {
+    if (this.draggingKey == null && this.pendingDrag == null) return;
+    const r = this.draggingKey, i = r != null;
+    this.draggingKey = null, this.pendingDrag = null, i && (this.suppressClick = !0, this.suppressClickTimer != null && clearTimeout(this.suppressClickTimer), this.suppressClickTimer = setTimeout(() => {
+      this.suppressClick = !1, this.suppressClickTimer = null;
+    }, 0), this.update(), queueMicrotask(() => this.focusHandle(r)));
+  }
+  startDragging(r, i) {
+    i.button === 0 && (this.pendingDrag = { key: r, clientX: i.clientX, clientY: i.clientY });
+  }
+  suppressDraggedClick(r) {
+    this.suppressClick && (this.suppressClick = !1, this.suppressClickTimer != null && clearTimeout(this.suppressClickTimer), this.suppressClickTimer = null, r.preventDefault(), r.stopPropagation());
+  }
+  announce(r) {
+    this.announcement = r, this.update();
+  }
+  focusHandle(r) {
+    var n;
+    const i = this.dom instanceof Element ? this.dom.querySelectorAll("[data-split-key] cap-draghandle") : [];
+    for (const s of i)
+      if (((n = s.closest("[data-split-key]")) == null ? void 0 : n.dataset.splitKey) === r) {
+        s.focus();
+        return;
+      }
+  }
+}
+c(ie, "liveProps", []), c(ie, "hostName", "split-selection-panel"), c(ie, "dependencies", [oe, ae, ge]), c(ie, "css", G`
+        & {
+            display: grid;
+            gap: var(--viz-space, 0.6rem);
+            min-width: 0;
+            user-select: none;
+        }
+
+        & > cap-groupbox {
+            min-width: 0;
+        }
+
+        & > cap-groupbox > cap-content {
+            display: flex;
+            flex-flow: column;
+            padding: .25em;
+            flex: 1 1 0;
+        }
+
+        & > cap-groupbox > cap-content > p,
+        & > cap-groupbox > cap-content > ol {
+            margin: 0;
+        }
+
+        & > cap-groupbox > cap-content > p:first-child {
+            color: var(--viz-muted-color, var(--ui-muted-text-color, currentColor));
+            font-size: 0.875em;
+        }
+
+        & > cap-groupbox > cap-content > cap-presets {
+            display: grid;
+            gap: 0.35rem;
+            align-content: stretch;
+            justify-content: stretch;
+        }
+
+        & > cap-groupbox > cap-content > cap-presets > cap-button {
+            display: flex;
+            flex-flow: column;
+            align-content: stretch;
+        }
+
+        & ol {
+            display: grid;
+            gap: 0.25rem;
+            padding: 0;
+            list-style: none;
+        }
+
+        & li {
+            display: flex;
+            flex-flow: row nowrap;
+            align-items: center;
+            justify-content: space-between;
+            gap: 0.35rem;
+            min-width: 0;
+            padding: 0 .35rem;
+            border-radius: var(--ui-border-radius);
+            box-shadow: var(--box-shadow);
+        }
+
+        & li:has(input[type="checkbox"]:not(:checked)) {
+            color: var(--viz-muted-color, var(--ui-muted-text-color, currentColor));
+        }
+
+        & li.dragging {
+            outline: 2px solid var(--focus-color, var(--ui-accent-color));
+        }
+
+        & cap-draghandle {
+            display: block;
+            width: 1.1rem;
+            height: .9rem;
+            min-height: .9rem;
+            padding: 0;
+            border: 0;
+            border-radius: 0;
+            color: inherit;
+            background-color: transparent;
+            background-image: radial-gradient(currentColor 0.75px, transparent 0.9px);
+            background-position: center;
+            background-size: 3px 3px;
+            cursor: grab;
+            touch-action: none;
+        }
+
+        & cap-draghandle:focus-visible {
+            outline: 2px solid var(--focus-color, var(--ui-accent-color));
+            outline-offset: 1px;
+        }
+
+        & li > :has(> [role="checkbox"]),
+        & [role="checkbox"] {
+
+            justify-content: center;
+            align-items: center;
+            justify-items: center;
+            align-content: center;
+        }
+
+        & > cap-groupbox > cap-content > p[role="status"][aria-live="polite"][aria-atomic="true"] {
+            position: absolute;
+            width: 1px;
+            height: 1px;
+            padding: 0;
+            overflow: hidden;
+            clip: rect(0, 0, 0, 0);
+            white-space: nowrap;
+            border: 0;
+        }
+    `);
+class hi {
+  constructor(e) {
+    c(this, "categories");
+    c(this, "byKey");
+    c(this, "deltas", /* @__PURE__ */ new Map());
+    if (!Array.isArray(e)) throw new TypeError("Series categories must be an array");
+    const r = e.map((n) => ti(n)), i = new Map(r.map((n) => [n.key, n]));
+    if (i.size !== r.length) throw new Error("Series category keys must be unique");
+    this.categories = Object.freeze(r), this.byKey = i;
+  }
+  addOne(e, r) {
+    return this.add(e, r, 1);
+  }
+  removeOne(e, r) {
+    return this.add(e, r, -1);
+  }
+  add(e, r, i) {
+    if (S(e), !Number.isFinite(i)) throw new TypeError("Series delta must be finite");
+    if (!this.byKey.has(r))
+      throw new Error(`Unknown series category "${r}"`);
+    const n = this.deltas.get(r) ?? /* @__PURE__ */ new Map();
+    return n.set(e, (n.get(e) ?? 0) + i), this.deltas.set(r, n), this;
+  }
+  build() {
+    const e = this.allDates();
+    return this.categories.map((r) => We(r, Object.fromEntries(e.map((i) => {
+      var n;
+      return [
+        i,
+        ((n = this.deltas.get(r.key)) == null ? void 0 : n.get(i)) ?? 0
+      ];
+    })), !1)).filter((r) => Object.values(r.values).some((i) => i !== 0));
+  }
+  buildCumulative() {
+    const e = this.allDates();
+    if (e.length === 0) return Object.freeze([]);
+    const r = [Nr(e[0], -1), ...e];
+    return this.categories.map((i) => {
+      var o;
+      let n = 0;
+      const s = { [r[0]]: 0 };
+      for (const a of e)
+        n += ((o = this.deltas.get(i.key)) == null ? void 0 : o.get(a)) ?? 0, s[a] = n;
+      return We(i, s, !0);
+    }).filter((i) => Object.values(i.values).some((n) => n !== 0));
+  }
+  allDates() {
+    return [...new Set([...this.deltas.values()].flatMap((e) => [...e.keys()]))].sort(Ir);
+  }
+}
+function ti(t) {
+  if (t == null || typeof t != "object")
+    throw new TypeError("Series category must be an object");
+  if (typeof t.key != "string" || t.key.trim() === "")
+    throw new TypeError("Series category key must be a non-empty string");
+  if (typeof t.label != "string" || t.label.trim() === "")
+    throw new TypeError("Series category label must be a non-empty string");
+  const e = "color" in t ? t.color : t.colors[1];
+  if (typeof e != "string" || e.trim() === "")
+    throw new TypeError("Series category color must be a non-empty CSS value");
+  const r = t.colorKey === void 0 ? { key: t.key, label: t.label, color: e } : { key: t.key, label: t.label, color: e, colorKey: t.colorKey };
+  return Object.freeze(r);
+}
+function We(t, e, r) {
+  return Object.freeze({
+    ...t,
+    values: Object.freeze(e),
+    carryForward: r
+  });
+}
+export {
+  ee as BlockGraph,
+  It as BlockSelectionModel,
+  te as CategoryHidePanel,
+  de as CollapsibleOptionGroup,
+  I as GroupingCriterion,
+  Se as LineGraph,
+  hi as SeriesBuilder,
+  Xr as SplitSelectionModel,
+  ie as SplitSelectionPanel,
+  Nr as addCivilDays,
+  qr as areaPath,
+  we as buildBlockLayout,
+  _r as buildIntegerTicks,
+  Br as buildLineChartModel,
+  Xe as categoryColorVariables,
+  li as categoryCounts,
+  S as civilDateToDay,
+  Ir as compareCivilDates,
+  ci as createBlockSelection,
+  ui as createSplitSelection,
+  Kt as criterionSnapshot,
+  K as dayToCivilDate,
+  Dt as deriveCategories,
+  oi as derivedCriterion,
+  ai as filterByHidden,
+  D as findBlock,
+  vt as flattenBlocks,
+  St as linePath,
+  Mt as setsEqual,
+  si as staticCriterion,
+  Kr as todayCivilDate,
+  Fr as valueAtDate
+};
+//# sourceMappingURL=index.js.map