@tempots/beatui 1.7.5 → 1.9.0

package/dist/deep-merge-8fwp1z4X.js

@@ -0,0 +1,1346 @@
+import { Task as be, Use as E, Value as f, prop as me, html as v, attr as s, on as U, WithElement as Ie, Empty as S, aria as ue, bind as K, When as B, NotEmpty as Se, Fragment as N, ForEach as se, computedOf as F, OnDispose as Te, Repeat as Be, signal as ge, input as te, emitValue as H } from "@tempots/dom";
+import { a as q, B as fe } from "./input-container-DCS5oJ4S.js";
+import { B as R, f as xe, I as O, d as pe } from "./translations-DU9wTV1y.js";
+import { C as ee, F as Le } from "./control-hqEuMzyI.js";
+import { C as ne, m as Fe } from "./text-input-ByuxdX8w.js";
+import { N as $e, r as ie, G as ye } from "./text-area-Br83-_PQ.js";
+import { S as Ve } from "./stack-BLMteGTn.js";
+import { a as re, m as we } from "./use-form-DsCzINfm.js";
+import { strictEqual as J } from "@tempots/std";
+let oe = null;
+async function de() {
+  const t = globalThis;
+  return t.Temporal ? t.Temporal : (oe || (oe = import("./index.esm-By0m3ki1.js").then((e) => {
+    const n = e.Temporal;
+    return t.Temporal || (t.Temporal = n), n;
+  })), oe);
+}
+const Ee = (t, e) => e ? be(de, {
+  then: t,
+  pending: e.pending,
+  error: e.error
+}) : be(de, t);
+function ce({
+  onChange: t,
+  value: e,
+  accept: n = "*/*",
+  enableClick: l = !0,
+  content: i,
+  disabled: x = !1,
+  allowMultiple: c
+}) {
+  return E(R, (m) => {
+    const p = f.deriveProp(e ?? []), _ = me(!1), h = (d) => {
+      d.preventDefault(), d.stopPropagation(), _.value = !0;
+    }, b = (d) => {
+      d.preventDefault(), d.stopPropagation(), (!d.currentTarget || !d.currentTarget.contains(d.relatedTarget)) && (_.value = !1);
+    }, k = (d) => {
+      d.preventDefault(), d.stopPropagation(), _.value = !1;
+      const y = Array.from(d.dataTransfer?.files || []);
+      y.length > 0 && (p.value = y, t(y, "dragdrop"));
+    }, o = (d) => {
+      f.get(l) && d.currentTarget.querySelector(
+        'input[type="file"]'
+      )?.click();
+    };
+    let a = null;
+    const D = () => {
+      if (a == null) return;
+      const d = Array.from(a.files ?? []);
+      d.length > 0 && (p.value = d, t(d, "click")), a.value = "";
+    }, z = (d) => {
+      f.get(l) && (d.key === "Enter" || d.key === " ") && (d.preventDefault(), o(d));
+    };
+    return v.div(
+      s.role("button"),
+      s.tabindex(
+        f.map(l, (d) => d ? 0 : -1)
+      ),
+      s.style("position: relative;"),
+      U.dragover(h),
+      U.dragleave(b),
+      U.drop(k),
+      U.click(o),
+      U.keydown(z),
+      // Hidden file input
+      v.input(
+        s.type("file"),
+        s.disabled(x),
+        s.accept(n),
+        s.multiple(c),
+        s.style(
+          "position: absolute; left: -9999px; opacity: 0; pointer-events: none;"
+        ),
+        U.change(D),
+        Ie((d) => (a = d, p.on((y) => {
+          const I = globalThis.DataTransfer;
+          if (I != null) {
+            const C = new I();
+            y.forEach((L) => C.items.add(L)), d.files = C.files;
+          }
+        }), S))
+      ),
+      // Screen reader instructions
+      ue.label(K(m.$.dropZoneInstructions)(l)),
+      // Content
+      i({
+        files: p,
+        clear: () => p.value = [],
+        change: (d) => p.set(d)
+      })
+    );
+  });
+}
+function Re(t) {
+  const e = t.type.toLowerCase();
+  return e.startsWith("image/") && (e.includes("jpeg") || e.includes("jpg") || e.includes("png") || e.includes("gif") || e.includes("webp") || e.includes("svg"));
+}
+function Oe(t) {
+  const e = t.type.toLowerCase();
+  return e.startsWith("image/") ? "vscode-icons:file-type-image" : e.startsWith("video/") ? "vscode-icons:file-type-video" : e.startsWith("audio/") ? "vscode-icons:file-type-audio" : e.includes("pdf") ? "vscode-icons:file-type-pdf2" : e.includes("word") || e.includes("document") ? "vscode-icons:file-type-word" : e.includes("excel") || e.includes("spreadsheet") ? "vscode-icons:file-type-excel" : e.includes("powerpoint") || e.includes("presentation") ? "vscode-icons:file-type-powerpoint" : e.includes("zip") || e.includes("archive") ? "vscode-icons:file-type-zip" : e.includes("text") ? "vscode-icons:file-type-text" : e.includes("json") ? "vscode-icons:file-type-json-official" : e.includes("csv") ? "vscode-icons:file-type-csv" : e.includes("xml") ? "vscode-icons:file-type-xml" : e.includes("yaml") ? "vscode-icons:file-type-yaml-official" : "vscode-icons:file-type-binary";
+}
+function ae(t) {
+  return B(
+    t.map(Re),
+    () => {
+      const e = me(null);
+      return t.on((n) => {
+        e.value && URL.revokeObjectURL(e.value);
+        const l = URL.createObjectURL(n);
+        e.value = l;
+      }), v.div(
+        Te(() => {
+          e.value && URL.revokeObjectURL(e.value);
+        }),
+        s.class("bc-file-input__thumbnail-container"),
+        v.img(
+          s.src(e),
+          s.alt(t.map((n) => n.name)),
+          s.class("bc-file-input__thumbnail")
+        )
+      );
+    },
+    () => O({ icon: t.map(Oe) })
+  );
+}
+const rt = (t, ...e) => {
+  const {
+    value: n = me([]),
+    accept: l = "*/*",
+    maxFiles: i,
+    maxFileSize: x,
+    onChange: c,
+    onBlur: m,
+    disabled: p,
+    hasError: _,
+    mode: h = "default",
+    showFileList: b = !0,
+    ...k
+  } = t, o = n, a = f.map(h, (w) => w === "input"), D = f.map(h, (w) => w === "compact"), z = (w) => {
+    let r = w;
+    if (i != null) {
+      const u = f.get(i);
+      r = r.slice(0, u);
+    }
+    if (x) {
+      const u = f.get(x);
+      r = r.filter((M) => M.size <= u);
+    }
+    c?.(r);
+  }, d = (w) => {
+    const u = o.value.filter((M, T) => T !== w);
+    c?.(u);
+  }, y = () => {
+    c?.([]);
+  }, I = ({
+    files: w,
+    clear: r,
+    change: u
+  }) => E(
+    R,
+    (M) => v.div(
+      s.class("bc-file-input__drop-zone"),
+      v.div(
+        s.class(
+          "bc-file-input__drop-zone-content bc-file-input__drop-zone-content--empty"
+        ),
+        O({ icon: "mdi:cloud-upload-outline", size: "xl" }),
+        v.div(
+          s.class("bc-file-input__drop-zone-text"),
+          K(M.$.filesInputInstructions)(
+            i,
+            x,
+            M.$.fileSizeUnits.value
+          )
+        )
+      )
+    )
+  ), C = ({
+    files: w
+  }) => E(
+    R,
+    (r) => v.div(
+      s.class("bc-file-input__compact-drop-zone"),
+      B(
+        w.map((u) => u.length > 0),
+        () => v.div(
+          s.class("bc-file-input__compact-file-list"),
+          se(w, (u, M) => {
+            const T = M.index;
+            return v.div(
+              s.class("bc-file-input__compact-file-item"),
+              v.div(
+                s.class("bc-file-input__compact-file-icon"),
+                ae(u)
+              ),
+              v.div(
+                s.class("bc-file-input__compact-file-info"),
+                v.div(
+                  s.class("bc-file-input__compact-file-name"),
+                  s.title(u.$.name),
+                  u.$.name
+                ),
+                v.div(
+                  s.class("bc-file-input__compact-file-meta"),
+                  F(
+                    u.$.size,
+                    r.$.fileSizeUnits
+                  )((g, $) => xe(g, { units: $ })),
+                  " • ",
+                  F(
+                    u.$.type,
+                    r.$.unknownType
+                  )((g, $) => g || $)
+                )
+              ),
+              ee(
+                {
+                  size: "sm",
+                  label: r.$.removeFile,
+                  disabled: p,
+                  onClick: () => d(T)
+                },
+                s.class("bc-file-input__compact-remove-button")
+              )
+            );
+          })
+        ),
+        () => v.div(
+          s.class("bc-file-input__compact-placeholder"),
+          O({ icon: "mdi:cloud-upload-outline", size: "lg" }),
+          v.div(
+            s.class("bc-file-input__compact-placeholder-text"),
+            K(r.$.filesInputInstructions)(
+              i,
+              x,
+              r.$.fileSizeUnits.value
+            )
+          )
+        )
+      )
+    )
+  ), L = ({
+    files: w
+  }) => E(
+    R,
+    (r) => v.div(
+      s.class("bc-file-input__compact-input"),
+      B(
+        w.map((u) => u.length > 0),
+        () => v.span(
+          s.class("bc-file-input__compact-value"),
+          se(
+            w,
+            (u) => v.span(
+              s.class("bc-file-input__compact-value-item"),
+              ae(u),
+              v.span(
+                s.class("bc-file-input__compact-value-item-name"),
+                u.$.name
+              )
+            )
+          )
+        ),
+        () => v.span(
+          s.class("bc-file-input__compact-placeholder"),
+          O({ icon: "mdi:cloud-upload-outline", size: "md" }),
+          " ",
+          K(r.$.filesInputInstructions)(
+            i,
+            x,
+            r.$.fileSizeUnits.value
+          )
+        )
+      )
+    )
+  );
+  return E(
+    R,
+    (w) => q(
+      {
+        baseContainer: f.map(a, (r) => !r),
+        disabled: p,
+        hasError: _,
+        after: B(
+          a,
+          () => B(
+            o.map(({ length: r }) => r > 0),
+            () => ee(
+              {
+                size: "sm",
+                label: w.$.clearAllFiles,
+                disabled: p,
+                onClick: y
+              },
+              s.class("bc-file-input__compact-clear")
+            )
+          )
+        ),
+        ...k,
+        input: B(
+          a,
+          () => v.div(
+            s.class("bc-file-input bc-file-input--input"),
+            ce({
+              value: o,
+              accept: l,
+              enableClick: !0,
+              allowMultiple: f.map(i ?? 1 / 0, (r) => r > 1),
+              disabled: p,
+              onChange: z,
+              content: L
+            })
+          ),
+          () => B(
+            D,
+            () => v.div(
+              s.class("bc-file-input bc-file-input--compact"),
+              ce({
+                value: o,
+                accept: l,
+                enableClick: !0,
+                allowMultiple: f.map(i ?? 1 / 0, (r) => r > 1),
+                disabled: p,
+                onChange: z,
+                content: C
+              })
+            ),
+            () => v.div(
+              s.class("bc-file-input"),
+              ce({
+                value: o,
+                accept: l,
+                enableClick: !0,
+                allowMultiple: f.map(i ?? 1 / 0, (r) => r > 1),
+                disabled: p,
+                onChange: z,
+                content: I
+              }),
+              B(
+                b,
+                () => Se(
+                  o,
+                  () => N(
+                    v.div(
+                      s.class("bc-file-input__file-list"),
+                      se(o, (r, u) => {
+                        const M = u.index;
+                        return v.div(
+                          s.class("bc-file-input__file-item"),
+                          v.div(
+                            s.class("bc-file-input__file-icon"),
+                            ae(r)
+                          ),
+                          v.div(
+                            s.class("bc-file-input__file-info"),
+                            v.div(
+                              s.class("bc-file-input__file-name"),
+                              s.title(r.$.name),
+                              r.$.name
+                            ),
+                            v.div(
+                              s.class("bc-file-input__file-meta"),
+                              F(
+                                r.$.size,
+                                w.$.fileSizeUnits
+                              )(
+                                (T, g) => xe(T, { units: g })
+                              ),
+                              " • ",
+                              F(
+                                r.$.type,
+                                w.$.unknownType
+                              )((T, g) => T || g)
+                            )
+                          ),
+                          ee(
+                            {
+                              size: "sm",
+                              label: w.$.removeFile,
+                              disabled: p,
+                              onClick: () => d(M)
+                            },
+                            s.class("bc-file-input__remove-button")
+                          )
+                        );
+                      })
+                    ),
+                    B(
+                      o.map(({ length: r }) => r > 1),
+                      () => v.div(
+                        s.class(
+                          "bc-file-input__clear-all-button-container"
+                        ),
+                        v.button(
+                          s.type("button"),
+                          s.class("bc-file-input__clear-all-button"),
+                          s.disabled(p),
+                          w.$.clearAllFiles,
+                          U.click((r) => {
+                            r.preventDefault(), r.stopPropagation(), y();
+                          })
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      },
+      ...e
+    )
+  );
+};
+function je(t, e, n) {
+  const l = t.length.map((i) => i);
+  return Be(
+    l,
+    (i) => {
+      const x = t.item(i.index), c = [];
+      return N(
+        Te(() => {
+          c.forEach((m) => m());
+        }),
+        e({
+          list: t,
+          item: x,
+          position: i,
+          remove: () => t.removeAt(i.index),
+          move: (m) => {
+            switch (m) {
+              case "up":
+                if (i.index === 0) return;
+                t.move(i.index, i.index - 1);
+                break;
+              case "down":
+                if (i.index === t.length.value - 1) return;
+                t.move(i.index, i.index + 1);
+                break;
+              case "first":
+                t.move(i.index, 0);
+                break;
+              case "last":
+                t.move(i.index, t.length.value - 1);
+            }
+          },
+          canMove: (m) => {
+            const p = (() => {
+              switch (m) {
+                case "up":
+                  return ge(i.index > 0);
+                case "down":
+                  return t.length.map((_) => i.index < _ - 1);
+              }
+            })();
+            return c.push(() => p.dispose()), p;
+          },
+          cannotMove: (m) => {
+            const p = (() => {
+              switch (m) {
+                case "up":
+                  return ge(i.index === 0);
+                case "down":
+                  return t.length.map((_) => i.index === _ - 1);
+              }
+            })();
+            return c.push(() => p.dispose()), p;
+          }
+        })
+      );
+    },
+    n
+  );
+}
+const _e = {
+  9: { pattern: /^[0-9]$/ },
+  A: { pattern: /^[A-Za-z]$/, transform: (t) => t.toUpperCase() },
+  "*": { pattern: /^.$/ }
+}, Ne = (t) => t instanceof RegExp;
+function Ue(t, e, n) {
+  if (t == null) return [];
+  const l = n ? { ..._e, ...e } : e ?? _e, i = (c, m) => {
+    const p = l[m];
+    p ? c.push({ type: "pattern", name: m, ...p }) : c.push({ type: "literal", char: m });
+  }, x = [];
+  if (typeof t == "string") {
+    for (const c of t) i(x, c);
+    return x;
+  }
+  for (const c of t)
+    if (typeof c == "string")
+      if (c.length <= 1) i(x, c);
+      else for (const m of c) i(x, m);
+    else Ne(c) ? x.push({ type: "pattern", pattern: c }) : typeof c == "object" && c && x.push(c);
+  return x;
+}
+function Pe(t, e) {
+  return (n) => {
+    switch (t) {
+      case "digits":
+        return /[0-9]/.test(n);
+      case "letters":
+        return /[A-Za-z]/.test(n);
+      case "alphanumeric":
+        return /[A-Za-z0-9]/.test(n);
+      case "custom":
+        return e?.(n) ?? !0;
+      default:
+        return !0;
+    }
+  };
+}
+function ke(t, e, n, l, i, x) {
+  const c = {
+    raw: t,
+    previousConformed: e,
+    cursor: i ?? t.length,
+    completed: !1
+  }, m = l.definitions ?? {}, p = typeof n == "function" ? n(t, c) : n, _ = Ue(
+    p,
+    m,
+    l.useDefaultDefinitions ?? !0
+  ), h = Pe(l.allowMode, l.allow), b = /* @__PURE__ */ new Set();
+  for (const g of _) g.type === "literal" && b.add(g.char);
+  if (l.prefix) for (const g of l.prefix) b.add(g);
+  if (l.suffix) for (const g of l.suffix) b.add(g);
+  const k = Array.from(t).filter((g) => h(g) && !b.has(g));
+  if (k.length === 0) return { value: "", cursor: 0, completed: !1 };
+  const o = [], a = [];
+  let D = 0, z = 0, d = 0, y = -1;
+  for (const g of _) {
+    if (g.type === "literal") {
+      o.push(g.char), a.push({ kind: "literal", filled: !0 });
+      continue;
+    }
+    z += g.optional ? 0 : 1;
+    const $ = k[D];
+    if ($ == null)
+      break;
+    if (g.type === "any") {
+      d++, o.push(g.transform ? g.transform($) : $), a.push({ kind: "slot", filled: !0 }), y = a.length - 1, D++;
+      continue;
+    }
+    if (g.type === "pattern")
+      if (g.pattern.test($)) {
+        d++;
+        const V = g.transform ? g.transform($) : $;
+        o.push(V), a.push({ kind: "slot", filled: !0 }), y = a.length - 1, D++;
+      } else {
+        D++;
+        continue;
+      }
+  }
+  const I = o.join(""), C = (l.prefix ?? "") + I + (l.suffix ?? "");
+  let w = (l.prefix ?? "").length;
+  if (y >= 0) {
+    let g = y + 1;
+    if ((x?.policy ?? "smart") !== "sticky")
+      for (; g < a.length && a[g].kind === "literal"; ) g++;
+    w += g;
+  }
+  const r = l.completion?.mode === "min" ? (l.completion.minChars ?? 0) <= d : l.completion?.mode === "custom" ? !!l.completion.isComplete?.(C) : z > 0 && d >= z, u = l.pipe?.(C, { ...c, completed: r });
+  let M, T = w;
+  return u === !1 ? (M = e, T = e.length) : typeof u == "string" ? (M = u, T = u.length) : typeof u == "object" && u ? (M = u.value, T = u.cursor ?? u.value.length) : M = C, { value: M, cursor: T, completed: r };
+}
+function We(t, e) {
+  const n = e?.strategy ?? "none";
+  return n === "custom" && e?.unmask ? e.unmask(t) : n === "strip" ? t.replace(/[^A-Za-z0-9]/g, "") : t;
+}
+const ze = (t) => {
+  const {
+    value: e,
+    onBlur: n,
+    onChange: l,
+    onInput: i,
+    onAccept: x,
+    onComplete: c,
+    mask: m,
+    definitions: p,
+    useDefaultDefinitions: _,
+    extraLiterals: h,
+    prefix: b,
+    suffix: k,
+    autofix: o,
+    pipe: a,
+    completion: D,
+    unmask: z,
+    allowMode: d,
+    allow: y,
+    placeholder: I,
+    placeholderOptions: C
+  } = t, L = F(
+    e,
+    m,
+    p,
+    _,
+    h,
+    b,
+    k,
+    o,
+    D,
+    z,
+    d,
+    I,
+    C
+  )((r, u, M, T, g, $, V, Y, G, Z, P, Q, j) => u ? ke(r ?? "", "", u, {
+    definitions: M ?? {},
+    useDefaultDefinitions: T ?? !0,
+    extraLiterals: g ?? [],
+    autofix: Y ?? "none",
+    completion: G ?? { mode: "mask" },
+    pipe: a ?? ((A) => A),
+    unmask: Z ?? { strategy: "none" },
+    allowMode: P ?? "all",
+    allow: y,
+    prefix: $,
+    suffix: V
+  }).value : r ?? ""), w = (r, u) => {
+    const M = r.value ?? "", T = f.get(e) ?? "", g = m != null ? f.get(m) : null, $ = p != null ? f.get(p) : void 0, V = _ != null ? f.get(_) : void 0, Y = h != null ? f.get(h) : void 0, G = o != null ? f.get(o) : void 0, Z = D != null ? f.get(D) : void 0, P = z != null ? f.get(z) : void 0, Q = d != null ? f.get(d) : void 0, j = b != null ? f.get(b) : void 0, A = k != null ? f.get(k) : void 0, {
+      value: W,
+      cursor: le,
+      completed: he
+    } = g ? ke(
+      M,
+      T,
+      g,
+      {
+        definitions: $ ?? {},
+        useDefaultDefinitions: V ?? !0,
+        extraLiterals: Y ?? [],
+        autofix: G ?? "none",
+        completion: Z ?? { mode: "mask" },
+        pipe: a ?? ((Ae) => Ae),
+        unmask: P ?? { strategy: "none" },
+        allowMode: Q ?? "all",
+        allow: y,
+        prefix: j,
+        suffix: A
+      },
+      r.selectionStart ?? M.length,
+      t.cursor ? f.get(t.cursor) : void 0
+    ) : { value: M, cursor: M.length, completed: !0 };
+    if (W !== M) {
+      r.value = W;
+      try {
+        r.setSelectionRange(le, le);
+      } catch {
+      }
+    }
+    const ve = We(W, P);
+    x?.({
+      raw: ve,
+      conformed: W,
+      completed: he,
+      cursor: le
+    }), u === "input" ? i?.(W) : (l?.(W), he && c?.({ raw: ve, conformed: W }));
+  };
+  return q({
+    ...t,
+    input: te.text(
+      ne(t),
+      s.value(L),
+      s.class("bc-input"),
+      n != null ? U.blur(n) : S,
+      Ie(
+        (r) => r instanceof HTMLInputElement ? N(
+          U.input(() => w(r, "input")),
+          U.change(() => w(r, "change")),
+          U.keydown((u) => {
+            if (u.key !== "Backspace" || !(t.cursor ? f.get(t.cursor)?.backspaceRubberBand ?? !0 : !0)) return;
+            const T = r.selectionStart ?? 0, g = r.selectionEnd ?? T;
+            if (T !== g || T <= 0) return;
+            const $ = r.value ?? "", V = m != null ? f.get(m) : null;
+            if (!V) return;
+            const Y = p != null ? f.get(p) : void 0, G = _ != null ? f.get(_) : !0, Z = b != null ? f.get(b) : void 0, P = k != null ? f.get(k) : void 0, Q = Ue(
+              typeof V == "function" ? V($, {
+                raw: $,
+                previousConformed: $,
+                cursor: T,
+                completed: !1
+              }) : V,
+              Y ?? {},
+              G ?? !0
+            ), j = /* @__PURE__ */ new Set();
+            for (const A of Q)
+              A.type === "literal" && j.add(A.char);
+            if (Z) for (const A of Z) j.add(A);
+            if (P) for (const A of P) j.add(A);
+            if (j.has($[T - 1])) {
+              let A = T - 1;
+              for (; A >= 0 && j.has($[A]); ) A--;
+              A >= 0 && (u.preventDefault(), u.stopPropagation(), r.value = $.slice(0, A) + $.slice(A + 1), w(r, "input"));
+            }
+          })
+        ) : S
+      )
+    )
+  });
+}, Ce = (t) => {
+  if (t == null || t === "") return null;
+  const e = Number(t);
+  return Number.isNaN(e) ? null : e;
+}, ot = (t) => {
+  const { value: e, step: n, min: l, max: i, onBlur: x, onChange: c, onInput: m, after: p } = t, _ = (o) => {
+    const a = l != null ? f.get(l) : void 0, D = i != null ? f.get(i) : void 0;
+    return a != null && o < a ? a : D != null && o > D ? D : o;
+  }, h = (() => {
+    if (n == null) return null;
+    const o = F(
+      e,
+      l
+    )((y, I) => {
+      const C = y ?? 0;
+      return I == null ? !0 : C > I;
+    }), a = F(
+      e,
+      i
+    )((y, I) => {
+      const C = y ?? 0;
+      return I == null ? !0 : C < I;
+    }), D = (y) => {
+      const I = f.get(e) ?? 0, C = f.get(n), L = y?.shiftKey ? 10 : 1, w = ie(I - C * L, C), r = l != null ? f.get(l) : void 0;
+      if (r != null && w < r) return;
+      const u = _(w);
+      u !== I && (c?.(u), m?.(u));
+    }, z = (y) => {
+      const I = f.get(e) ?? 0, C = f.get(n), L = y?.shiftKey ? 10 : 1, w = ie(I + C * L, C), r = i != null ? f.get(i) : void 0;
+      if (r != null && w > r) return;
+      const u = _(w);
+      u !== I && (c?.(u), m?.(u));
+    };
+    return ((y, I) => Ve(
+      s.class("bc-number-input-steppers"),
+      v.button(
+        s.type("button"),
+        s.class(
+          "bc-button bc-number-input-steppers-button bc-number-input-steppers-button--increment"
+        ),
+        s.disabled(
+          F(
+            a,
+            t.disabled ?? !1
+          )((C, L) => !C || L)
+        ),
+        U.click((C) => z(C)),
+        ue.label(y),
+        O({ icon: "line-md:plus", size: "xs" })
+      ),
+      v.button(
+        s.type("button"),
+        s.class(
+          "bc-button bc-number-input-steppers-button bc-number-input-steppers-button--decrement"
+        ),
+        s.disabled(
+          F(
+            o,
+            t.disabled ?? !1
+          )((C, L) => !C || L)
+        ),
+        U.click((C) => D(C)),
+        ue.label(I),
+        O({ icon: "line-md:minus", size: "xs" })
+      )
+    ))(
+      pe.incrementValue,
+      pe.decrementValue
+    );
+  })(), b = $e(
+    e,
+    t.disabled,
+    c ?? m
+  ), k = p != null && h != null ? N(h, b, p) : p != null ? N(b, p) : h != null ? N(h, b) : b;
+  return q({
+    ...t,
+    input: te.number(
+      // min/max attributes and reactive watchers (no forced correction)
+      l != null ? s.min(l) : S,
+      i != null ? s.max(i) : S,
+      ne(t),
+      // Represent null as empty string so the field can be cleared
+      s.value(f.map(e, (o) => o == null ? "" : String(o))),
+      s.step(n),
+      s.class("bc-input bc-number-input"),
+      x != null ? U.blur(H(x)) : S,
+      c != null ? U.change(
+        H((o) => {
+          const a = Ce(o);
+          c(a);
+        })
+      ) : S,
+      m != null ? U.input(
+        H((o) => {
+          const a = Ce(o);
+          m(a);
+        })
+      ) : S,
+      // Wheel support when step is defined
+      n != null ? U.wheel((o) => {
+        o.preventDefault();
+        const a = f.get(e) ?? 0, D = f.get(n), z = o.shiftKey ? 10 : 1, d = o.deltaY < 0 ? D * z : -D * z, y = _(ie(a + d, D));
+        y !== a && (c?.(y), m?.(y));
+      }) : S
+    ),
+    after: k
+  });
+}, ct = (t) => {
+  const e = {
+    type: "pattern",
+    pattern: /[0-9A-Fa-f]/,
+    transform: (i) => i.toLowerCase()
+  }, n = [
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    "-",
+    e,
+    e,
+    e,
+    e,
+    "-",
+    e,
+    e,
+    e,
+    e,
+    "-",
+    e,
+    e,
+    e,
+    e,
+    "-",
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e,
+    e
+  ], l = t.class ? f.map(t.class, (i) => `bc-uuid-input ${i}`) : "bc-uuid-input";
+  return ze({
+    ...t,
+    class: l,
+    mask: n,
+    // Sensible default placeholder; can be overridden via options.placeholder
+    placeholder: t.placeholder ?? "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+  });
+}, Ze = /^P(\d+([YMWD]|$)){0,4}(T(\d+([HMS]|$)){0,3})?$/i, He = /^P(?:(\d+Y)?(\d+M)?(\d+W)?(\d+D)?)(T(\d+H)?(\d+M)?(\d+S)?)?$/i;
+function Ye(t) {
+  return {
+    mask: null,
+    allowMode: "custom",
+    allow: (e) => /[0-9ptwdhms]/i.test(e),
+    pipe: (e) => {
+      const n = e.toUpperCase();
+      return n.length === 0 ? n : !n.startsWith("P") || !Ze.test(n) ? !1 : n;
+    },
+    completion: {
+      mode: "custom",
+      isComplete: (e) => {
+        const n = e.toUpperCase();
+        if (!He.test(n)) return !1;
+        try {
+          return t(n), !0;
+        } catch {
+          return !1;
+        }
+      }
+    }
+  };
+}
+const De = (t, e) => {
+  if (t == null) return null;
+  try {
+    return t.Duration.from(e);
+  } catch {
+    return null;
+  }
+}, at = (t) => {
+  const { value: e, onChange: n, onInput: l, after: i, disabled: x, onBlur: c } = t, m = () => {
+    const h = $e(e, x, n ?? l);
+    return i != null ? N(h, i) : h;
+  }, p = t.placeholder != null ? S : s.placeholder("P0DT0H0M0S");
+  return Ee(
+    (h) => {
+      const b = Fe(
+        t,
+        (k) => k?.toString() ?? "",
+        (k) => k === "" ? null : h.Duration.from(k)
+      );
+      return ze({
+        ...b,
+        onInput: void 0,
+        ...Ye(h.Duration.from),
+        placeholder: "P0DT0H0M0S",
+        after: m()
+      });
+    },
+    { pending: () => {
+      const h = (b) => (k) => {
+        const a = k.currentTarget?.value ?? "";
+        if (a === "") {
+          b(null);
+          return;
+        }
+        const D = globalThis.Temporal, z = De(D, a);
+        if (z != null) {
+          b(z);
+          return;
+        }
+        de().then((d) => {
+          const y = De(d, a);
+          y != null && b(y);
+        }).catch(() => {
+        });
+      };
+      return q({
+        ...t,
+        input: te.text(
+          ne(t),
+          s.value(f.map(e, (b) => b?.toString() ?? "")),
+          s.class("bc-input"),
+          p,
+          c != null ? U.blur(() => c()) : S,
+          n != null ? U.change(h(n)) : S,
+          l != null ? U.input(h(l)) : S
+        ),
+        after: m()
+      });
+    } }
+  );
+}, ut = (t) => {
+  const { value: e, onBlur: n, onChange: l, onInput: i } = t;
+  return q({
+    ...t,
+    input: te.url(
+      ne(t),
+      s.value(e),
+      s.class("bc-input"),
+      n != null ? U.blur(H(n)) : S,
+      l != null ? U.change(H(l)) : S,
+      i != null ? U.input(H(i)) : S
+    )
+  });
+};
+function Ge(t, e) {
+  const {
+    onMove: n,
+    cannotMoveUp: l,
+    cannotMoveDown: i,
+    onRemove: x,
+    showMove: c = !0,
+    showRemove: m = !0,
+    removeDisabled: p,
+    showMoveButtons: _ = !0,
+    layout: h = "aside"
+  } = t, b = f.toSignal(h).map((a) => a === "aside"), k = B(
+    c,
+    () => v.div(
+      s.class("bc-list-item-controls__move"),
+      fe(
+        {
+          size: "xs",
+          roundedness: "full",
+          variant: "text",
+          onClick: () => n("up"),
+          disabled: l
+        },
+        E(
+          R,
+          (a) => O({
+            size: "xs",
+            icon: "line-md:arrow-up",
+            title: a.$.incrementValue
+          })
+        )
+      ),
+      fe(
+        {
+          size: "xs",
+          roundedness: "full",
+          variant: "text",
+          onClick: () => n("down"),
+          disabled: i
+        },
+        E(
+          R,
+          (a) => O({
+            size: "xs",
+            icon: "line-md:arrow-down",
+            title: a.$.decrementValue
+          })
+        )
+      )
+    )
+  ), o = B(
+    m,
+    () => E(
+      R,
+      (a) => ee({
+        size: "xs",
+        label: f.map(a.$.removeItem, (D) => D.toLowerCase()),
+        color: "danger",
+        disabled: p,
+        onClick: x
+      })
+    )
+  );
+  return B(
+    b,
+    () => v.div(
+      s.class("bc-list-item-controls bc-list-item-controls--aside"),
+      v.div(s.class("bc-list-item-controls__content"), e),
+      v.div(
+        s.class("bc-list-item-controls__actions"),
+        B(_, () => k),
+        o
+      )
+    ),
+    () => v.div(
+      s.class("bc-list-item-controls bc-list-item-controls--below"),
+      v.div(s.class("bc-list-item-controls__content"), e),
+      v.div(
+        s.class("bc-list-item-controls__actions"),
+        B(
+          _,
+          () => k,
+          () => v.div()
+        ),
+        o
+      )
+    )
+  );
+}
+const Je = (t) => {
+  const {
+    controller: e,
+    element: n,
+    separator: l,
+    showMove: i = !0,
+    showRemove: x = !0,
+    showAdd: c = !0,
+    createItem: m,
+    addLabel: p,
+    controlsLayout: _ = "aside",
+    removeDisabled: h,
+    addDisabled: b
+  } = t, k = B(
+    F(c, m)((o, a) => o && a != null),
+    () => ye(
+      s.class(
+        "bc-group--gap-2 bc-group--align-center bc-group--justify-center"
+      ),
+      fe(
+        {
+          size: "sm",
+          variant: "filled",
+          onClick: () => e.push(m()),
+          disabled: F(
+            e.disabled,
+            b ?? !1
+          )(
+            (o, a) => o || a
+          )
+        },
+        E(
+          R,
+          (o) => ye(
+            s.class("bc-group--gap-2"),
+            O({ icon: "line-md:plus" }),
+            p ?? o.$.addLabel
+          )
+        )
+      )
+    )
+  );
+  return N(
+    je(
+      e,
+      (o) => Ge(
+        {
+          onMove: o.move,
+          cannotMoveUp: o.cannotMove("up"),
+          cannotMoveDown: o.cannotMove("down"),
+          onRemove: o.remove,
+          showMove: i,
+          showRemove: x,
+          removeDisabled: h,
+          showMoveButtons: e.signal.map((a) => a.length > 1),
+          layout: _
+        },
+        n(o)
+      ),
+      l
+    ),
+    k
+  );
+}, ft = (t, ...e) => {
+  const {
+    controller: n,
+    element: l,
+    separator: i,
+    showMove: x,
+    showRemove: c,
+    showAdd: m,
+    createItem: p,
+    addLabel: _,
+    controlsLayout: h,
+    removeDisabled: b,
+    addDisabled: k,
+    ...o
+  } = t;
+  return Le(
+    {
+      ...o,
+      content: Je({
+        controller: n,
+        element: l,
+        separator: i,
+        showMove: x,
+        showRemove: c,
+        showAdd: m,
+        createItem: p,
+        addLabel: _,
+        controlsLayout: h,
+        removeDisabled: b,
+        addDisabled: k
+      })
+    },
+    ...e
+  );
+};
+class pt extends re {
+  /** The immutable list of branch definitions for this union */
+  branches;
+  /** Reactive signal containing the key of the currently active branch */
+  activeBranch;
+  /** @internal Reactive signal containing the controller for the active branch */
+  #t;
+  /** @internal Cache of lazily-created branch controllers */
+  #e = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new UnionController.
+   *
+   * @param path - The path segments identifying this controller in the form tree
+   * @param change - Callback to propagate value changes to the parent
+   * @param signal - Reactive signal holding the current union value
+   * @param status - Reactive signal holding the current validation status
+   * @param parent - Parent context providing disabled state and optional validation mode
+   * @param branches - Array of branch definitions describing the possible value types
+   * @param equals - Optional equality function for comparing values. Defaults to `strictEqual`.
+   */
+  constructor(e, n, l, i, x, c, m = J) {
+    super(e, n, l, i, x, m), this.branches = c;
+    const p = (h) => {
+      for (const b of c)
+        if (b.detect(h))
+          return b.key;
+      return c[0]?.key ?? "unknown";
+    };
+    this.activeBranch = l.map(p, J);
+    const _ = (h) => {
+      if (this.#e.has(h))
+        return this.#e.get(h);
+      const b = c.find((o) => o.key === h);
+      if (!b)
+        throw new Error(`Unknown branch: ${h}`);
+      const k = new re(
+        [...e, h],
+        (o) => {
+          this.change(o);
+        },
+        this.signal.map(
+          (o) => b.detect(o) ? o : b.defaultValue(),
+          m
+        ),
+        i.map(we([h])),
+        {
+          disabled: this.disabled,
+          validationMode: this.parent.validationMode
+        },
+        m
+      );
+      return this.#e.set(h, k), k;
+    };
+    this.#t = this.activeBranch.map(
+      (h) => _(h),
+      J
+    ), this.onDispose(() => {
+      for (const h of this.#e.values())
+        h.dispose();
+      this.#e.clear(), this.activeBranch.dispose(), this.#t.dispose();
+    });
+  }
+  /**
+   * Gets the controller for the currently active branch.
+   *
+   * The returned controller's value and type correspond to the branch that
+   * matches the current union value.
+   *
+   * @returns The `Controller<unknown>` for the active branch
+   */
+  get activeController() {
+    return f.get(this.#t);
+  }
+  /**
+   * Gets or creates a controller for a specific branch by key.
+   *
+   * Controllers are created lazily and cached for subsequent calls.
+   *
+   * @param branchKey - The unique key of the branch to get a controller for
+   * @returns The `Controller<unknown>` for the specified branch
+   * @throws Error if the branch key is not found in the branches array
+   */
+  getBranchController(e) {
+    const n = this.branches.find((i) => i.key === e);
+    if (!n)
+      throw new Error(`Unknown branch: ${e}`);
+    if (this.#e.has(e))
+      return this.#e.get(e);
+    const l = new re(
+      [...this.path, e],
+      (i) => {
+        this.change(i);
+      },
+      this.signal.map(
+        (i) => n.detect(i) ? i : n.defaultValue(),
+        J
+      ),
+      this.status.map(we([e])),
+      {
+        disabled: this.disabled,
+        validationMode: this.parent.validationMode
+      },
+      J
+    );
+    return this.#e.set(e, l), l;
+  }
+  /**
+   * Switches the union value to a different branch.
+   *
+   * Attempts the following in order:
+   * 1. If already on the target branch, returns `true` immediately
+   * 2. If the branch has a `convert` function, tries to convert the current value
+   * 3. If conversion fails and `confirmChange` is true, prompts the user with `window.confirm`
+   * 4. Sets the value to the branch's default value
+   *
+   * @param branchKey - The key of the branch to switch to
+   * @param confirmChange - If true, prompts the user before losing the current value when conversion fails
+   * @returns `true` if the switch was successful, `false` if the user cancelled
+   * @throws Error if the branch key is not found in the branches array
+   */
+  switchToBranch(e, n = !1) {
+    const l = this.branches.find((c) => c.key === e);
+    if (!l)
+      throw new Error(`Unknown branch: ${e}`);
+    const i = f.get(this.signal);
+    if (l.detect(i))
+      return !0;
+    if (l.convert) {
+      const c = l.convert(i);
+      if (c.ok)
+        return this.change(c.value), !0;
+    }
+    if (n && typeof window == "object" && typeof window.confirm == "function" && !window.confirm(pe.changeTypeConfirmation))
+      return !1;
+    const x = l.defaultValue();
+    return this.change(x), !0;
+  }
+  /**
+   * Gets the {@link UnionBranch} definition for the currently active branch.
+   *
+   * @returns The active branch definition, or `undefined` if no branch matches
+   */
+  get activeBranchDefinition() {
+    const e = f.get(this.activeBranch);
+    return this.branches.find((n) => n.key === e);
+  }
+}
+function dt(t) {
+  return t.transform(
+    (e) => e ?? null,
+    (e) => e ?? void 0
+  );
+}
+function mt(t) {
+  return t.transform(
+    (e) => e ?? "",
+    (e) => e === "" ? void 0 : e
+  );
+}
+function ht(t) {
+  return t.transform(
+    (e) => e ?? void 0,
+    (e) => e ?? null
+  );
+}
+function X(t) {
+  return t !== null && typeof t == "object" && !Array.isArray(t) && Object.prototype.toString.call(t) === "[object Object]";
+}
+function qe(t, e) {
+  if (e == null)
+    return Me(t);
+  if (t == null)
+    return e;
+  if (X(t) && X(e)) {
+    const n = { ...e };
+    for (const l of Object.keys(t))
+      n[l] === void 0 ? n[l] = Me(t[l]) : X(t[l]) && X(n[l]) && (n[l] = qe(t[l], n[l]));
+    return n;
+  }
+  return e;
+}
+function Me(t) {
+  return typeof structuredClone == "function" ? structuredClone(t) : JSON.parse(JSON.stringify(t));
+}
+export {
+  Je as B,
+  rt as F,
+  ft as L,
+  ze as M,
+  at as N,
+  ct as U,
+  Ee as W,
+  ut as a,
+  mt as b,
+  ot as c,
+  Ye as d,
+  pt as e,
+  qe as f,
+  je as g,
+  Ge as h,
+  ce as i,
+  de as j,
+  ht as k,
+  dt as t
+};