@tempots/beatui 0.30.2 → 0.31.0

package/dist/notice-Dz_BJg8D.js

@@ -0,0 +1,1467 @@
+import { Use as N, coalesce as R, aria as x, attr as o, html as b, on as D, Value as C, Empty as w, computedOf as _, When as V, dataAttr as q, input as Z, emitValue as M, prop as I, Fragment as F, emitValueAsNumber as ee, Unless as se, Ensure as te } from "@tempots/dom";
+import { a as L, B as ne, I as P, b as z, C as W } from "./translations-D4PjDB1t.js";
+const H = /* @__PURE__ */ new Map();
+function K(e) {
+  const s = H.get(e) ?? 0;
+  return H.set(e, s + 1), `${e}-${s}`;
+}
+const k = {
+  /**
+   * Creates a loading state.
+   * @param previousValue - The previous value.
+   * @returns A loading state.
+   * @public
+   */
+  notAsked: { type: "NotAsked" },
+  /**
+   * Creates a loading state.
+   * @param previousValue - The previous value.
+   * @returns A loading state.
+   * @public
+   */
+  loading(e = void 0) {
+    return { type: "Loading", previousValue: e };
+  },
+  /**
+   * Creates a successful state.
+   * @param value - The value.
+   * @returns A successful state.
+   * @public
+   */
+  success(e) {
+    return { type: "AsyncSuccess", value: e };
+  },
+  /**
+   * Creates a failure state.
+   * @param error - The error.
+   * @returns A failure state.
+   * @public
+   */
+  failure(e) {
+    return { type: "AsyncFailure", error: e };
+  },
+  /**
+   * Checks if the result is a success.
+   * @param r - The result.
+   * @returns `true` if the result is a success; otherwise, `false`.
+   * @public
+   */
+  isSuccess(e) {
+    return e.type === "AsyncSuccess";
+  },
+  /**
+   * Checks if the result is a failure.
+   * @param r - The result.
+   * @returns `true` if the result is a failure; otherwise, `false`.
+   * @public
+   */
+  isFailure(e) {
+    return e.type === "AsyncFailure";
+  },
+  /**
+   * Checks if the result is a not-asked.
+   * @param r - The result.
+   * @returns `true` if the result is not-asked; otherwise, `false`.
+   * @public
+   */
+  isNotAsked(e) {
+    return e.type === "NotAsked";
+  },
+  /**
+   * Checks if the result is a loading.
+   * @param r - The result.
+   * @returns `true` if the result is loading; otherwise, `false`.
+   * @public
+   */
+  isLoading(e) {
+    return e.type === "Loading";
+  },
+  /**
+   * Gets the value if the result is a success; otherwise, returns the alternative value.
+   * @param r - The result.
+   * @param alt - The alternative value.
+   * @returns The value if the result is a success; otherwise, the alternative value.
+   * @public
+   */
+  getOrElse(e, s) {
+    return k.isSuccess(e) ? e.value : s;
+  },
+  /**
+   * Gets the value if the result is a success; otherwise, returns the value from the alternative function.
+   * @param r - The result.
+   * @param altf - The alternative function.
+   * @returns The value if the result is a success; otherwise, the value from the alternative
+   * @public
+   * function.
+   */
+  getOrElseLazy(e, s) {
+    return k.isSuccess(e) ? e.value : s();
+  },
+  /**
+   * Gets the value if the result is a success; otherwise, returns `null`.
+   * @param r - The result.
+   * @returns The value if the result is a success; otherwise, `null`.
+   * @public
+   */
+  getOrNull(e) {
+    return k.isSuccess(e) ? e.value : null;
+  },
+  /**
+   * Gets the value if the result is a success; otherwise, returns `undefined`.
+   * @param r - The result.
+   * @returns The value if the result is a success; otherwise, `undefined`.
+   * @public
+   */
+  getOrUndefined(e) {
+    return k.isSuccess(e) ? e.value : void 0;
+  },
+  /**
+   * Gets the value of a `AsyncResult` if it is a `Success`, otherwise it throws the error contained in the `Failure`.
+   * @param r - The `AsyncResult` to get the value from.
+   * @returns The value of the `AsyncResult` if it is a `Success`.
+   */
+  getUnsafe: (e) => {
+    if (k.isSuccess(e))
+      return e.value;
+    throw k.isFailure(e) ? e.error : new Error("Cannot get value from a not-asked or loading result");
+  },
+  /**
+   * Based on the state of the result, it picks the appropriate function to call and returns the result.
+   * @param success - The function to call if the result is a success.
+   * @param failure - The function to call if the result is a failure.
+   * @param loading - The function to call if the result is loading.
+   * @param notAsked - The function to call if the result is not-asked.
+   * @returns The result of calling the appropriate function based on the state of the result.
+   * @public
+   */
+  match: (e, {
+    success: s,
+    failure: t,
+    loading: a,
+    notAsked: n = a
+  }) => k.isSuccess(e) ? s(e.value) : k.isFailure(e) ? t(e.error) : k.isNotAsked(e) ? n() : a(e.previousValue),
+  /**
+   * When the result is a success, it applies the function to the value.
+   *
+   * @param r - The result.
+   * @param apply - The function to apply.
+   * @returns The result that was passed in.
+   * @public
+   */
+  whenSuccess: (e, s) => (k.isSuccess(e) && s(e.value), e),
+  /**
+   * When the result is a failure, it applies the function to the error.
+   *
+   * @param r - The result.
+   * @param apply - The function to apply.
+   * @returns The result that was passed in.
+   * @public
+   */
+  whenFailure: (e, s) => (k.isFailure(e) && s(e.error), e),
+  /**
+   * Compares two results for equality.
+   * @param r1 - The first result.
+   * @param r2 - The second result.
+   * @param options - The options to use for comparison. By default, uses strict equality.
+   * @returns `true` if the results are equal, `false` otherwise.
+   */
+  equals: (e, s, t = {
+    valueEquals: (a, n) => a === n,
+    errorEquals: (a, n) => a === n
+  }) => e.type === "AsyncSuccess" && s.type === "AsyncSuccess" ? t.valueEquals(e.value, s.value) : e.type === "AsyncFailure" && s.type === "AsyncFailure" ? t.errorEquals(e.error, s.error) : e.type === "Loading" && s.type === "Loading" ? t.valueEquals(e.previousValue, s.previousValue) : e.type === "NotAsked" && s.type === "NotAsked",
+  /**
+   * Combines multiple results into a single result.
+   * @param results - The results to combine.
+   * @returns A single result that is a success if all the input results are successes, otherwise a failure.
+   */
+  all: (e) => {
+    const s = [];
+    for (const t of e)
+      if (k.isSuccess(t))
+        s.push(t.value);
+      else
+        return t;
+    return k.success(s);
+  },
+  /**
+   * Converts a Promise to an AsyncResult.
+   * @param p - The Promise to convert.
+   * @returns A Promise that resolves to an AsyncResult.
+   */
+  ofPromise: async (e) => {
+    try {
+      const s = await e;
+      return k.success(s);
+    } catch (s) {
+      return k.failure(s instanceof Error ? s : new Error(String(s)));
+    }
+  }
+}, $ = (e, s) => e === s || e !== e && s !== s, S = {
+  /**
+   * Creates a valid `Validation`.
+   * @returns A `Validation` that is `Valid`.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  valid: { type: "valid" },
+  /**
+   * Creates an invalid `Validation`.
+   * @param error - The error associated with the invalid value.
+   * @returns A `Validation` that is `Invalid`.
+   */
+  invalid(e) {
+    return { type: "invalid", error: e };
+  },
+  /**
+   * Checks if a `Validation` is `Valid`.
+   * @param r - The `Validation` to check.
+   * @returns `true` if the `Validation` is `Valid`, otherwise `false`.
+   */
+  isValid(e) {
+    return e.type === "valid";
+  },
+  /**
+   * Checks if a `Validation` is `Invalid`.
+   * @param r - The `Validation` to check.
+   * @returns `true` if the `Validation` is `Invalid`, otherwise `false`.
+   */
+  isInvalid(e) {
+    return e.type === "invalid";
+  },
+  /**
+   * Maps the value of a `Validation` to a new value.
+   * @param r - The `Validation` to map.
+   * @param valid - The mapping function for a valid value.
+   * @param invalid - The mapping function for an invalid value.
+   * @returns The mapped value.
+   */
+  match: (e, s, t) => S.isValid(e) ? s() : t(e.error),
+  /**
+   * Maps the value of a `Validation` to a new `Validation`.
+   * @param validation - The `Validation` to map.
+   * @param value - The value to map.
+   * @returns A new `Validation` with the mapped value.
+   */
+  toResult: (e, s) => S.match(
+    e,
+    () => m.success(s),
+    (t) => m.failure(t)
+  ),
+  /**
+   * Execute a function when the `Validation` is valid.
+   *
+   * @param r - The `Validation` to check.
+   * @param apply - The function to execute when the `Validation` is valid.
+   * @returns The `Validation` object.
+   */
+  whenValid: (e, s) => (S.isValid(e) && s(), e),
+  /**
+   * Execute a function when the `Validation` is invalid.
+   *
+   * @param r - The `Validation` to check.
+   * @param apply - The function to execute when the `Validation` is invalid.
+   * @returns The `Validation` object.
+   */
+  whenInvalid: (e, s) => (S.isInvalid(e) && s(e.error), e)
+}, m = {
+  /**
+   * Creates a successful `Result`.
+   * @param value - The value to wrap in a `Success` type.
+   * @returns A `Result` that is a `Success`.
+   * @public
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  success(e) {
+    return { type: "Success", value: e };
+  },
+  /**
+   * Creates a failure `Result`.
+   * @param error - The error to wrap in a `Failure` type.
+   * @returns A `Result` that is a `Failure`.
+   * @public
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  failure(e) {
+    return { type: "Failure", error: e };
+  },
+  /**
+   * Maps the value of a `Result` to a new value.
+   * @param r - The `Result` to map.
+   * @param f - The mapping function.
+   * @returns A new `Result` with the mapped value.
+   * @public
+   */
+  map: (e, s) => e.type === "Success" ? m.success(s(e.value)) : e,
+  /**
+   * Maps the value of a `Result` to a new `Result`.
+   * @param r - The `Result` to map.
+   * @param f - The mapping function.
+   * @returns A new `Result` with the mapped value.
+   * @public
+   */
+  flatMap: (e, s) => e.type === "Success" ? s(e.value) : e,
+  /**
+   * Converts a `Result` to an `AsyncResult`.
+   * @param r - The `Result` to convert.
+   * @returns An `AsyncResult` that is equivalent to the input `Result`.
+   * @public
+   */
+  toAsync(e) {
+    return m.match(
+      e,
+      (s) => k.success(s),
+      (s) => k.failure(s)
+    );
+  },
+  /**
+   * Converts a `Result` to a `Validation`.
+   * @param r - The `Result` to convert.
+   * @returns A `Validation` that is equivalent to the input `Result`.
+   * @public
+   */
+  toValidation(e) {
+    return m.match(
+      e,
+      () => S.valid,
+      (s) => S.invalid(s)
+    );
+  },
+  /**
+   * Checks if a `Result` is a success.
+   * @param r - The `Result` to check.
+   * @returns `true` if the `Result` is a `Success`, `false` otherwise.
+   * @public
+   */
+  isSuccess(e) {
+    return e.type === "Success";
+  },
+  /**
+   * Checks if a `Result` is a failure.
+   * @param r - The `Result` to check.
+   * @returns `true` if the `Result` is a `Failure`, `false` otherwise.
+   * @public
+   */
+  isFailure(e) {
+    return e.type === "Failure";
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns the provided default value.
+   * @param r - The `Result` to get the value from.
+   * @param alt - The default value to return if the `Result` is a `Failure`.
+   * @returns The value of the `Result` if it is a `Success`, otherwise the default value.
+   * @public
+   */
+  getOrElse(e, s) {
+    return m.isSuccess(e) ? e.value : s;
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns the result of the provided function.
+   * @param r - The `Result` to get the value from.
+   * @param altf - The function to call if the `Result` is a `Failure`.
+   * @returns The value of the `Result` if it is a `Success`, otherwise the result of the function.
+   * @public
+   */
+  getOrElseLazy(e, s) {
+    return m.isSuccess(e) ? e.value : s();
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns `null`.
+   * @param r - The `Result` to get the value from.
+   * @returns The value of the `Result` if it is a `Success`, otherwise `null`.
+   * @public
+   */
+  getOrNull(e) {
+    return m.isSuccess(e) ? e.value : null;
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns `undefined`.
+   * @param r - The `Result` to get the value from.
+   * @returns The value of the `Result` if it is a `Success`, otherwise `undefined`.
+   * @public
+   */
+  getOrUndefined(e) {
+    return m.isSuccess(e) ? e.value : void 0;
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise it throws the error contained in the `Failure`.
+   * @param r - The `Result` to get the value from.
+   * @returns The value of the `Result` if it is a `Success`.
+   */
+  getUnsafe: (e) => {
+    if (m.isSuccess(e))
+      return e.value;
+    throw e.error;
+  },
+  /**
+   * Based on the state of the result, it picks the appropriate function to call and returns the result.
+   * @param success - The function to call if the result is a success.
+   * @param failure - The function to call if the result is a failure.
+   * @returns The result of calling the appropriate function based on the state of the result.
+   * @public
+   */
+  match: (e, s, t) => m.isSuccess(e) ? s(e.value) : t(e.error),
+  /**
+   * Calls the provided function if the result is a success.
+   * @param apply - The function to call if the result is a success.
+   * @returns A function that takes a `Result` and calls the provided function if the result is a success.
+   * @public
+   */
+  whenSuccess: (e, s) => (m.isSuccess(e) && s(e.value), e),
+  whenFailure: (e, s) => (m.isFailure(e) && s(e.error), e),
+  /**
+   * Combines two results into a single result.
+   * @param r1 - The first result.
+   * @param r2 - The second result.
+   * @param combineV - The function to combine two values.
+   * @param combineE - The function to combine two errors.
+   * @returns The combined result.
+   * @public
+   */
+  combine: (e, s, t, a) => m.match(
+    e,
+    (n) => m.match(
+      s,
+      (r) => m.success(t(n, r)),
+      (r) => m.failure(r)
+    ),
+    (n) => m.match(
+      s,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (r) => m.failure(n),
+      (r) => m.failure(a(n, r))
+    )
+  ),
+  /**
+   * Compares two results for equality.
+   * @param r1 - The first result.
+   * @param r2 - The second result.
+   * @param options - The options to use for comparison. By default, uses strict equality.
+   * @returns `true` if the results are equal, `false` otherwise.
+   */
+  equals: (e, s, t = {
+    valueEquals: (a, n) => a === n,
+    errorEquals: (a, n) => a === n
+  }) => e.type === "Success" && s.type === "Success" ? t.valueEquals(e.value, s.value) : e.type === "Failure" && s.type === "Failure" ? t.errorEquals(e.error, s.error) : !1,
+  /**
+   * Combines multiple results into a single result.
+   * @param results - The results to combine.
+   * @returns A single result that is a success if all the input results are successes, otherwise a failure.
+   */
+  all: (e) => {
+    const s = [];
+    for (const t of e)
+      if (m.isSuccess(t))
+        s.push(t.value);
+      else
+        return t;
+    return m.success(s);
+  }
+};
+function ae({
+  size: e = "sm",
+  icon: s = "line-md:close",
+  disabled: t,
+  roundedness: a = "full",
+  color: n = "base",
+  onClick: r,
+  label: i
+}, ...l) {
+  return N(L, (c) => {
+    const f = R(i, c.$.closeModal);
+    return ne(
+      {
+        variant: "text",
+        size: e,
+        roundedness: a,
+        disabled: t,
+        color: n,
+        onClick: r
+      },
+      o.title(f),
+      x.label(f),
+      ...l,
+      P({ icon: s, size: e ?? "sm" })
+    );
+  });
+}
+function j(e) {
+  return `bc-label bc-label--${e}`;
+}
+const De = (...e) => b.span(o.class(j("emphasis")), ...e), re = (...e) => b.span(o.class(j("default")), ...e), ie = (...e) => b.span(o.class(j("muted")), ...e), Ee = (...e) => b.span(o.class(j("danger")), ...e), Te = (e) => {
+  const {
+    value: s,
+    onBlur: t,
+    onChange: a,
+    placeholder: n,
+    disabled: r,
+    id: i,
+    checkedIcon: l,
+    uncheckedIcon: c,
+    iconSize: f = "lg"
+  } = e, u = i ?? K("checkbox"), v = `${u}-label`, g = () => {
+    if (C.get(r ?? !1)) return;
+    const h = C.get(s);
+    a?.(!h);
+  }, y = (h) => {
+    C.get(r ?? !1) || (h.key === " " || h.key === "Enter") && (h.preventDefault(), g());
+  };
+  return z(
+    {
+      baseContainer: !0,
+      growInput: !1,
+      ...e,
+      input: b.span(
+        o.class("bc-checkbox-input"),
+        b.span(
+          o.class("bc-checkbox-input__checkbox"),
+          o.class(
+            C.map(
+              s,
+              (h) => h ? "bc-checkbox-input__checkbox--checked" : "bc-checkbox-input__checkbox--unchecked"
+            )
+          ),
+          o.class(
+            C.map(
+              r ?? !1,
+              (h) => h ? "bc-checkbox-input__checkbox--disabled" : ""
+            )
+          ),
+          o.id(u),
+          o.role("checkbox"),
+          o.tabindex(
+            C.map(
+              r ?? !1,
+              (h) => h ? -1 : 0
+            )
+          ),
+          x.checked(s),
+          x.disabled(r),
+          n != null ? x.labelledby(v) : w,
+          D.keydown(y),
+          t != null ? D.blur(t) : w,
+          P({
+            icon: _(
+              s,
+              l,
+              c
+            )(
+              (h, d, p) => h ? d ?? "akar-icons/check-box-fill" : p ?? "akar-icons/box"
+            ),
+            accessibility: "decorative",
+            size: f
+          })
+        ),
+        n != null ? b.label(
+          o.class("bc-checkbox-input__label"),
+          o.id(v),
+          o.for(u),
+          ie(n)
+        ) : w
+      )
+    },
+    D.click(g)
+  );
+}, le = b.span(
+  o.class("bc-input-wrapper__required"),
+  " *"
+);
+function ce(e) {
+  const s = ["bc-input-wrapper"];
+  return e && s.push("bc-input-wrapper--horizontal"), s.join(" ");
+}
+function oe(e, s) {
+  const t = ["bc-input-wrapper__label-text"];
+  return e ? t.push("bc-input-wrapper__label-text--error") : s ? t.push("bc-input-wrapper__label-text--disabled") : t.push("bc-input-wrapper__label-text--default"), t.join(" ");
+}
+const G = ({
+  required: e,
+  label: s,
+  labelChildren: t,
+  context: a,
+  description: n,
+  content: r,
+  error: i,
+  labelFor: l,
+  hasError: c,
+  disabled: f,
+  horizontal: u
+}, ...v) => {
+  const g = c ?? i != null, y = f ?? !1, h = u ?? !1, d = K("input-wrapper"), p = n ? `${d}-description` : void 0, E = i != null ? `${d}-error` : void 0;
+  return b.div(
+    o.class(
+      C.map(h, (T) => ce(T))
+    ),
+    s != null || a != null ? b.div(
+      o.class("bc-input-wrapper__header"),
+      b.div(
+        o.class("bc-input-wrapper__label-section"),
+        b.label(
+          o.class("bc-input-wrapper__label"),
+          l != null ? o.for(l) : w,
+          b.span(
+            o.class(
+              _(
+                g,
+                y
+              )(
+                (T, A) => oe(
+                  T ?? !1,
+                  A ?? !1
+                )
+              )
+            ),
+            s
+          ),
+          s != null && e ? le : w
+        ),
+        // Show description under label when horizontal
+        V(
+          _(
+            h,
+            n
+          )((T, A) => T && A != null),
+          () => b.div(
+            o.class(
+              "bc-input-wrapper__description bc-input-wrapper__description--under-label"
+            ),
+            o.id(p),
+            n
+          )
+        )
+      ),
+      a != null ? re(a) : w,
+      t
+    ) : w,
+    b.div(
+      o.class("bc-input-wrapper__content"),
+      // Add data attributes to help inputs inherit accessibility information
+      [p, E].filter(Boolean).length > 0 ? q.describedby(
+        [p, E].filter(Boolean).join(" ")
+      ) : w,
+      e ? q.required("true") : w,
+      V(g, () => q.invalid("true")),
+      r
+    ),
+    // Show description at bottom only when not horizontal
+    V(
+      _(
+        h,
+        n
+      )((T, A) => !T && A != null),
+      () => b.div(
+        o.class("bc-input-wrapper__description"),
+        o.id(p),
+        n
+      )
+    ),
+    i != null ? V(
+      g,
+      () => b.div(
+        o.class("bc-input-wrapper__error"),
+        o.id(E),
+        x.live("polite"),
+        // Announce errors to screen readers
+        o.role("alert"),
+        // Mark as alert for immediate attention
+        i
+      )
+    ) : null,
+    ...v
+  );
+};
+function Ie(...e) {
+  return b.div(o.class("bc-stack"), ...e);
+}
+const Ae = (e) => {
+  const s = {
+    name: "email",
+    autocomplete: "email",
+    ...e
+  }, {
+    value: t,
+    before: a,
+    onBlur: n,
+    onChange: r,
+    onInput: i,
+    placeholder: l
+  } = s, c = a ?? P({
+    icon: "line-md:email",
+    size: "sm",
+    color: "neutral"
+  });
+  return N(
+    L,
+    (f) => z({
+      ...e,
+      before: c,
+      input: Z.email(
+        W(s),
+        o.placeholder(R(l, f.$.emailPlaceholderText)),
+        o.value(t),
+        o.class("bc-input"),
+        n != null ? D.blur(M(n)) : w,
+        r != null ? D.change(M(r)) : w,
+        i != null ? D.input(M(i)) : w
+      )
+    })
+  );
+}, Ve = (e) => {
+  const {
+    value: s,
+    onBlur: t,
+    onChange: a,
+    onInput: n,
+    before: r,
+    after: i,
+    hasError: l,
+    disabled: c,
+    autocomplete: f,
+    placeholder: u,
+    ...v
+  } = e, g = {
+    name: "password",
+    disabled: c,
+    ...v
+  }, y = I(!0), h = _(
+    y,
+    f
+  )((d, p) => d ? p ?? "current-password" : "off");
+  return N(L, (d) => {
+    const p = _(
+      d.$.passwordPlaceholderText,
+      y,
+      u
+    )((T, A, Y) => A ? "•••••••••••••••" : Y ?? T), E = b.button(
+      o.type("button"),
+      o.class("bc-input-container__password-toggle"),
+      x.label(d.$.togglePasswordVisibility),
+      D.click(() => y.update((T) => !T)),
+      V(
+        y,
+        () => P({ icon: "line-md:watch" }),
+        () => P({ icon: "line-md:watch-off" })
+      )
+    );
+    return z({
+      before: r,
+      disabled: c,
+      hasError: l,
+      input: b.input(
+        W({
+          ...g,
+          autocomplete: h,
+          placeholder: p
+        }),
+        V(
+          y,
+          () => F(o.type("password")),
+          () => F(o.type("text"))
+        ),
+        o.class("bc-input"),
+        o.value(s),
+        t != null ? D.blur(M(t)) : w,
+        a != null ? D.change(M(a)) : w,
+        n != null ? D.input(M(n)) : w
+      ),
+      after: i != null ? F(E, i) : E
+    });
+  });
+}, ue = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (e, s) => () => {
+    e.markTouched(), s?.();
+  }
+), he = (e, s) => (t) => {
+  e.change(t), s?.(t);
+};
+function J(e, s) {
+  const { controller: t, onBlur: a, onChange: n, ...r } = s;
+  return e({
+    id: t.name,
+    disabled: t.disabled,
+    value: t.value,
+    hasError: t.errorVisible,
+    ...r,
+    onChange: he(t, n),
+    onBlur: ue(t, a)
+  });
+}
+function Oe(e, s, ...t) {
+  return G(
+    {
+      ...s,
+      content: J(
+        e,
+        s
+      )
+    },
+    ...t
+  );
+}
+function de(e, s) {
+  const { toInput: t, fromInput: a, controller: n, ...r } = s, i = n.transform(t, a);
+  return J(e, {
+    ...r,
+    controller: i
+  });
+}
+function Me(e, s, ...t) {
+  return G(
+    {
+      ...s,
+      content: de(e, s)
+    },
+    ...t
+  );
+}
+function $e(e) {
+  return e.split(".").map((t) => {
+    const a = t.match(/^\[(\d+)\]$/);
+    return a ? Number(a[1]) : t;
+  });
+}
+function pe(e) {
+  return typeof e == "number" ? `[${e}]` : `.${e}`;
+}
+function fe(e) {
+  if (e.length === 0) return "";
+  const [s, ...t] = e;
+  return [
+    typeof s == "number" ? `[${s}]` : s,
+    ...t.map(pe)
+  ].join("");
+}
+function B(e) {
+  return function(t) {
+    if (t.type === "valid") return t;
+    let a = t.error;
+    for (const n of e)
+      if (a = a?.dependencies?.[n], a == null) return S.valid;
+    return S.invalid(a);
+  };
+}
+class O {
+  path;
+  change;
+  value;
+  status;
+  error;
+  hasError;
+  touched;
+  errorVisible;
+  dirty;
+  dependencyErrors;
+  #e = {
+    disabled: I(!1),
+    touched: I(!1)
+  };
+  #t;
+  #s = I(void 0);
+  parent;
+  disabled;
+  #n = [];
+  disabledOrHasErrors;
+  constructor(s, t, a, n, r, i = $) {
+    this.path = s, this.change = t, this.value = a, this.status = n, this.#t = i, this.#s.set(a.value), this.error = n.map(
+      (l) => l?.type === "invalid" ? l.error?.message : void 0
+    ), this.hasError = this.error.map((l) => l != null), this.touched = this.#e.touched, r.validationMode ? this.errorVisible = _(
+      this.hasError,
+      this.touched,
+      r.validationMode
+    )((l, c, f) => f === "continuous" ? !!l : !!l && !!c) : this.errorVisible = _(
+      this.hasError,
+      this.touched
+    )((l, c) => !!l && !!c), this.dirty = _(
+      this.value,
+      this.#s
+    )((l, c) => !this.#t(l, c)), this.dependencyErrors = n.map(
+      (l) => l?.type === "invalid" ? l.error?.dependencies : void 0
+    ), this.parent = r, this.disabled = _(
+      this.#e.disabled,
+      r.disabled
+    )((l, c) => l || c), this.disabledOrHasErrors = _(
+      this.disabled,
+      this.hasError
+    )((l, c) => l || c), this.onDispose(() => {
+      this.#e.disabled.dispose(), this.#e.touched.dispose(), this.disabled.dispose(), this.error.dispose(), this.errorVisible.dispose(), this.dirty.dispose(), this.#s.dispose(), this.dependencyErrors.dispose(), this.disabledOrHasErrors.dispose();
+    });
+  }
+  get name() {
+    return fe(this.path);
+  }
+  onDispose = (s) => {
+    this.#n.push(s);
+  };
+  dispose = () => {
+    for (const s of this.#n)
+      try {
+        s();
+      } catch (t) {
+        console.error("Error in dispose callback:", t);
+      }
+    this.#n.length = 0;
+  };
+  setDisabled = (s) => {
+    this.#e.disabled.set(s);
+  };
+  disable = () => this.setDisabled(!0);
+  enable = () => this.setDisabled(!1);
+  markTouched = () => {
+    this.#e.touched.set(!0);
+  };
+  resetTouched = () => {
+    this.#e.touched.set(!1);
+  };
+  markPristine = () => {
+    this.#s.set(this.value.value);
+  };
+  reset = () => {
+    this.change(this.#s.value);
+  };
+  array = (s = $) => new me(
+    this.path,
+    this.change,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.value,
+    this.status,
+    this.parent,
+    s
+  );
+  object = (s = $) => new be(
+    this.path,
+    this.change,
+    this.value,
+    this.status,
+    this.parent,
+    s
+  );
+  transform = (s, t, a = [], n = $) => new O(
+    [...this.path, ...a],
+    (r) => this.change(t(r)),
+    this.value.map(s, n),
+    this.status.map(B(a)),
+    this.parent,
+    n
+  );
+  asyncTransform = (s, t, a, n = [], r = $) => new O(
+    [...this.path, ...n],
+    (i) => {
+      t(i).then((l) => this.change(l));
+    },
+    this.value.mapAsync(s, a, void 0, r),
+    this.status.map(B(n)),
+    this.parent,
+    r
+  );
+}
+class be extends O {
+  #e = /* @__PURE__ */ new Map();
+  #t = /* @__PURE__ */ new Map();
+  #s = /* @__PURE__ */ new Map();
+  #n = I(!1);
+  touchedDeep = this.#n;
+  #r = /* @__PURE__ */ new Map();
+  #a = /* @__PURE__ */ new Map();
+  #l = I(!1);
+  dirtyDeep = this.#l;
+  #o;
+  #u;
+  #c = () => {
+    let s = !1;
+    for (const t of this.#t.values())
+      if (t) {
+        s = !0;
+        break;
+      }
+    this.#n.set(this.touched.value || s);
+  };
+  constructor(s, t, a, n, r, i) {
+    super(
+      s,
+      t,
+      a.map((c) => c ?? {}, i),
+      n,
+      r,
+      i
+    ), this.#o = this.touched.on(() => {
+      this.#c();
+    }), this.#u = this.dirty.on(() => {
+      this.#i();
+    });
+    const l = this.value.on(() => this.#i());
+    this.onDispose(() => {
+      for (const c of this.#e.values())
+        c.dispose();
+      this.#e.clear();
+      for (const c of this.#s.values()) c();
+      this.#s.clear(), this.#t.clear(), this.#n.dispose();
+      for (const c of this.#a.values()) c();
+      this.#a.clear(), this.#r.clear(), this.#l.dispose(), this.#o(), this.#u(), l();
+    });
+  }
+  field = (s) => {
+    if (this.#e.has(s))
+      return this.#e.get(s);
+    const t = async (i) => {
+      this.change({
+        ...this.value.value,
+        [s]: i
+      });
+    }, a = new O(
+      [...this.path, s],
+      t,
+      this.value.map((i) => i[s]),
+      this.status.map(B([s])),
+      {
+        disabled: this.disabled,
+        // propagate validationMode to children if present
+        validationMode: this.parent.validationMode
+      }
+    );
+    this.#e.set(s, a);
+    const n = a.touched.on((i) => {
+      this.#t.set(s, i), this.#c();
+    });
+    this.#s.set(s, n);
+    const r = a.dirty.on((i) => {
+      this.#r.set(s, i), this.#i();
+    });
+    return this.#a.set(s, r), a;
+  };
+  markAllTouched = () => {
+    this.markTouched();
+    const s = this.value.value;
+    for (const t of Object.keys(s))
+      this.field(t).markTouched();
+    for (const t of this.#e.values())
+      t.markTouched();
+  };
+  markAllPristine = () => {
+    this.markPristine();
+    const s = this.value.value;
+    for (const t of Object.keys(s))
+      this.field(t).markPristine?.();
+    for (const t of this.#e.values())
+      t.markPristine?.();
+  };
+  #i = () => {
+    let s = !1;
+    for (const t of this.#r.values())
+      if (t) {
+        s = !0;
+        break;
+      }
+    this.#l.set(this.dirty.value || s);
+  };
+}
+class me extends O {
+  #e = new Array();
+  length;
+  #t = /* @__PURE__ */ new Map();
+  #s = /* @__PURE__ */ new Map();
+  #n = I(!1);
+  touchedDeep = this.#n;
+  #r = /* @__PURE__ */ new Map();
+  #a = /* @__PURE__ */ new Map();
+  #l = I(!1);
+  dirtyDeep = this.#l;
+  #o;
+  #u;
+  #c = () => {
+    let s = !1;
+    for (const t of this.#t.values())
+      if (t) {
+        s = !0;
+        break;
+      }
+    this.#n.set(this.touched.value || s);
+  };
+  constructor(s, t, a, n, r, i) {
+    const l = a.map((u) => u ?? [], i);
+    super(s, t, l, n, r, i);
+    const c = l.on((u) => {
+      const v = this.#e.length - u.length;
+      v > 0 && (this.#e.splice(u.length, v).forEach((g, y) => {
+        const h = u.length + y;
+        g.dispose(), this.#s.get(h)?.(), this.#s.delete(h), this.#t.delete(h), this.#a.get(h)?.(), this.#a.delete(h), this.#r.delete(h);
+      }), this.#c(), this.#i());
+    });
+    this.length = l.map((u) => u.length), this.#o = this.touched.on(() => {
+      this.#c();
+    }), this.#u = this.dirty.on(() => {
+      this.#i();
+    });
+    const f = this.value.on(() => this.#i());
+    this.onDispose(() => {
+      for (const u of this.#e)
+        u.dispose();
+      this.length.dispose(), this.#e.length = 0, c(), l.dispose();
+      for (const u of this.#s.values()) u();
+      this.#s.clear(), this.#t.clear(), this.#n.dispose();
+      for (const u of this.#a.values()) u();
+      this.#a.clear(), this.#r.clear(), this.#l.dispose(), this.#o(), this.#u(), f();
+    });
+  }
+  item = (s) => {
+    if (this.#e[s])
+      return this.#e[s];
+    const t = async (i) => {
+      const l = this.value.value.slice();
+      l[s] = i, this.change(l);
+    }, a = new O(
+      [...this.path, s],
+      t,
+      this.value.map((i) => i[s]),
+      this.status.map(B([s])),
+      {
+        disabled: this.disabled,
+        validationMode: this.parent.validationMode
+      }
+    );
+    this.#e[s] = a;
+    const n = a.touched.on((i) => {
+      this.#t.set(s, i), this.#c();
+    });
+    this.#s.set(s, n);
+    const r = a.dirty.on((i) => {
+      this.#r.set(s, i), this.#i();
+    });
+    return this.#a.set(s, r), a;
+  };
+  push = (...s) => {
+    this.change([...this.value.value, ...s]);
+  };
+  pop = () => {
+    this.splice(this.value.value.length - 1, 1);
+  };
+  shift = () => {
+    this.splice(0, 1);
+  };
+  unshift = (...s) => {
+    this.change([...s, ...this.value.value]);
+  };
+  removeAt = (s) => {
+    this.splice(s, 1);
+  };
+  splice = (s, t) => {
+    const a = this.value.value.slice();
+    a.splice(s, t), this.change(a);
+  };
+  move = (s, t, a = 1) => {
+    if (a < 1 || s === t) return;
+    const n = this.value.value.slice(), r = n.splice(s, a);
+    n.splice(t, 0, ...r), this.change(n);
+  };
+  markAllTouched = () => {
+    this.markTouched();
+    const s = this.value.value.length;
+    for (let t = 0; t < s; t++)
+      this.item(t).markTouched();
+  };
+  markAllPristine = () => {
+    this.markPristine();
+    const s = this.value.value.length;
+    for (let t = 0; t < s; t++)
+      this.item(t).markPristine?.();
+  };
+  #i = () => {
+    let s = !1;
+    for (const t of this.#r.values())
+      if (t) {
+        s = !0;
+        break;
+      }
+    this.#l.set(this.dirty.value || s);
+  };
+}
+function ve(e) {
+  function s(t) {
+    return typeof t == "number" ? t : t.toString();
+  }
+  return e.map(
+    (t) => typeof t == "object" && t.key != null ? s(t.key) : s(t)
+  );
+}
+function ye(e) {
+  const s = e.filter((n) => n.path == null || n.path.length === 0).map((n) => n.message), t = e.filter((n) => n.path != null && n.path.length > 0).reduce((n, r) => {
+    const i = ve(r.path), l = i.pop();
+    let c = n;
+    for (const f of i)
+      c.dependencies == null && (c.dependencies = {}), c.dependencies[f] == null && (c.dependencies[f] = {}), c = c.dependencies[f];
+    return c.dependencies == null && (c.dependencies = {}), c.dependencies[l] = { message: r.message }, n;
+  }, {}), a = s.join(`
+`);
+  return {
+    ...t,
+    message: a != "" ? a : void 0
+  };
+}
+function ge({
+  initialValue: e,
+  onChange: s,
+  validate: t,
+  equals: a,
+  validationMode: n,
+  validateDebounceMs: r
+}) {
+  const i = C.deriveProp(e), l = I(S.valid), c = I(!1), f = I(n ?? "touchedOrSubmit"), u = (d) => {
+    l.set(d);
+  };
+  let v;
+  const g = async (d) => {
+    if (t != null) {
+      const p = await t(d);
+      u(p);
+    }
+  }, y = async (d) => {
+    i.set(d), s?.(d);
+    const p = f.value;
+    if (t != null) {
+      if (p === "onSubmit")
+        return;
+      const E = r ?? 0;
+      E > 0 ? (v && clearTimeout(v), v = setTimeout(() => {
+        g(d);
+      }, E)) : await g(d);
+    }
+  }, h = new O(
+    [],
+    y,
+    i,
+    l,
+    {
+      disabled: c,
+      validationMode: f
+    },
+    a ?? $
+  );
+  return h.onDispose(() => {
+    c.dispose(), i.dispose(), l.dispose(), f.dispose(), v && clearTimeout(v);
+  }), { controller: h, setStatus: u };
+}
+function Q(e) {
+  return F(o.disabled(e.disabled), o.name(e.name));
+}
+function xe(e, {
+  triggerOn: s = "change"
+} = {}) {
+  return F(
+    Q(e),
+    o.value(e.value),
+    (s === "input" ? D.input : D.change)(M(e.change))
+  );
+}
+function Fe(e, {
+  triggerOn: s = "change"
+} = {}) {
+  return F(
+    Q(e),
+    o.valueAsNumber(e.value),
+    (s === "input" ? D.input : D.change)(
+      ee(e.change)
+    )
+  );
+}
+function U(e) {
+  return e.issues != null ? S.invalid(ye(e.issues)) : S.valid;
+}
+async function Pe({
+  task: e,
+  errorMessage: s,
+  errorPath: t = ["root"],
+  validation: a
+}) {
+  try {
+    const n = await e();
+    return a != null ? a(n) : S.valid;
+  } catch (n) {
+    const r = s ?? (n instanceof Error ? n.message : "Operation failed");
+    return t.length === 1 && t[0] === "root" ? S.invalid({
+      message: r
+    }) : S.invalid({
+      dependencies: X(t, r)
+    });
+  }
+}
+function X(e, s) {
+  if (e.length === 1)
+    return {
+      [e[0]]: { message: s }
+    };
+  const [t, ...a] = e;
+  return {
+    [t]: {
+      dependencies: X(a, s)
+    }
+  };
+}
+function Be({
+  initialValue: e = {},
+  schema: s,
+  onSubmit: t = async () => S.valid,
+  validationMode: a,
+  validateDebounceMs: n
+}) {
+  const { controller: r, setStatus: i } = ge({
+    initialValue: e,
+    validationMode: a ?? "touchedOrSubmit",
+    validateDebounceMs: n,
+    validate: (a ?? "touchedOrSubmit") === "onSubmit" ? void 0 : async (u) => U(
+      await s["~standard"].validate(u)
+    )
+  }), l = I(!1), c = r.object();
+  return c.onDispose(l.dispose), {
+    controller: c,
+    setStatus: i,
+    submit: async (u) => {
+      if (l.set(!0), u?.preventDefault(), c.markAllTouched(), (a ?? "touchedOrSubmit") === "onSubmit") {
+        const g = c.value.value, y = U(
+          await s["~standard"].validate(g)
+        );
+        if (i(y), y.type === "invalid") {
+          l.set(!1);
+          return;
+        }
+      }
+      const v = await t(c.value.value);
+      l.set(!1), v.type === "invalid" && i(v);
+    },
+    submitting: l
+  };
+}
+function ke(e) {
+  switch (e) {
+    case "success":
+      return "material-symbols:check-circle-outline";
+    case "warning":
+      return "material-symbols:warning-outline";
+    case "danger":
+      return "material-symbols:error-outline";
+    case "info":
+    default:
+      return "material-symbols:info-outline";
+  }
+}
+function we(e) {
+  switch (e) {
+    case "success":
+      return "success";
+    case "warning":
+      return "warning";
+    case "danger":
+      return "danger";
+    case "info":
+    default:
+      return "info";
+  }
+}
+function Se(e, s, t, a) {
+  const n = [
+    "bc-notice",
+    `bc-notice--${e}`,
+    `bc-notice--tone-${s}`
+  ];
+  return t && n.push("bc-notice--dismissible"), a && a.length > 0 && n.push(a), n.join(" ");
+}
+function Ne({
+  variant: e = "info",
+  tone: s = "subtle",
+  role: t,
+  title: a,
+  icon: n,
+  closable: r = !1,
+  onDismiss: i,
+  class: l
+}, ...c) {
+  const f = C.map(
+    r,
+    (d) => !!d || i != null
+  ), u = C.map(e, (d) => d ?? "info"), v = C.map(s, (d) => d ?? "subtle"), g = _(
+    t,
+    u
+  )(
+    (d, p) => d ?? (p === "danger" ? "alert" : "status")
+  ), y = I(!0), h = N(
+    L,
+    (d) => b.div(
+      o.class(
+        _(
+          u,
+          v,
+          f,
+          l
+        )((p, E, T, A) => Se(p, E, T, A))
+      ),
+      // Accessibility role mapping (always defined)
+      o.role(C.map(g, (p) => p)),
+      se(
+        C.map(n, (p) => p === !1),
+        () => b.div(
+          o.class("bc-notice__icon"),
+          P({
+            icon: _(
+              n,
+              u
+            )((p, E) => p === void 0 ? ke(E) : String(p)),
+            size: "md",
+            color: C.map(u, we)
+          })
+        )
+      ),
+      b.div(
+        o.class("bc-notice__body"),
+        te(a, (p) => b.div(o.class("bc-notice__title"), p)),
+        b.div(o.class("bc-notice__content"), ...c)
+      ),
+      V(
+        f,
+        () => ae({
+          size: "xs",
+          label: d.$.closeModal,
+          onClick: () => {
+            y.set(!1), i?.();
+          }
+        })
+      )
+    )
+  );
+  return V(y, () => h);
+}
+export {
+  me as A,
+  J as B,
+  ae as C,
+  Ee as D,
+  Ae as E,
+  G as I,
+  re as L,
+  Me as M,
+  Ne as N,
+  $ as O,
+  Ve as P,
+  le as R,
+  Ie as S,
+  S as a,
+  Te as b,
+  Oe as c,
+  he as d,
+  O as e,
+  B as f,
+  de as g,
+  fe as h,
+  be as i,
+  ve as j,
+  ye as k,
+  ge as l,
+  ue as m,
+  Q as n,
+  xe as o,
+  $e as p,
+  Fe as q,
+  U as r,
+  K as s,
+  Pe as t,
+  Be as u,
+  De as v,
+  pe as w,
+  ie as x
+};