@capillaryjs/capillary-ui 1.1.0 → 1.3.0

package/dist/jsx-runtime-Ba-uafjl.js

@@ -0,0 +1,1631 @@
+var $e = Object.defineProperty;
+var Ae = (e, t, n) => t in e ? $e(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var c = (e, t, n) => Ae(e, typeof t != "symbol" ? t + "" : t, n);
+import { defaultDiagnosticScope as ke, Diagnostics as u, diagnosticInfo as ze, EventBubble as X } from "@capillaryjs/capillary";
+const ee = "data-cap-structural-styles";
+let Ne = 1;
+class le {
+  constructor(t = `runtime-${Ne++}`) {
+    c(this, "id");
+    c(this, "cssFragments", /* @__PURE__ */ new Map());
+    if (typeof t != "string") throw new TypeError("StyleRegistry id must be a string");
+    this.id = t;
+  }
+  registerCSS(t) {
+    if (typeof t != "string") throw new TypeError("Component CSS must be a string");
+    const n = t.trim();
+    return n.length > 0 && this.cssFragments.set(`raw:${n}`, { kind: "raw", css: n }), this;
+  }
+  /** @internal Collect a host-relative component template without resolving it yet. */
+  registerHostCSS(t, n) {
+    if (typeof t != "string") throw new TypeError("Component CSS must be a string");
+    if (typeof n != "string" || n.trim().length === 0)
+      throw new TypeError("Component CSS host must be a non-empty selector");
+    const i = t.trim();
+    if (i.length === 0) return this;
+    if (!i.includes("&")) return this.registerCSS(i);
+    const s = `host:${i}`, r = this.cssFragments.get(s);
+    return r == null ? this.cssFragments.set(s, {
+      kind: "host",
+      css: i,
+      hosts: /* @__PURE__ */ new Set([n.trim()])
+    }) : r.kind === "host" && r.hosts.add(n.trim()), this;
+  }
+  generateCSS() {
+    return [...this.cssFragments.values()].map((t) => t.kind === "raw" ? t.css : ce(t.css, [...t.hosts])).join(`
+
+`);
+  }
+  injectAll(t = globalThis.document) {
+    if ((t == null ? void 0 : t.head) == null)
+      throw new TypeError("StyleRegistry.injectAll requires a document with a head");
+    const n = `style[${ee}="${Me(this.id)}"]`;
+    let i = t.head.querySelector(n);
+    i == null && (i = t.createElement("style"), i.setAttribute(ee, this.id), t.head.prepend(i));
+    const s = this.generateCSS();
+    return i.textContent !== s && (i.textContent = s), i;
+  }
+  reset() {
+    this.cssFragments.clear();
+  }
+}
+function xe() {
+  return new le();
+}
+const Ie = new le("");
+function Me(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function ce(e, t) {
+  let n = "", i = 0;
+  for (; i < e.length; ) {
+    const s = qe(e, i);
+    if (s < 0) return n + e.slice(i);
+    const r = Be(e, s);
+    if (r < 0) return n + e.slice(i);
+    const o = e.slice(i, s), a = e.slice(s + 1, r), l = o.trim();
+    n += l.startsWith("@") ? `${o}{${ce(a, t)}}` : `${Ue(o, t)}{${a}}`, i = r + 1;
+  }
+  return n;
+}
+function Ue(e, t) {
+  var o, a, l;
+  if (t.length === 1 || !e.includes("&"))
+    return t.length === 1 ? e.replaceAll("&", t[0]) : e;
+  const n = ((o = e.match(/^\s*/)) == null ? void 0 : o[0]) ?? "", i = ((a = e.match(/\s*$/)) == null ? void 0 : a[0]) ?? "", s = Fe(e.trim()), r = ((l = n.match(/(?:^|\n)([ \t]*)$/)) == null ? void 0 : l[1]) ?? "";
+  return n + s.flatMap((f) => f.includes("&") ? t.map((p) => f.replaceAll("&", p)) : [f]).join(`,
+${r}`) + i;
+}
+function Fe(e) {
+  const t = [];
+  let n = 0, i = 0, s = 0, r = null;
+  for (let o = 0; o < e.length; o += 1) {
+    const a = e[o];
+    if (r != null) {
+      a === "\\" ? o += 1 : a === r && (r = null);
+      continue;
+    }
+    a === '"' || a === "'" ? r = a : a === "(" ? i += 1 : a === ")" ? i -= 1 : a === "[" ? s += 1 : a === "]" ? s -= 1 : a === "," && i === 0 && s === 0 && (t.push(e.slice(n, o).trim()), n = o + 1);
+  }
+  return t.push(e.slice(n).trim()), t.filter(Boolean);
+}
+function qe(e, t) {
+  for (let n = t; n < e.length; n += 1) {
+    const i = e[n];
+    if (i === '"' || i === "'")
+      n = ue(e, n);
+    else if (i === "/" && e[n + 1] === "*")
+      n = fe(e, n);
+    else if (i === "{")
+      return n;
+  }
+  return -1;
+}
+function Be(e, t) {
+  let n = 1;
+  for (let i = t + 1; i < e.length; i += 1) {
+    const s = e[i];
+    if (s === '"' || s === "'")
+      i = ue(e, i);
+    else if (s === "/" && e[i + 1] === "*")
+      i = fe(e, i);
+    else if (s === "{")
+      n += 1;
+    else if (s === "}" && --n === 0)
+      return i;
+  }
+  return -1;
+}
+function ue(e, t) {
+  const n = e[t];
+  for (let i = t + 1; i < e.length; i += 1)
+    if (e[i] === "\\") i += 1;
+    else if (e[i] === n) return i;
+  return e.length;
+}
+function fe(e, t) {
+  const n = e.indexOf("*/", t + 2);
+  return n < 0 ? e.length : n + 1;
+}
+const pe = /* @__PURE__ */ new WeakSet(), de = /* @__PURE__ */ new WeakSet();
+function vt(e) {
+  if (typeof e != "string" || e.trim() === "")
+    throw new TypeError("Service name must be a non-empty string");
+  const t = Object.freeze({ name: e.trim() });
+  return pe.add(t), t;
+}
+function Et(e, t) {
+  if (W(e), typeof t != "function")
+    throw new TypeError(`Service provider "${e.name}" requires a factory function`);
+  const n = Object.freeze({ key: e, create: t });
+  return de.add(n), n;
+}
+class he {
+  constructor(t = []) {
+    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(t))
+      throw new TypeError("ServiceScope providers must be an array");
+    for (const n of t) {
+      if (De(n), this.providers.has(n.key))
+        throw new Error(`Service "${n.key.name}" is registered more than once`);
+      this.providers.set(n.key, n);
+    }
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  has(t) {
+    return this.assertActive(), W(t), this.providers.has(t);
+  }
+  require(t) {
+    if (this.assertActive(), W(t), this.instances.has(t)) return this.instances.get(t);
+    const n = this.providers.get(t);
+    if (n == null) throw new Error(`Service "${t.name}" is not registered`);
+    const i = this.resolving.indexOf(t);
+    if (i >= 0) {
+      const s = [...this.resolving.slice(i), t].map((r) => r.name).join(" -> ");
+      throw new Error(`Circular service dependency: ${s}`);
+    }
+    this.resolving.push(t);
+    try {
+      const s = n.create(this);
+      return this.instances.set(t, s), this.creationOrder.push(t), s;
+    } finally {
+      this.resolving.pop();
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = !0;
+    const t = [];
+    for (const n of [...this.creationOrder].reverse()) {
+      const i = this.instances.get(n);
+      try {
+        const s = He(i);
+        s != null && s.call(i);
+      } catch (s) {
+        t.push(s);
+      }
+    }
+    if (this.instances.clear(), this.creationOrder.length = 0, this.resolving.length = 0, t.length === 1) throw t[0];
+    if (t.length > 1)
+      throw new AggregateError(t, "Several services failed during disposal");
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("ServiceScope has been disposed");
+  }
+}
+function Ve(e = []) {
+  return new he(e);
+}
+function We(e) {
+  return e != null && (typeof e == "object" || typeof e == "function") && pe.has(e);
+}
+function W(e) {
+  if (!We(e)) throw new TypeError("Expected a service key created by defineService()");
+}
+function De(e) {
+  if (e == null || typeof e != "object" && typeof e != "function" || !de.has(e))
+    throw new TypeError("Expected a service provider created by provideService()");
+}
+function He(e) {
+  if (e == null || typeof e != "object" && typeof e != "function") return null;
+  const t = Reflect.get(e, "dispose");
+  return typeof t == "function" ? t : null;
+}
+const z = Object.freeze({
+  breadcrumbLabel: "Breadcrumb",
+  checkboxOptionLabel: "Option",
+  checkboxStateLabel: (e, t) => `${e}: ${t}`,
+  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",
+  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: (e) => `Filter ${e}`,
+  tableSortColumnLabel: (e) => `Sort ${e}`,
+  themeOptionCapillaryLabel: "Capillary",
+  themeOptionMinimalLabel: "Minimal",
+  themeOptionShinyLabel: "Shiny",
+  toolbarLabel: "Actions",
+  treeViewEmpty: "No tree items",
+  treeViewLoadError: "Unable to load tree items",
+  treeViewLoading: "Loading tree items…"
+});
+class me {
+  constructor(t, n) {
+    c(this, "locale");
+    c(this, "messages");
+    this.locale = t, this.messages = n, Object.freeze(this);
+  }
+  message(t) {
+    return this.messages[t];
+  }
+}
+const Ke = new me(
+  void 0,
+  z
+);
+function Ye(e) {
+  if (e == null) return Ke;
+  if (typeof e != "object" || Array.isArray(e))
+    throw new TypeError("Capillary UI localization must be an object");
+  const t = Ze(e.locale), n = e.messages;
+  if (n != null && (typeof n != "object" || Array.isArray(n)))
+    throw new TypeError("Capillary UI localization messages must be an object");
+  const i = { ...z };
+  if (n != null)
+    for (const s of Object.keys(z)) {
+      const r = n[s];
+      if (r === void 0) continue;
+      const o = z[s];
+      if (typeof r != typeof o)
+        throw new TypeError(`Capillary UI localization message "${s}" has the wrong type`);
+      Object.assign(i, { [s]: r });
+    }
+  return new me(t, Object.freeze(i));
+}
+function Ze(e) {
+  if (typeof e != "string" || e.trim() === "")
+    throw new TypeError("Capillary UI localization locale must be a non-empty BCP 47 language tag");
+  try {
+    return Intl.getCanonicalLocales(e)[0];
+  } catch (t) {
+    throw new RangeError(`Invalid Capillary UI localization locale: ${e}`, { cause: t });
+  }
+}
+const Ge = /* @__PURE__ */ new Set([
+  "annotation-xml",
+  "color-profile",
+  "font-face",
+  "font-face-src",
+  "font-face-uri",
+  "font-face-format",
+  "font-face-name",
+  "missing-glyph"
+]);
+class K {
+  constructor(t = {}, n = xe()) {
+    c(this, "styleRegistry");
+    c(this, "services");
+    c(this, "router");
+    c(this, "localization");
+    c(this, "diagnosticScope");
+    c(this, "routedRoots", /* @__PURE__ */ new WeakSet());
+    if (t == null || typeof t != "object" || Array.isArray(t))
+      throw new TypeError("CapillaryUiRuntime options must be an object");
+    if (Object.hasOwn(t, "elementNames"))
+      throw new TypeError("CapillaryUiRuntime no longer supports configurable element names");
+    if (this.styleRegistry = n, this.diagnosticScope = t.diagnosticScope ?? ke, this.localization = Ye(t.localization), this.services = t.services ?? Ve(), !(this.services instanceof he))
+      throw new TypeError("Capillary UI services must be a ServiceScope");
+    if (this.router = t.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(t) {
+    ge(t, "Capillary UI component host name");
+    const n = `cap-${t.replaceAll("-", "")}`;
+    return Je(n), n;
+  }
+  resolveHostSelector(t, n) {
+    if (typeof t != "string") throw new TypeError("Host selector must be a string");
+    return t.replaceAll("&", this.resolveElementName(n));
+  }
+  resolveHostCSS(t, n) {
+    if (typeof t != "string") throw new TypeError("Host CSS must be a string");
+    return t.replaceAll("&", this.resolveElementName(n));
+  }
+  create(t, ...n) {
+    const i = u.withScope(this.diagnosticScope, () => new t(...n));
+    return i._setRuntime(this), i;
+  }
+  mount(t, n, i = null) {
+    t._setRuntime(this);
+    let s = null;
+    this.router != null && !this.routedRoots.has(t) && (this.routedRoots.add(t), s = this.router.openScope(this.router.root, t), t.onCleanup(s));
+    try {
+      t.mount(n, i), this.router != null && s != null && this.router.completeScope(this.router.root, t);
+    } catch (r) {
+      throw s == null || s(), r;
+    }
+    return t;
+  }
+  registerStyles(t) {
+    if (t == null || typeof t.registerStyles != "function")
+      throw new TypeError("registerStyles requires a Capillary UI component dependency");
+    return t.registerStyles(this), this;
+  }
+  injectStyles(t = globalThis.document) {
+    return this.styleRegistry.injectAll(t);
+  }
+}
+function Ct(e = {}) {
+  return new K(e);
+}
+const te = new K({}, Ie);
+function ge(e, t) {
+  if (typeof e != "string" || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(e))
+    throw new TypeError(`${t} must be a lowercase kebab-case name`);
+}
+function Je(e) {
+  if (ge(e, "Capillary UI element name"), !e.includes("-") || Ge.has(e))
+    throw new TypeError(`Capillary UI element name must be a non-reserved name containing a hyphen: ${e}`);
+}
+const N = Symbol.for("@capillaryjs/capillary-ui.Fragment"), ye = /* @__PURE__ */ new WeakSet(), Qe = /* @__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"
+]), Xe = /* @__PURE__ */ new Set([
+  "checked",
+  "defaultChecked",
+  "defaultValue",
+  "disabled",
+  "indeterminate",
+  "multiple",
+  "muted",
+  "readOnly",
+  "required",
+  "selected",
+  "selectedIndex",
+  "tabIndex",
+  "value"
+]), ne = "data-cap";
+let g = null;
+function h() {
+  g && (g.count += 1);
+}
+function Rt(e) {
+  Q(e, "live");
+  const t = Object.freeze({ emitter: e });
+  return ye.add(t), t;
+}
+function x(e, t = null, ...n) {
+  const i = t ?? {};
+  if (typeof i != "object" || Array.isArray(i))
+    throw new TypeError("VNode props must be an object or null");
+  const {
+    children: s,
+    key: r = null,
+    ...o
+  } = i;
+  return {
+    type: e,
+    key: r,
+    props: {
+      ...o,
+      children: be([s, n])
+    }
+  };
+}
+function et(e, ...t) {
+  return e.reduce((n, i, s) => n + i + String(t[s] ?? ""), "");
+}
+const m = class m {
+  constructor(t = {}) {
+    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", te);
+    /** @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: t = [],
+      ...n
+    }) => this.host(n, t));
+    if (t == null || typeof t != "object" || Array.isArray(t))
+      throw new TypeError(`${this.constructor.name} props must be an object`);
+    this.props = t;
+  }
+  static new(...t) {
+    const n = new this(...t);
+    if (!(n instanceof m))
+      throw new TypeError("Component.new() requires a Component constructor");
+    return n.mount();
+  }
+  static registerStyles(t = te, n = /* @__PURE__ */ new Set()) {
+    if (n.has(this)) return;
+    n.add(this);
+    const i = this.hostName ?? null, s = yt(this);
+    for (const r of s)
+      Object.hasOwn(r, "css") && r.css && (i == null ? t.styleRegistry.registerCSS(r.css) : t.styleRegistry.registerHostCSS(
+        r.css,
+        t.resolveElementName(i)
+      ));
+    for (const r of s)
+      if (Object.hasOwn(r, "dependencies"))
+        for (const o of r.dependencies ?? [])
+          o.registerStyles(t, n);
+  }
+  get diagnosticScope() {
+    var t;
+    return this.constructor.diagnosticScope ?? ((t = this._parentComponent) == null ? void 0 : t.diagnosticScope) ?? this._runtime.diagnosticScope;
+  }
+  /** Stable instance label, captured when this component is first observed. */
+  get diagnosticLabel() {
+    const t = this.constructor;
+    return t.diagnosticLabel ?? t.hostName ?? t.name;
+  }
+  [ze]() {
+    return {
+      kind: "component",
+      label: R(this),
+      scope: this.diagnosticScope,
+      sources: [...this.watched.keys(), ...this.renderReadSubscriptions.keys()],
+      targets: [...this._childComponents]
+    };
+  }
+  /** 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(t = null, ...n) {
+    const i = this.constructor, s = i.hostName;
+    if (s == null)
+      throw new Error(`${this.constructor.name} does not declare a custom host name`);
+    const {
+      class: r,
+      className: o,
+      ...a
+    } = t ?? {}, l = o ?? r, f = this.props.island === !0 ? bt(l, "island") : l;
+    return x(this._runtime.resolveElementName(s), {
+      ...a,
+      ...f == null ? {} : { className: f },
+      "data-cap-component": s,
+      ...i.dataSurface == null ? {} : { "data-cap-surface": i.dataSurface }
+    }, ...n);
+  }
+  /** @internal Assign an immutable application runtime before initialization or mounting. */
+  _setRuntime(t) {
+    var n;
+    if (!(t instanceof K))
+      throw new TypeError("Component runtime must be a CapillaryUiRuntime");
+    if (t === 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 = t, this._routeContext == null && (this._routeContext = ((n = t.router) == null ? void 0 : n.root) ?? null), this;
+  }
+  /** @internal Assign contextual route lineage before initialization. */
+  _setRouteContext(t) {
+    if (this.initialized || this.mounted || this._rendered != null)
+      throw new Error("Cannot change a component route context after initialization");
+    return this._routeContext = t, this;
+  }
+  /** @internal Route lineage inherited by component children. */
+  _routeContextForChildren() {
+    return this._routeContext;
+  }
+  /** @internal Assign the renderer-owned component ancestry. */
+  _setParentComponent(t) {
+    if (this._parentComponent != null && this._parentComponent !== t)
+      throw new Error("A component instance cannot move between component owners");
+    return this._parentComponent = t, this.validateIslandAncestry(this.props), this;
+  }
+  mount(t = null, n = 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, u.withScope(this.diagnosticScope, () => this.initialize())), this.mounted || (this.mounted = !0, this.update(), i = !0), t != null && (gt(t), J(t, this._rendered, n)), i && this.afterMount(this.dom), this;
+  }
+  attachTo(t) {
+    return this.mount(t), this;
+  }
+  update(t, n = t instanceof X ? "dependency" : "explicit") {
+    if (this.destroyed) return this;
+    if (!this.mounted) return this.mount();
+    if (this.updating)
+      return this.updateRequested = !0, this;
+    this.updating = !0;
+    const i = u.event(this, "consumer", {
+      parent: t instanceof X ? t : u.currentEvent,
+      cause: "component render",
+      outcome: "started",
+      consumer: { trigger: n }
+    }), s = g, r = i ? { count: 0 } : null;
+    let o = 0;
+    g = r;
+    try {
+      u.withEvent(i, () => {
+        do {
+          o += 1, this.updateRequested = !1;
+          const a = /* @__PURE__ */ new Set();
+          this.collectingRenderReads = a;
+          let l;
+          try {
+            l = u.withScope(this.diagnosticScope, () => j(this.render()));
+          } finally {
+            this.collectingRenderReads = null;
+          }
+          this._rendered = Y(this._rendered, l, this), this.dom = Le(this._rendered), this.reconcileRenderReads(a), this.afterUpdate(this.dom);
+        } while (this.updateRequested && !this.destroyed);
+      }), i && u.event(this, "consumer", {
+        parent: i,
+        cause: "component rendered",
+        outcome: "succeeded",
+        consumer: { trigger: n, domWrites: r.count, renderPasses: o }
+      });
+    } catch (a) {
+      throw i && u.event(this, "consumer", {
+        parent: i,
+        cause: "component render failed",
+        outcome: "failed",
+        error: a,
+        consumer: { trigger: n, domWrites: r.count, renderPasses: o }
+      }), a;
+    } finally {
+      g = s, this.updating = !1;
+    }
+    return this;
+  }
+  setProps(t) {
+    var n, i;
+    if (t == null || typeof t != "object" || Array.isArray(t))
+      throw new TypeError(`${this.constructor.name} props must be an object`);
+    return this.validateIslandAncestry(t), this.props = t, this.mounted && this.update(
+      void 0,
+      ((i = (n = u.currentEvent) == null ? void 0 : n.diagnostic) == null ? void 0 : i.node.kind) === "binding" ? "dependency" : "parent"
+    ), this;
+  }
+  afterMount(t) {
+  }
+  afterUpdate(t) {
+  }
+  watch(...t) {
+    for (const n of t) {
+      if (n == null || typeof n.subscribe != "function")
+        throw new TypeError("watch requires emitter-like values");
+      if (this.watched.has(n)) continue;
+      const i = n.subscribe(({ event: s }) => {
+        this.mounted && !this.destroyed && this.update(s);
+      }, { emitCurrent: !1, diagnosticTarget: this });
+      this.watched.set(n, i), this.onCleanup(() => {
+        i(), this.watched.delete(n);
+      });
+    }
+    return this;
+  }
+  watchFutureValues(...t) {
+    return this.watch(...t);
+  }
+  /** Read an emitter during render and rerender when that dependency changes. */
+  read(t) {
+    return this.trackRenderRead(t), t.get();
+  }
+  /** Read a Capillary value, fetch state, and error as one tracked render dependency. */
+  snapshot(t) {
+    return this.trackRenderRead(t), Object.freeze({
+      value: t.get(),
+      fetchState: t.getFetchState(),
+      error: t.getError()
+    });
+  }
+  onCleanup(t) {
+    if (typeof t != "function") throw new TypeError("cleanup must be a function");
+    if (this.destroyed)
+      return t(), () => {
+      };
+    this.cleanupFunctions.add(t);
+    let n = !0;
+    return () => {
+      n && (n = !1, this.cleanupFunctions.delete(t), t());
+    };
+  }
+  /** Resolve one explicitly declared application service from this component's runtime. */
+  requireService(t) {
+    if (!this.initialized)
+      throw new Error("Components may resolve services during initialize() or later");
+    const n = this.constructor;
+    if (!n.requiredServices.includes(t))
+      throw new Error(
+        `${n.name} must declare service "${t.name}" in requiredServices`
+      );
+    return this._runtime.services.require(t);
+  }
+  /** 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(t) {
+    return this.localization.message(t);
+  }
+  listen(t, n, i, s) {
+    if (t == null || typeof t.addEventListener != "function")
+      throw new TypeError("listen target must be an EventTarget");
+    const r = {};
+    u.configure(r, {
+      kind: "interaction",
+      label: `${R(this)}: ${n}`,
+      scope: this.diagnosticScope
+    });
+    const o = (a) => M(
+      r,
+      this.diagnosticScope,
+      a,
+      o,
+      n,
+      () => i(a)
+    );
+    return t.addEventListener(n, o, s), this.onCleanup(() => {
+      t.removeEventListener(n, o, s), u.dispose(r);
+    }), this;
+  }
+  /**
+   * Like {@link listen}, but returns a function that detaches the listener.
+   * Use for listeners that are only active some of the time — for example
+   * an outside-click handler that exists only while a popup is open — so
+   * they neither fire nor appear in the trace while inactive. The listener
+   * runs through the same traced native-event coalescing as listen(), and
+   * is removed on destroy if it is still attached.
+   */
+  listenWhile(t, n, i, s) {
+    if (t == null || typeof t.addEventListener != "function")
+      throw new TypeError("listen target must be an EventTarget");
+    const r = {};
+    u.configure(r, {
+      kind: "interaction",
+      label: `${R(this)}: ${n}`,
+      scope: this.diagnosticScope
+    });
+    const o = (p) => M(
+      r,
+      this.diagnosticScope,
+      p,
+      o,
+      n,
+      () => i(p)
+    );
+    let a = !1;
+    const l = () => {
+      a && (a = !1, t.removeEventListener(n, o, s), u.dispose(r));
+    }, f = this.onCleanup(l);
+    return this.destroyed || (a = !0, t.addEventListener(n, o, s)), f;
+  }
+  registerChild(t) {
+    if (!(t instanceof m))
+      throw new TypeError("registerChild requires a Component");
+    return this._childComponents.add(t), u.active && u.inspect(this), t;
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0, this.mounted = !1, u.dispose(this);
+      for (const t of [...this.cleanupFunctions]) t();
+      this.cleanupFunctions.clear(), this.watched.clear();
+      for (const t of this.renderReadSubscriptions.values()) t();
+      this.renderReadSubscriptions.clear(), this.collectingRenderReads = null, this._rendered && E(this._rendered, !0), this._rendered = null, this.dom = null, this._childComponents.clear(), this.onDestroy();
+    }
+  }
+  validateRequiredServices() {
+    const t = this.constructor;
+    for (const n of t.requiredServices)
+      if (!this._runtime.services.has(n))
+        throw new Error(`${t.name} requires unregistered service "${n.name}"`);
+  }
+  validateIslandAncestry(t) {
+    if (!V(t)) return;
+    if (this.hasIslandDescendant())
+      throw new Error("An island component cannot contain another island");
+    let n = this._parentComponent;
+    for (; n != null; ) {
+      if (V(n.props))
+        throw new Error("An island component cannot be nested inside another island");
+      n = n._parentComponent;
+    }
+  }
+  hasIslandDescendant() {
+    for (const t of this._childComponents)
+      if (V(t.props) || t.hasIslandDescendant()) return !0;
+    return !1;
+  }
+  onDestroy() {
+  }
+  trackRenderRead(t) {
+    if (Q(t, "Component.read"), this.collectingRenderReads == null)
+      throw new Error("Component.read() and snapshot() may only be called during render()");
+    this.collectingRenderReads.add(t);
+  }
+  reconcileRenderReads(t) {
+    for (const [n, i] of this.renderReadSubscriptions)
+      t.has(n) || (i(), this.renderReadSubscriptions.delete(n));
+    for (const n of t) {
+      if (this.watched.has(n) || this.renderReadSubscriptions.has(n)) continue;
+      const i = n.subscribe(({ event: s }) => {
+        this.mounted && !this.destroyed && this.update(s);
+      }, { emitCurrent: !1, diagnosticTarget: this });
+      this.renderReadSubscriptions.set(n, i);
+    }
+  }
+};
+c(m, "dependencies", []), c(m, "requiredServices", []), /** Component `live()` bindings are opt-in; subclasses declare their allowlist. */
+c(m, "liveProps", []), c(m, "css", et`
+        .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;
+            gap: calc(var(--_cap-island-flow, 0) * var(--island-gap, 0px));
+        }
+
+        .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 {
+            /* Move the clip into the surrounding gutter without moving the
+             * content. The inherited allowance is owned by the parent layout,
+             * so local gaps and nested scrollports do not add extra spacing. */
+            --_cap-scroll-gutter: calc(var(--_cap-island-flow, 0) * var(--_cap-island-gutter, 0px));
+            margin: calc(-1 * var(--_cap-scroll-gutter));
+            padding: var(--_cap-scroll-gutter);
+            overflow: auto;
+            min-inline-size: 0;
+            min-block-size: 0;
+        }
+
+        /* The mode crosses wrappers; each layout resolves its own public gap.
+         * Only the first enabled scope contributes a perimeter inset. */
+        .cap-island-layout {
+            --_cap-island-flow: 1;
+            --_cap-island-margin: 0px;
+            --_cap-island-separator-background: transparent;
+            box-sizing: border-box;
+            padding: var(--_cap-island-outer-inset, var(--island-inset, 0px));
+            gap: calc(var(--_cap-island-flow, 0) * var(--island-gap, 0px));
+        }
+
+        .cap-island-layout > * {
+            --_cap-island-outer-inset: 0px;
+        }
+
+        .cap-layout-horizontal > *,
+        .cap-layout-vertical > *,
+        .cap-island-layout > * {
+            --_cap-island-gutter: calc(var(--_cap-island-flow, 0) * var(--island-gap, 0px) / 2);
+        }
+
+        .cap-island-layout.cap-scroll {
+            padding: calc(var(--_cap-island-outer-inset, var(--island-inset, 0px))
+                + var(--_cap-scroll-gutter));
+        }
+
+        .cap-island-layout-off {
+            --_cap-island-flow: 0;
+            --_cap-island-margin: initial;
+            --_cap-island-separator-background: initial;
+        }
+
+        .cap-island-layout-off > *,
+        .island > * {
+            --_cap-island-outer-inset: initial;
+            --_cap-island-gutter: 0px;
+        }
+
+        .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 {
+            --_cap-island-flow: 0;
+            --_cap-island-separator-background: initial;
+            box-sizing: border-box;
+            min-width: 0;
+            min-height: 0;
+            margin: var(--_cap-island-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(--_cap-island-margin, var(--island-margin))));
+            overflow-x: auto;
+        }
+
+        .cap-fill-vertical.island,
+        .cap-fill-vertical .island {
+            max-height: calc(100% - (2 * var(--_cap-island-margin, var(--island-margin))));
+            overflow-y: auto;
+        }
+
+        label[data-cap] {
+            user-select: none;
+        }
+    `), c(m, "hostName", null), /** Override for a diagnostic-tool subtree; ordinary components inherit their owner/runtime. */
+c(m, "diagnosticScope", null), /** Optional stable display name for bundled application components. Built-ins use their host name. */
+c(m, "diagnosticLabel", null), /** Optional host-level data surface marker for parent composition. */
+c(m, "dataSurface", null);
+let w = m;
+function j(e) {
+  return Array.isArray(e) ? x(N, null, e) : e == null || typeof e == "boolean" ? x(N) : e;
+}
+function be(e) {
+  const t = [], n = (i) => {
+    if (Array.isArray(i))
+      for (const s of i) n(s);
+    else i != null && typeof i != "boolean" && t.push(i);
+  };
+  return n(e), t;
+}
+function $(e, t) {
+  if (typeof e == "string" || typeof e == "number")
+    return {
+      kind: "text",
+      key: null,
+      value: e,
+      node: document.createTextNode(String(e)),
+      owner: t
+    };
+  if (q(e)) {
+    const r = document.createComment("cap-emitter-start"), o = document.createComment("cap-emitter-end"), a = e.get();
+    if (Object.is(a, e))
+      throw new TypeError("A Capillary UI emitter child cannot render itself");
+    const l = document.createDocumentFragment();
+    l.append(r, o), h(), h();
+    const f = $(j(a), t);
+    J(l, f, o);
+    const p = {
+      kind: "emitter",
+      key: null,
+      source: e,
+      start: r,
+      end: o,
+      child: f,
+      unsubscribe: () => {
+      },
+      owner: t
+    };
+    return p.unsubscribe = F(e, p, t, "reactive child", (y) => {
+      if (Object.is(y, e))
+        throw new TypeError("A Capillary UI emitter child cannot render itself");
+      p.child = Y(p.child, j(y), t);
+    }), p;
+  }
+  if (e instanceof w)
+    return e._setRuntime(t._runtime), e._setRouteContext(t._routeContextForChildren()), e._setParentComponent(t), e.mount(), t.registerChild(e), {
+      kind: "component",
+      key: Te(e.props),
+      type: e.constructor,
+      instance: e,
+      prebuilt: !0,
+      props: e.props,
+      liveProps: /* @__PURE__ */ new Map(),
+      owner: t
+    };
+  if (!S(e))
+    throw new TypeError(`Invalid Capillary UI child: ${ae(e)}`);
+  const { type: n, key: i = null, props: s } = e;
+  if (n === N) {
+    const r = document.createComment("cap-fragment-start"), o = document.createComment("cap-fragment-end"), a = {
+      kind: "fragment",
+      key: i,
+      type: n,
+      start: r,
+      end: o,
+      children: [],
+      owner: t
+    }, l = document.createDocumentFragment();
+    return l.append(r, o), h(), h(), a.children = I(
+      l,
+      [],
+      s.children,
+      t,
+      o,
+      r
+    ), a;
+  }
+  if (typeof n == "string") {
+    const r = document.createElement(n), o = {
+      kind: "element",
+      key: i,
+      type: n,
+      node: r,
+      props: {},
+      listeners: /* @__PURE__ */ new Map(),
+      liveProps: /* @__PURE__ */ new Map(),
+      nativeBindings: /* @__PURE__ */ new Map(),
+      ref: null,
+      children: [],
+      owner: t
+    };
+    return Ce(o, s), o.children = I(r, [], s.children, t), o;
+  }
+  if (Pe(n)) {
+    const r = s;
+    ve(n, r);
+    const o = ie(r), a = u.withScope(
+      n.diagnosticScope ?? t.diagnosticScope,
+      () => new n(o)
+    );
+    a._setRuntime(t._runtime), a._setRouteContext(t._routeContextForChildren()), a._setParentComponent(t);
+    const l = {
+      kind: "component",
+      key: i,
+      type: n,
+      instance: a,
+      prebuilt: !1,
+      props: o,
+      liveProps: /* @__PURE__ */ new Map(),
+      owner: t
+    };
+    return Se(l, r), a.mount(), t.registerChild(a), l;
+  }
+  if (typeof n == "function") {
+    const r = n, o = s, a = ie(o), l = r === Reflect.get(t, "Host") ? null : {};
+    l && u.configure(l, {
+      kind: "component",
+      label: String(Reflect.get(r, "diagnosticLabel") ?? r.name ?? "Function component"),
+      scope: t.diagnosticScope,
+      sources: [t]
+    });
+    const f = Ee(l, () => $(j(r(a)), t)), p = {
+      kind: "function",
+      key: i,
+      type: r,
+      props: a,
+      sourceProps: o,
+      liveProps: /* @__PURE__ */ new Map(),
+      child: f,
+      diagnosticSubject: l,
+      owner: t
+    };
+    return nt(p), p;
+  }
+  throw new TypeError(`Unsupported vnode type: ${ae(n)}`);
+}
+function Y(e, t, n) {
+  if (e == null) return $(t, n);
+  if (Oe(e, t)) return we(e, t, n);
+  const i = $(t, n), s = Le(e), r = (s == null ? void 0 : s.parentNode) ?? null;
+  return r && J(r, i, s), E(e, !0), i;
+}
+function we(e, t, n) {
+  return e.kind === "text" ? (typeof t != "string" && typeof t != "number" || Object.is(e.value, t) || (e.value = t, e.node.data = String(t), h()), e) : e.kind === "emitter" ? (!q(t) || e.source !== t, e) : e.kind === "component" ? (t instanceof w || S(t) && tt(e, t.props), e) : S(t) ? e.kind === "function" ? (it(e, t.props), e) : e.kind === "fragment" ? (e.children = I(
+    e.start.parentNode,
+    e.children,
+    t.props.children,
+    n,
+    e.end,
+    e.start
+  ), e) : (Ce(e, t.props), e.children = I(
+    e.node,
+    e.children,
+    t.props.children,
+    n
+  ), e) : e;
+}
+function ie(e) {
+  return Object.fromEntries(Object.entries(e).map(([t, n]) => [
+    t,
+    T(n) ? n.emitter.get() : n
+  ]));
+}
+function Se(e, t) {
+  Z(e.liveProps, t, e.instance, R(e.instance), (n, i) => {
+    e.props = { ...e.props, [n]: i }, e.instance.setProps(e.props);
+  }), e.props = G(e.liveProps, t), e.instance.setProps(e.props);
+}
+function tt(e, t) {
+  ve(e.type, t), Se(e, t);
+}
+function ve(e, t) {
+  const n = Reflect.get(e, "liveProps");
+  if (n == null) return;
+  if (!Array.isArray(n) || n.some((s) => typeof s != "string"))
+    throw new TypeError(`${e.name || "Component"}.liveProps must be an array`);
+  const i = new Set(n);
+  for (const [s, r] of Object.entries(t))
+    if (T(r) && !i.has(s))
+      throw new TypeError(
+        `${e.name || "Component"} prop "${s}" does not support live()`
+      );
+}
+function nt(e) {
+  Z(e.liveProps, e.sourceProps, e.owner, e.type.diagnosticLabel ?? e.type.name, (t, n) => {
+    e.props = { ...e.props, [t]: n }, D(e, "dependency");
+  }), e.props = G(e.liveProps, e.sourceProps);
+}
+function it(e, t) {
+  e.sourceProps = t, Z(e.liveProps, t, e.owner, e.type.diagnosticLabel ?? e.type.name, (n, i) => {
+    e.props = { ...e.props, [n]: i }, D(e, "dependency");
+  }), e.props = G(e.liveProps, t), D(e);
+}
+function D(e, t = "parent") {
+  Ee(e.diagnosticSubject, () => {
+    const n = j(e.type(e.props));
+    e.child = Y(e.child, n, e.owner);
+  }, t);
+}
+function Ee(e, t, n = "parent") {
+  if (!e) return t();
+  const i = u.event(e, "consumer", { cause: "function component render", outcome: "started", consumer: { trigger: n } }), s = g, r = i ? { count: 0 } : null;
+  g = r;
+  try {
+    const o = i ? u.withEvent(i, t) : t();
+    return i && u.event(e, "consumer", { parent: i, cause: "function component rendered", outcome: "succeeded", consumer: { trigger: n, domWrites: r.count, renderPasses: 1 } }), o;
+  } catch (o) {
+    throw i && u.event(e, "consumer", { parent: i, cause: "function component failed", outcome: "failed", error: o, consumer: { trigger: n, domWrites: r.count, renderPasses: 1 } }), o;
+  } finally {
+    g = s;
+  }
+}
+function Z(e, t, n, i, s) {
+  for (const [r, o] of e) {
+    const a = t[r];
+    T(a) && a.emitter === o.source || (o.unsubscribe(), e.delete(r));
+  }
+  for (const [r, o] of Object.entries(t)) {
+    if (!T(o) || e.has(r)) continue;
+    const a = {
+      source: o.emitter,
+      value: o.emitter.get(),
+      unsubscribe: () => {
+      }
+    };
+    a.unsubscribe = F(o.emitter, a, n, `${i}.${r}`, (l) => {
+      e.get(r) === a && (a.value = l, s(r, l));
+    }), e.set(r, a);
+  }
+}
+function G(e, t) {
+  return Object.fromEntries(Object.entries(t).map(([n, i]) => {
+    var s;
+    return [
+      n,
+      T(i) ? ((s = e.get(n)) == null ? void 0 : s.value) ?? i.emitter.get() : i
+    ];
+  }));
+}
+function I(e, t, n, i, s = null, r = null) {
+  if (e == null) throw new Error("Cannot patch a detached fragment range");
+  const o = be(n), a = /* @__PURE__ */ new Map(), l = [];
+  for (const d of t)
+    d.key == null ? l.push(d) : a.has(d.key) || a.set(d.key, d);
+  const f = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), y = [];
+  let je = 0;
+  for (const d of o) {
+    const b = _(d);
+    if (b != null) {
+      if (f.has(b)) throw new Error(`Duplicate sibling key: ${String(b)}`);
+      f.add(b);
+    }
+    const A = b == null ? l[je++] : a.get(b);
+    A && Oe(A, d) ? (p.add(A), y.push(we(A, d, i))) : y.push($(d, i));
+  }
+  for (const d of t)
+    p.has(d) || E(d, !0);
+  let O = r ? r.nextSibling : e.firstChild;
+  for (const d of y)
+    for (const b of C(d))
+      b === O ? O = O.nextSibling : (e.insertBefore(b, O ?? s), h(), O = b.nextSibling);
+  return y;
+}
+function Ce(e, t) {
+  const n = Object.fromEntries(Object.entries(t).filter(
+    ([r]) => r !== "children" && P(r) !== ne
+  )), i = e.props, s = /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(n)]);
+  for (const r of ["value", "checked"])
+    if (Object.hasOwn(n, r) && Object.hasOwn(n, `bind:${r}`))
+      throw new Error(`${r} and bind:${r} cannot be used together`);
+  for (const r of s) {
+    const o = i[r], a = n[r];
+    if (pt(r))
+      st(e, r, a);
+    else if (r === "ref")
+      o !== a && at(e, a);
+    else if (ft(r))
+      ot(e, r, a);
+    else if (T(a))
+      rt(e, r, a);
+    else {
+      const l = e.liveProps.get(r);
+      l && (l.unsubscribe(), e.liveProps.delete(r));
+      const f = (l == null ? void 0 : l.value) ?? o;
+      Object.is(f, a) || L(e.node, r, f, a);
+    }
+  }
+  v(e.node, ne, ""), e.props = { ...n };
+}
+function rt(e, t, n) {
+  const i = e.liveProps.get(t);
+  if ((i == null ? void 0 : i.source) === n.emitter) return;
+  i == null || i.unsubscribe();
+  const s = n.emitter.get();
+  L(e.node, t, (i == null ? void 0 : i.value) ?? e.props[t], s);
+  const r = {
+    source: n.emitter,
+    value: s,
+    unsubscribe: () => {
+    }
+  };
+  r.unsubscribe = F(n.emitter, r, e.owner, `${e.type}.${t}`, (o) => {
+    const a = r.value;
+    r.value = o, Object.is(a, o) || L(e.node, t, a, o);
+  }), e.liveProps.set(t, r);
+}
+function st(e, t, n) {
+  const i = t.slice(5), s = e.nativeBindings.get(t);
+  if (n == null) {
+    s && (s.unsubscribe(), e.node.removeEventListener(s.eventName, s.listener), e.nativeBindings.delete(t), L(e.node, i, s.value, void 0));
+    return;
+  }
+  if (dt(n, t), (s == null ? void 0 : s.source) === n) return;
+  s && (s.unsubscribe(), e.node.removeEventListener(s.eventName, s.listener)), ht(e.node, i);
+  const r = mt(e.node, i), o = n.get();
+  L(e.node, i, s == null ? void 0 : s.value, o);
+  const a = (f) => {
+    M(
+      Re(e, r),
+      e.owner.diagnosticScope,
+      f,
+      a,
+      `${t} changed`,
+      () => n.set(Reflect.get(e.node, i), `${t} changed`)
+    );
+  }, l = {
+    source: n,
+    value: o,
+    eventName: r,
+    listener: a,
+    unsubscribe: () => {
+    }
+  };
+  l.unsubscribe = F(n, l, e.owner, `${e.type}.${t}`, (f) => {
+    const p = l.value;
+    l.value = f, Object.is(p, f) || L(e.node, i, p, f);
+  }), e.node.addEventListener(r, a), e.nativeBindings.set(t, l);
+}
+function ot(e, t, n) {
+  const i = t.slice(2).toLowerCase(), s = e.listeners.get(t), r = s ? se.get(s) ?? s : null;
+  if (s && r !== n && (e.node.removeEventListener(i, s), e.listeners.delete(t)), n != null && typeof n != "function")
+    throw new TypeError(`${t} must be a function or null`);
+  if (typeof n == "function" && r !== n) {
+    const o = (a) => M(
+      Re(e, i),
+      e.owner.diagnosticScope,
+      a,
+      o,
+      i,
+      () => n.call(e.node, a)
+    );
+    se.set(o, n), e.node.addEventListener(i, o), e.listeners.set(t, o);
+  }
+}
+const re = /* @__PURE__ */ new WeakMap(), se = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap();
+function M(e, t, n, i, s, r) {
+  return u.withScope(t, () => {
+    if (!u.active) return r();
+    let o = B.get(n);
+    return (!o || o.listeners.has(i)) && (o = { event: u.event(e, "interaction", { cause: s, outcome: "started" }), listeners: /* @__PURE__ */ new Set() }, B.set(n, o), queueMicrotask(() => B.delete(n))), o.listeners.add(i), u.withEvent(o.event, r);
+  });
+}
+function Re(e, t) {
+  var s;
+  let n = re.get(e);
+  n || (n = /* @__PURE__ */ new Map(), re.set(e, n));
+  let i = n.get(t);
+  if (!i) {
+    i = {};
+    const r = e.node.getAttribute("aria-label") ?? e.node.getAttribute("name") ?? ((s = e.node.textContent) == null ? void 0 : s.trim().slice(0, 80)) ?? "";
+    u.configure(i, {
+      kind: "interaction",
+      label: `${R(e.owner)}: ${e.type} ${r} ${t}`.trim(),
+      scope: e.owner.diagnosticScope
+    }), n.set(t, i);
+  }
+  return i;
+}
+function F(e, t, n, i, s) {
+  u.configure(t, {
+    kind: "binding",
+    label: `${R(n)}: ${i}`,
+    scope: n.diagnosticScope,
+    sources: [e]
+  });
+  const r = e.subscribe(({ value: o, event: a }) => {
+    const l = u.event(t, "consumer", {
+      parent: a,
+      cause: "binding update",
+      value: o,
+      outcome: "started",
+      consumer: { trigger: "dependency" }
+    }), f = g, p = l ? { count: 0 } : null;
+    g = p;
+    try {
+      u.withEvent(l, () => s(o)), l && u.event(t, "consumer", {
+        parent: l,
+        cause: "binding updated",
+        value: o,
+        outcome: "succeeded",
+        consumer: { trigger: "dependency", domWrites: p.count }
+      });
+    } catch (y) {
+      throw l && u.event(t, "consumer", {
+        parent: l,
+        cause: "binding update failed",
+        outcome: "failed",
+        error: y,
+        consumer: { trigger: "dependency", domWrites: p.count }
+      }), y;
+    } finally {
+      g = f;
+    }
+  }, { emitCurrent: !1, diagnosticTarget: t });
+  return () => {
+    r(), u.dispose(t);
+  };
+}
+function R(e) {
+  return e.diagnosticLabel;
+}
+function at(e, t) {
+  if (H(e.ref, null), t != null && typeof t != "function" && typeof t != "object")
+    throw new TypeError("ref must be a function, object, or null");
+  e.ref = t, H(e.ref, e.node);
+}
+function L(e, t, n, i) {
+  if (t === "class" || t === "className") {
+    v(e, "class", i);
+    return;
+  }
+  if (t === "for" || t === "htmlFor") {
+    v(e, "for", i);
+    return;
+  }
+  if (t === "dataset") {
+    lt(e, n, i);
+    return;
+  }
+  if (t === "style") {
+    ct(e, n, i);
+    return;
+  }
+  if (t === "dangerouslySetInnerHTML")
+    throw new Error("dangerouslySetInnerHTML is not supported");
+  const s = ut(t);
+  if (Qe.has(s)) {
+    const r = !!i;
+    s in e && Reflect.get(e, s) !== r && (Reflect.set(e, s, r), h()), v(e, P(t), r);
+    return;
+  }
+  if (s === "value" && e.localName === "option") {
+    v(e, P(t), i);
+    return;
+  }
+  if (Xe.has(s) && s in e) {
+    const r = i ?? (s === "value" ? "" : !1);
+    Object.is(Reflect.get(e, s), r) || (Reflect.set(e, s, r), h()), i == null && v(e, P(t), null);
+    return;
+  }
+  v(e, P(t), i);
+}
+function lt(e, t, n) {
+  const i = U(t, "dataset"), s = U(n, "dataset");
+  for (const r of /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(s)])) {
+    const o = s[r];
+    e.dataset[r] !== (o == null ? void 0 : String(o)) && (o == null ? delete e.dataset[r] : e.dataset[r] = String(o), h());
+  }
+}
+function ct(e, t, n) {
+  if (typeof n == "string") {
+    e.style.cssText !== n && (e.style.cssText = n, h());
+    return;
+  }
+  const i = typeof t == "string" ? {} : U(t, "style"), s = U(n, "style");
+  typeof t == "string" && e.style.cssText !== "" && (e.style.cssText = "", h());
+  for (const r of /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(s)])) {
+    const o = s[r];
+    if (r.startsWith("--")) {
+      if (e.style.getPropertyValue(r) === (o == null ? "" : String(o))) continue;
+      o == null ? e.style.removeProperty(r) : e.style.setProperty(r, String(o));
+    } else {
+      if (Reflect.get(e.style, r) === (o == null ? "" : String(o))) continue;
+      Reflect.set(e.style, r, o == null ? "" : String(o));
+    }
+    h();
+  }
+}
+function U(e, t) {
+  if (e == null) return {};
+  if (typeof e != "object" || Array.isArray(e))
+    throw new TypeError(`${t} must be an object or null`);
+  return e;
+}
+function v(e, t, n) {
+  const i = n == null || n === !1 ? null : n === !0 ? "" : String(n);
+  e.getAttribute(t) !== i && (i === null ? e.removeAttribute(t) : e.setAttribute(t, i), h());
+}
+function ut(e) {
+  return e === "readonly" ? "readOnly" : e === "autofocus" ? "autoFocus" : e;
+}
+function P(e) {
+  return e === "className" ? "class" : e === "htmlFor" ? "for" : e === "minLength" ? "minlength" : e === "maxLength" ? "maxlength" : e === "autoComplete" ? "autocomplete" : e === "inputMode" ? "inputmode" : /^aria[A-Z]/.test(e) || /^data[A-Z]/.test(e) ? oe(e) : e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function oe(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function H(e, t) {
+  e != null && (typeof e == "function" ? e(t) : e.current = t);
+}
+function E(e, t) {
+  if (e.kind === "emitter") {
+    if (e.unsubscribe(), E(e.child, !1), t)
+      for (const n of C(e)) k(n);
+    return;
+  }
+  if (e.kind === "component") {
+    for (const n of e.liveProps.values()) n.unsubscribe();
+    e.liveProps.clear(), e.owner._childComponents.delete(e.instance), e.instance.destroy();
+    return;
+  }
+  if (e.kind === "function") {
+    for (const n of e.liveProps.values()) n.unsubscribe();
+    e.liveProps.clear(), e.diagnosticSubject && u.dispose(e.diagnosticSubject), E(e.child, t);
+    return;
+  }
+  if (e.kind === "element") {
+    H(e.ref, null);
+    for (const [n, i] of e.listeners)
+      e.node.removeEventListener(n.slice(2).toLowerCase(), i);
+    e.listeners.clear();
+    for (const n of e.liveProps.values()) n.unsubscribe();
+    e.liveProps.clear();
+    for (const n of e.nativeBindings.values())
+      n.unsubscribe(), e.node.removeEventListener(n.eventName, n.listener);
+    e.nativeBindings.clear();
+    for (const n of e.children) E(n, !1);
+    t && k(e.node);
+    return;
+  }
+  if (e.kind === "fragment") {
+    for (const n of e.children) E(n, !1);
+    if (t)
+      for (const n of C(e)) k(n);
+    return;
+  }
+  t && k(e.node);
+}
+function k(e) {
+  e.parentNode && (e.remove(), h());
+}
+function J(e, t, n = null) {
+  if (t != null)
+    for (const i of C(t))
+      i.parentNode === e && i.nextSibling === n || (e.insertBefore(i, n), h());
+}
+function C(e) {
+  if (e == null) return [];
+  if (e.kind === "text" || e.kind === "element") return [e.node];
+  if (e.kind === "component") return C(e.instance._rendered);
+  if (e.kind === "function") return C(e.child);
+  const t = [];
+  let n = e.start;
+  for (; n && (t.push(n), n !== e.end); )
+    n = n.nextSibling;
+  return t;
+}
+function Le(e) {
+  return C(e)[0] ?? null;
+}
+function _(e) {
+  return e instanceof w ? Te(e.props) : S(e) ? e.key : null;
+}
+function Te(e) {
+  const t = e.key;
+  return typeof t == "string" || typeof t == "number" ? t : null;
+}
+function Oe(e, t) {
+  return e.kind === "text" ? typeof t == "string" || typeof t == "number" : e.kind === "emitter" ? q(t) && e.source === t : e.kind === "component" ? t instanceof w ? e.instance === t : S(t) && Pe(t.type) && e.type === t.type && e.key === _(t) : e.kind === "function" ? S(t) && e.type === t.type && e.key === _(t) : e.kind === "fragment" ? S(t) && t.type === N && e.key === _(t) : S(t) && typeof t.type == "string" && e.type === t.type && e.key === _(t);
+}
+function S(e) {
+  return e != null && typeof e == "object" && Object.hasOwn(e, "type");
+}
+function Pe(e) {
+  return typeof e == "function" && (e === w || e.prototype instanceof w);
+}
+function ft(e) {
+  return /^on[A-Z]/.test(e);
+}
+function pt(e) {
+  return e === "bind:value" || e === "bind:checked";
+}
+function T(e) {
+  return e != null && typeof e == "object" && ye.has(e);
+}
+function q(e) {
+  return (typeof e != "object" || e == null) && typeof e != "function" ? !1 : typeof Reflect.get(e, "get") == "function" && typeof Reflect.get(e, "getFetchState") == "function" && typeof Reflect.get(e, "getError") == "function" && typeof Reflect.get(e, "subscribe") == "function";
+}
+function Q(e, t) {
+  if (!q(e)) throw new TypeError(`${t} requires a readable emitter`);
+}
+function dt(e, t) {
+  if (Q(e, t), typeof Reflect.get(e, "set") != "function")
+    throw new TypeError(`${t} requires a writable emitter`);
+}
+function ht(e, t) {
+  const n = e.localName;
+  if (!(t === "checked" ? n === "input" : n === "input" || n === "textarea" || n === "select")) throw new TypeError(`bind:${t} is not supported on ${n}`);
+}
+function mt(e, t) {
+  return t === "value" && e.localName !== "select" ? "input" : "change";
+}
+function gt(e) {
+  if (e == null || typeof e != "object" && typeof e != "function" || typeof Reflect.get(e, "insertBefore") != "function")
+    throw new TypeError("Component parent must be a DOM ParentNode");
+}
+function ae(e) {
+  try {
+    return String(e);
+  } catch {
+    return Object.prototype.toString.call(e);
+  }
+}
+function yt(e) {
+  const t = [];
+  let n = e;
+  for (; n != null && typeof n == "function" && (t.unshift(n), n !== w); )
+    n = Object.getPrototypeOf(n);
+  return t;
+}
+function bt(...e) {
+  return [...new Set(e.flatMap((t) => typeof t == "string" ? t.split(/\s+/) : []).filter(Boolean))].join(" ");
+}
+function V(e) {
+  if (e.island === !0) return !0;
+  const t = e.className ?? e.class;
+  return typeof t == "string" && t.split(/\s+/).includes("island");
+}
+function _e(e, t, n) {
+  const i = t == null ? {} : { ...t };
+  return n !== void 0 && (i.key = n), x(e, i);
+}
+const Lt = _e, Tt = _e;
+function Ot(e) {
+  if (!(e instanceof w))
+    throw new TypeError("createPrebuiltElement requires a Component instance");
+  return e;
+}
+export {
+  w as C,
+  N as F,
+  he as S,
+  _e as a,
+  Lt as b,
+  et as c,
+  K as d,
+  le as e,
+  Ct as f,
+  Ve as g,
+  x as h,
+  S as i,
+  Tt as j,
+  xe as k,
+  te as l,
+  vt as m,
+  Rt as n,
+  Ot as o,
+  Et as p,
+  Ie as s
+};
+//# sourceMappingURL=jsx-runtime-Ba-uafjl.js.map