@tempots/beatui 0.16.0 → 0.18.0

package/dist/translations-CxMNY8i7.js

@@ -0,0 +1,2006 @@
+var He = Object.defineProperty;
+var De = (e) => {
+  throw TypeError(e);
+};
+var Ue = (e, s, t) => s in e ? He(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var h = (e, s, t) => Ue(e, typeof s != "symbol" ? s + "" : s, t), _e = (e, s, t) => s.has(e) || De("Cannot " + t);
+var o = (e, s, t) => (_e(e, s, "read from private field"), t ? t.call(e) : s.get(e)), v = (e, s, t) => s.has(e) ? De("Cannot add the same private member more than once") : s instanceof WeakSet ? s.add(e) : s.set(e, t), z = (e, s, t, n) => (_e(e, s, "write to private field"), n ? n.call(e, t) : s.set(e, t), t);
+import { makeProviderMark as Me, localStorageProp as Ee, computedOf as T, Use as he, html as m, attr as u, When as M, Fragment as P, aria as E, coalesce as Se, style as fe, prop as $, on as S, OnDispose as Pe, Value as x, WithElement as Ge, Empty as k, dataAttr as ke, input as Ae, emitValue as B, emitValueAsNumber as ze } from "@tempots/dom";
+import { WhenInViewport as We, Resource as Ke, ElementRect as Je } from "@tempots/ui";
+function Te(e, {
+  units: s = ["B", "KB", "MB", "GB", "TB"],
+  decimalPlaces: t = 0,
+  locale: n
+} = {}) {
+  if (e === 0 || e === 0n)
+    return new Intl.NumberFormat(n, {
+      style: "unit",
+      unit: "byte",
+      unitDisplay: "short",
+      maximumFractionDigits: 0
+    }).format(0).replace("byte", s[0]);
+  let r, a;
+  if (typeof e == "bigint") {
+    let c = e < 0n ? -e : e;
+    for (r = 0; c >= 1024n && r < s.length - 1; )
+      c = c / 1024n, r++;
+    a = Number(e) / Math.pow(1024, r);
+  } else
+    r = Math.floor(Math.log(Math.abs(e)) / Math.log(1024)), r = Math.min(r, s.length - 1), a = e / Math.pow(1024, r);
+  return new Intl.NumberFormat(n, {
+    style: "unit",
+    unit: "byte",
+    unitDisplay: "short",
+    minimumFractionDigits: r === 0 ? 0 : t,
+    maximumFractionDigits: r === 0 ? 0 : t
+  }).format(a).replace("byte", s[r]);
+}
+const Ce = /* @__PURE__ */ new Map();
+function xe(e) {
+  const s = Ce.get(e) ?? 0;
+  return Ce.set(e, s + 1), `${e}-${s}`;
+}
+const _ = {
+  /**
+   * 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 _.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 _.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 _.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 _.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 (_.isSuccess(e))
+      return e.value;
+    throw _.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: n,
+    notAsked: r = n
+  }) => _.isSuccess(e) ? s(e.value) : _.isFailure(e) ? t(e.error) : _.isNotAsked(e) ? r() : n(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) => (_.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) => (_.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: (n, r) => n === r,
+    errorEquals: (n, r) => n === r
+  }) => 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 (_.isSuccess(t))
+        s.push(t.value);
+      else
+        return t;
+    return _.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 _.success(s);
+    } catch (s) {
+      return _.failure(s instanceof Error ? s : new Error(String(s)));
+    }
+  }
+}, W = (e, s) => e === s || e !== e && s !== s, C = {
+  /**
+   * 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) => C.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) => C.match(
+    e,
+    () => y.success(s),
+    (t) => y.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) => (C.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) => (C.isInvalid(e) && s(e.error), e)
+}, y = {
+  /**
+   * 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" ? y.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 y.match(
+      e,
+      (s) => _.success(s),
+      (s) => _.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 y.match(
+      e,
+      () => C.valid,
+      (s) => C.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 y.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 y.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 y.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 y.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 (y.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) => y.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) => (y.isSuccess(e) && s(e.value), e),
+  whenFailure: (e, s) => (y.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, n) => y.match(
+    e,
+    (r) => y.match(
+      s,
+      (a) => y.success(t(r, a)),
+      (a) => y.failure(a)
+    ),
+    (r) => y.match(
+      s,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (a) => y.failure(r),
+      (a) => y.failure(n(r, a))
+    )
+  ),
+  /**
+   * 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: (n, r) => n === r,
+    errorEquals: (n, r) => n === r
+  }) => 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 (y.isSuccess(t))
+        s.push(t.value);
+      else
+        return t;
+    return y.success(s);
+  }
+}, Le = {
+  loadingExtended: "Loading, please wait",
+  loadingShort: "Loading...",
+  locale: "Locale",
+  iconDescription: "Icon",
+  loadingIcon: "Loading icon",
+  failedToLoadIcon: "Failed to load icon",
+  editLabel: "Edit",
+  selectOne: "Select one",
+  selectMany: "Select many",
+  noResults: "No results",
+  passwordPlaceholderText: "Secret Password",
+  togglePasswordVisibility: "Toggle password visibility",
+  toggleMenu: "Toggle menu",
+  toggleAside: "Toggle aside",
+  mainNavigation: "Main navigation",
+  sidebar: "Sidebar",
+  closeDrawer: "Close drawer",
+  closeModal: "Close modal",
+  confirm: "Confirm",
+  cancel: "Cancel",
+  addLabel: "Add",
+  removeItem: "Remove item",
+  // languages
+  currentLocale: "English",
+  ar: "Arabic",
+  de: "German",
+  en: "English",
+  es: "Spanish",
+  fr: "French",
+  hi: "Hindi",
+  it: "Italian",
+  ja: "Japanese",
+  ko: "Korean",
+  nl: "Dutch",
+  pl: "Polish",
+  pt: "Portuguese",
+  ru: "Russian",
+  tr: "Turkish",
+  vi: "Vietnamese",
+  zh: "Chinese",
+  he: "Hebrew",
+  fa: "Persian",
+  ur: "Urdu",
+  // input
+  emailPlaceholderText: "Enter your email",
+  incrementValue: "Increment value",
+  decrementValue: "Decrement value",
+  // drop zone
+  dropZoneInstructions: (e) => e ? "Click to choose or drag files here, or press Enter or Space to open file selector" : "Drag files here",
+  // size
+  fileSizeUnits: ["Bytes", "KB", "MB", "GB", "TB"],
+  // file input
+  removeFile: "Remove file",
+  clearAllFiles: "Clear all files",
+  // inputs reset
+  clearValue: "Reset",
+  unknownType: "Unknown type",
+  filesInputInstructions: (e, s, t) => {
+    let n = e == null || e > 1 ? "Click to choose or drag files here" : "Click to choose or drag a file here";
+    if (e || s) {
+      const r = [];
+      if (e != null && e > 1 && r.push(`up to ${e} files`), s && t) {
+        const a = Te(s, {
+          units: t
+        });
+        r.push(`max ${a} each`);
+      }
+      r.length > 0 && (n += ` (${r.join(", ")})`);
+    } else if (s && t) {
+      const r = Te(s, {
+        units: t
+      });
+      n += ` (max ${r})`;
+    }
+    return n;
+  }
+}, Ye = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Le
+}, Symbol.toStringTag, { value: "Module" })), Ze = Le, Qe = "en", Xe = (e, s, t) => {
+  const n = e[s];
+  return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((r, a) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(
+      a.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + s + (s.split("/").length !== t ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+}, et = /* @__PURE__ */ new Set([
+  "ar",
+  // Arabic
+  "he",
+  // Hebrew
+  "fa",
+  // Persian/Farsi
+  "ur",
+  // Urdu
+  "ps",
+  // Pashto
+  "sd",
+  // Sindhi
+  "ku",
+  // Kurdish
+  "dv",
+  // Divehi/Maldivian
+  "yi",
+  // Yiddish
+  "ji",
+  // Yiddish (alternative code)
+  "iw",
+  // Hebrew (deprecated, but still used)
+  "in"
+  // Indonesian (deprecated, but sometimes confused)
+]);
+function Oe(e) {
+  if (!e) return "ltr";
+  const s = e.split(/[-_]/)[0].toLowerCase();
+  return et.has(s) ? "rtl" : "ltr";
+}
+function tt(e, s) {
+  return e === "auto" ? Oe(s) : e;
+}
+function Ot(e) {
+  return `b-${e}`;
+}
+function Vt(e) {
+  return Oe(e) === "rtl";
+}
+function Bt(e) {
+  return e === "ltr" ? "rtl" : "ltr";
+}
+const st = {
+  ltr: {
+    "inline-start": "left",
+    "inline-end": "right",
+    "block-start": "top",
+    "block-end": "bottom"
+  },
+  rtl: {
+    "inline-start": "right",
+    "inline-end": "left",
+    "block-start": "top",
+    "block-end": "bottom"
+  }
+};
+function jt(e, s) {
+  return st[s][e];
+}
+const nt = {
+  mark: Me("Locale"),
+  create: (e) => {
+    const s = Ee({
+      defaultValue: navigator.language ?? "en-US",
+      key: "beatui-locale"
+    }), t = Ee({
+      defaultValue: "auto",
+      key: "beatui-direction-preference"
+    }), n = T(
+      s,
+      t
+    )(
+      (a, l) => tt(l, a)
+    );
+    return {
+      value: {
+        locale: s,
+        setLocale: (a) => s.set(a),
+        direction: n,
+        directionPreference: t,
+        setDirectionPreference: (a) => t.set(a)
+      },
+      dispose: () => {
+        s.dispose(), t.dispose(), n.dispose();
+      }
+    };
+  }
+}, rt = "bui-icons", me = /* @__PURE__ */ new Map(), Ve = (() => {
+  try {
+    return typeof indexedDB < "u" && indexedDB !== null;
+  } catch {
+    return !1;
+  }
+})();
+function at() {
+  return Ve ? new Promise((e, s) => {
+    const t = indexedDB.open(rt, 1);
+    t.onupgradeneeded = function(n) {
+      const r = n.target.result;
+      r.objectStoreNames.contains("icons") || r.createObjectStore("icons");
+    }, t.onsuccess = function() {
+      e(t.result);
+    }, t.onerror = function() {
+      s(t.error);
+    };
+  }) : Promise.reject(new Error("IndexedDB not available"));
+}
+const be = Ve ? at() : null;
+function it(e, s) {
+  return new Promise(async (t, n) => {
+    try {
+      if (be) {
+        const a = (await be).transaction("icons", "readwrite");
+        a.objectStore("icons").put(s, e), a.oncomplete = t, a.onerror = n;
+      } else
+        me.set(e, s), t(void 0);
+    } catch {
+      me.set(e, s), t(void 0);
+    }
+  });
+}
+function ot(e) {
+  return new Promise(async (s, t) => {
+    try {
+      if (be) {
+        const l = (await be).transaction("icons", "readonly").objectStore("icons").get(e);
+        l.onsuccess = function() {
+          s(l.result);
+        }, l.onerror = t;
+      } else
+        s(me.get(e) || null);
+    } catch {
+      s(me.get(e) || null);
+    }
+  });
+}
+async function lt(e) {
+  const s = `https://api.iconify.design/${e}.svg`;
+  return fetch(s).then((t) => {
+    if (t.status === 200)
+      return t.text();
+    throw new Error(`Failed to load icon: ${e}`);
+  });
+}
+async function ct(e) {
+  const s = e.replace(":", "/"), t = await ot(s);
+  if (t)
+    return t;
+  const n = await lt(s);
+  return await it(s, n), n;
+}
+function ut(e, s) {
+  const t = ["bc-icon", `bc-icon--${e}`];
+  return s && t.push(`bu-fg-${s}`), t.join(" ");
+}
+function ae({ icon: e, size: s = "md", color: t, title: n, accessibility: r = "auto" }, ...a) {
+  const l = T(
+    r,
+    n
+  )((i, c) => i === "decorative" ? !1 : i === "informative" ? !0 : c != null && c !== "");
+  return he(
+    pe,
+    (i) => m.span(
+      u.class("bu-content-box"),
+      u.class(
+        T(
+          s,
+          t
+        )((c, p) => ut(c ?? "md", p))
+      ),
+      // Add accessibility attributes based on icon type
+      M(
+        l,
+        () => P(
+          u.role("img"),
+          E.label(Se(n, i.$.iconDescription))
+        ),
+        () => E.hidden(!0)
+      ),
+      We(
+        { once: !0 },
+        () => Ke({
+          request: e,
+          load: ({ request: c }) => ct(c),
+          mapError: String
+        })({
+          success: (c) => m.span(
+            fe.width("100%"),
+            fe.height("100%"),
+            u.innerHTML(c)
+          ),
+          loading: () => m.span(
+            u.class("animate-spin"),
+            // Loading state accessibility
+            M(
+              l,
+              () => P(u.role("img"), E.label(i.$.loadingIcon)),
+              () => E.hidden(!0)
+            ),
+            "↻"
+          ),
+          failure: (c) => m.span(
+            u.title(c),
+            u.class("text-red-500"),
+            // Error state accessibility
+            M(
+              l,
+              () => P(u.role("img"), E.label(i.$.failedToLoadIcon)),
+              () => E.hidden(!0)
+            ),
+            "🚫"
+          )
+        })
+      ),
+      ...a
+    )
+  );
+}
+function dt(e, s, t, n, r, a) {
+  const l = [
+    "bc-button",
+    `bu-text-${s}`,
+    `bc-control--padding-${s}`,
+    `bu-rounded-${n}`
+  ];
+  switch (a && l.push("bc-button--loading"), e) {
+    case "filled":
+      l.push(`bu-bg-${t}`), r || l.push(`hover:bu-bg-${t}`);
+      break;
+    case "light":
+      l.push(`bu-bg-light-${t}`), r || l.push(`hover:bu-bg-light-${t}`);
+      break;
+    case "outline":
+      l.push(`bu-border--${t}`), r || l.push(`hover:bu-bg-light-${t}`);
+      break;
+    case "default":
+      l.push("bu-bg-light-neutral"), l.push(`bu-text-${t}`), r || l.push("hover:bu-bg-light-base");
+      break;
+    case "text":
+      l.push("bu-bg-inherit"), l.push(`bu-text-${t}`), r || l.push("hover:bu-underline");
+      break;
+  }
+  return l.join(" ");
+}
+function ht({
+  type: e = "button",
+  disabled: s,
+  loading: t,
+  variant: n = "filled",
+  size: r = "md",
+  color: a = "base",
+  roundedness: l = "sm",
+  onClick: i = () => {
+  }
+}, ...c) {
+  const p = $(null);
+  return he(
+    pe,
+    (f) => m.button(
+      u.type(e),
+      u.disabled(
+        T(
+          s,
+          t
+        )((d, g) => d || g)
+      ),
+      // Add ARIA attributes for accessibility
+      E.busy(t ?? !1),
+      M(t ?? !1, () => E.label(f.$.loadingExtended)),
+      u.class(
+        T(
+          n,
+          r,
+          a,
+          l,
+          s,
+          t
+        )(
+          (d, g, w, A, b, I) => dt(
+            d ?? "filled",
+            g ?? "md",
+            w ?? "base",
+            A ?? "sm",
+            b,
+            I
+          )
+        )
+      ),
+      M(
+        t ?? !1,
+        () => P(
+          fe.width(
+            p.map((d) => d == null ? "" : `${d.width}px`)
+          ),
+          fe.height(
+            p.map((d) => d == null ? "" : `${d.height}px`)
+          ),
+          ae({ icon: "line-md:loading-twotone-loop", size: r ?? "md" }),
+          // Hidden live region for screen reader announcements
+          m.span(
+            u.class("sr-only"),
+            E.live("polite"),
+            f.$.loadingExtended
+          )
+        ),
+        () => P(S.click(i), ...c)
+      ),
+      M(
+        t != null,
+        () => Je(
+          (d) => Pe(
+            d.on((g) => {
+              x.get(t ?? !1) || p.set(g);
+            })
+          )
+        )
+      )
+    )
+  );
+}
+function Nt({
+  size: e = "sm",
+  icon: s = "line-md:close",
+  disabled: t,
+  roundedness: n = "full",
+  color: r = "base",
+  onClick: a,
+  label: l
+}, ...i) {
+  return he(pe, (c) => {
+    const p = Se(l, c.$.closeModal);
+    return ht(
+      {
+        variant: "text",
+        size: e,
+        roundedness: n,
+        disabled: t,
+        color: r,
+        onClick: a
+      },
+      u.title(p),
+      E.label(p),
+      ...i,
+      ae({ icon: s, size: e ?? "sm" })
+    );
+  });
+}
+function pt(e, s, t) {
+  const n = [
+    e ? "bc-base-input-container" : "bc-input-container"
+  ];
+  return s ? n.push(
+    e ? "bc-base-input-container--disabled" : "bc-input-container--disabled"
+  ) : n.push(
+    e ? "bc-base-input-container--default" : "bc-input-container--default"
+  ), t && n.push("bc-input-container--error"), n.join(" ");
+}
+const ye = ({
+  baseContainer: e,
+  disabled: s,
+  input: t,
+  before: n,
+  after: r,
+  hasError: a,
+  focusableSelector: l = "input, select, textarea",
+  growInput: i = !0
+}, ...c) => {
+  const p = x.map(s ?? !1, (f) => f);
+  return m.div(
+    Ge((f) => {
+      const d = () => {
+        const g = f.querySelector(l);
+        g == null || g.focus();
+      };
+      return f.addEventListener("click", d), Pe(() => f.removeEventListener("click", d));
+    }),
+    u.class(
+      T(
+        e,
+        p,
+        a ?? !1
+      )(
+        (f, d, g) => pt(
+          f ?? !1,
+          d ?? !1,
+          g ?? !1
+        )
+      )
+    ),
+    n != null ? m.span(u.class("bc-input-container__before"), n) : null,
+    m.div(
+      u.class("bc-input-container__input"),
+      u.class(
+        x.map(
+          i,
+          (f) => f ? "bc-input-container__input--grow" : ""
+        )
+      ),
+      t
+    ),
+    r != null ? m.span(u.class("bc-input-container__after"), r) : null,
+    ...c
+  );
+};
+function we(e) {
+  return `bc-label bc-label--${e}`;
+}
+const Ft = (...e) => m.span(u.class(we("emphasis")), ...e), ft = (...e) => m.span(u.class(we("default")), ...e), mt = (...e) => m.span(u.class(we("muted")), ...e), qt = (...e) => m.span(u.class(we("error")), ...e), Rt = (e) => {
+  const { value: s, onBlur: t, onChange: n, placeholder: r, disabled: a, id: l } = e, i = l ?? xe("checkbox"), c = `${i}-label`, p = () => {
+    if (x.get(a ?? !1)) return;
+    const d = x.get(s);
+    n == null || n(!d);
+  }, f = (d) => {
+    x.get(a ?? !1) || (d.key === " " || d.key === "Enter") && (d.preventDefault(), p());
+  };
+  return ye(
+    {
+      baseContainer: !0,
+      growInput: !1,
+      ...e,
+      input: m.span(
+        u.class("bc-checkbox-input"),
+        m.span(
+          u.class("bc-checkbox-input__checkbox"),
+          u.class(
+            x.map(
+              s,
+              (d) => d ? "bc-checkbox-input__checkbox--checked" : ""
+            )
+          ),
+          u.class(
+            x.map(
+              a ?? !1,
+              (d) => d ? "bc-checkbox-input__checkbox--disabled" : ""
+            )
+          ),
+          u.id(i),
+          u.role("checkbox"),
+          u.tabindex(
+            x.map(
+              a ?? !1,
+              (d) => d ? -1 : 0
+            )
+          ),
+          E.checked(s),
+          E.disabled(a),
+          r != null ? E.labelledby(c) : k,
+          S.keydown(f),
+          t != null ? S.blur(t) : k
+        ),
+        r != null ? m.label(
+          u.class("bc-checkbox-input__label"),
+          u.id(c),
+          u.for(i),
+          mt(r)
+        ) : k
+      )
+    },
+    S.click(p)
+  );
+}, Ie = ({
+  autocomplete: e,
+  autofocus: s,
+  class: t,
+  disabled: n,
+  name: r,
+  placeholder: a,
+  id: l,
+  required: i,
+  hasError: c
+}) => P(
+  u.autocomplete(e),
+  u.autofocus(s),
+  u.class(t),
+  u.disabled(n),
+  u.name(r ?? l),
+  u.placeholder(a),
+  u.id(l),
+  E.required(i),
+  c != null ? E.invalid(
+    c ?? !1
+  ) : null
+), bt = m.span(
+  u.class("bc-input-wrapper__required"),
+  " *"
+);
+function vt(e) {
+  const s = ["bc-input-wrapper"];
+  return e && s.push("bc-input-wrapper--horizontal"), s.join(" ");
+}
+function gt(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 Be = ({
+  required: e,
+  label: s,
+  context: t,
+  description: n,
+  content: r,
+  error: a,
+  labelFor: l,
+  hasError: i,
+  disabled: c,
+  horizontal: p
+}, ...f) => {
+  const d = i ?? a != null, g = c ?? !1, w = p ?? !1, A = xe("input-wrapper"), b = n ? `${A}-description` : void 0, I = a != null ? `${A}-error` : void 0;
+  return m.div(
+    u.class(
+      x.map(w, (D) => vt(D))
+    ),
+    s != null || t != null ? m.div(
+      u.class("bc-input-wrapper__header"),
+      m.div(
+        u.class("bc-input-wrapper__label-section"),
+        m.label(
+          u.class("bc-input-wrapper__label"),
+          l != null ? u.for(l) : k,
+          m.span(
+            u.class(
+              T(
+                d,
+                g
+              )(
+                (D, j) => gt(
+                  D ?? !1,
+                  j ?? !1
+                )
+              )
+            ),
+            s
+          ),
+          s != null && e ? bt : k
+        ),
+        // Show description under label when horizontal
+        M(
+          T(
+            w,
+            n
+          )((D, j) => D && j != null),
+          () => m.div(
+            u.class(
+              "bc-input-wrapper__description bc-input-wrapper__description--under-label"
+            ),
+            u.id(b),
+            n
+          )
+        )
+      ),
+      t != null ? ft(t) : k
+    ) : k,
+    m.div(
+      u.class("bc-input-wrapper__content"),
+      // Add data attributes to help inputs inherit accessibility information
+      [b, I].filter(Boolean).length > 0 ? ke.describedby(
+        [b, I].filter(Boolean).join(" ")
+      ) : k,
+      e ? ke.required("true") : k,
+      M(d, () => ke.invalid("true")),
+      r
+    ),
+    // Show description at bottom only when not horizontal
+    M(
+      T(
+        w,
+        n
+      )((D, j) => !D && j != null),
+      () => m.div(
+        u.class("bc-input-wrapper__description"),
+        u.id(b),
+        n
+      )
+    ),
+    a != null ? M(
+      d,
+      () => m.div(
+        u.class("bc-input-wrapper__error"),
+        u.id(I),
+        E.live("polite"),
+        // Announce errors to screen readers
+        u.role("alert"),
+        // Mark as alert for immediate attention
+        a
+      )
+    ) : null,
+    ...f
+  );
+};
+function Ht(...e) {
+  return m.div(u.class("bc-group"), ...e);
+}
+function Ut(...e) {
+  return m.div(u.class("bc-stack"), ...e);
+}
+const Gt = (e) => {
+  const s = {
+    name: "email",
+    autocomplete: "email",
+    ...e
+  }, {
+    value: t,
+    before: n,
+    onBlur: r,
+    onChange: a,
+    onInput: l,
+    placeholder: i
+  } = s, c = n ?? ae({
+    icon: "line-md:email",
+    size: "sm",
+    color: "neutral"
+  });
+  return he(
+    pe,
+    (p) => ye({
+      ...e,
+      before: c,
+      input: Ae.email(
+        Ie(s),
+        u.placeholder(Se(i, p.$.emailPlaceholderText)),
+        u.value(t),
+        u.class("bc-input"),
+        r != null ? S.blur(B(r)) : k,
+        a != null ? S.change(B(a)) : k,
+        l != null ? S.input(B(l)) : k
+      )
+    })
+  );
+}, zt = (e) => {
+  const { value: s, onBlur: t, onChange: n, onInput: r } = e;
+  return ye({
+    ...e,
+    input: Ae.text(
+      Ie(e),
+      u.value(s),
+      u.class("bc-input"),
+      t != null ? S.blur(B(t)) : k,
+      n != null ? S.change(B(n)) : k,
+      r != null ? S.input(B(r)) : k
+    )
+  });
+}, Wt = (e) => {
+  const {
+    value: s,
+    onBlur: t,
+    onChange: n,
+    onInput: r,
+    before: a,
+    after: l,
+    hasError: i,
+    disabled: c,
+    autocomplete: p,
+    placeholder: f,
+    ...d
+  } = e, g = {
+    name: "password",
+    disabled: c,
+    ...d
+  }, w = $(!0), A = T(
+    w,
+    p
+  )((b, I) => b ? I ?? "current-password" : "off");
+  return he(pe, (b) => {
+    const I = T(
+      b.$.passwordPlaceholderText,
+      w,
+      f
+    )((j, qe, Re) => qe ? "•••••••••••••••" : Re ?? j), D = m.button(
+      u.class("bc-input-container__password-toggle bu-text-light-gray"),
+      E.label(b.$.togglePasswordVisibility),
+      S.click(() => w.update((j) => !j)),
+      M(
+        w,
+        () => ae({ icon: "line-md:watch" }),
+        () => ae({ icon: "line-md:watch-off" })
+      )
+    );
+    return ye({
+      before: a,
+      disabled: c,
+      hasError: i,
+      input: m.input(
+        Ie({
+          ...g,
+          autocomplete: A,
+          placeholder: I
+        }),
+        M(
+          w,
+          () => P(u.type("password")),
+          () => P(u.type("text"))
+        ),
+        u.class("bc-input"),
+        u.value(s),
+        t != null ? S.blur(B(t)) : k,
+        n != null ? S.change(B(n)) : k,
+        r != null ? S.input(B(r)) : k
+      ),
+      after: l != null ? P(D, l) : D
+    });
+  });
+}, yt = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (e, s) => () => {
+    e.markTouched(), s == null || s();
+  }
+), wt = (e, s) => (t) => {
+  e.change(t), s == null || s(t);
+};
+function je(e, s) {
+  const { controller: t, onBlur: n, onChange: r, ...a } = s;
+  return e({
+    id: t.name,
+    disabled: t.disabled,
+    value: t.value,
+    hasError: t.errorVisible,
+    ...a,
+    onChange: wt(t, r),
+    onBlur: yt(t, n)
+  });
+}
+function Kt(e, s, ...t) {
+  return Be(
+    {
+      ...s,
+      content: je(
+        e,
+        s
+      )
+    },
+    ...t
+  );
+}
+function kt(e, s) {
+  const { toInput: t, fromInput: n, controller: r, ...a } = s, l = r.transform(t, n);
+  return je(e, {
+    ...a,
+    controller: l
+  });
+}
+function Jt(e, s, ...t) {
+  return Be(
+    {
+      ...s,
+      content: kt(e, s)
+    },
+    ...t
+  );
+}
+function Yt(e) {
+  return e.split(".").map((t) => {
+    const n = t.match(/^\[(\d+)\]$/);
+    return n ? Number(n[1]) : t;
+  });
+}
+function St(e) {
+  return typeof e == "number" ? `[${e}]` : `.${e}`;
+}
+function It(e) {
+  if (e.length === 0) return "";
+  const [s, ...t] = e;
+  return [
+    typeof s == "number" ? `[${s}]` : s,
+    ...t.map(St)
+  ].join("");
+}
+function ve(e) {
+  return function(t) {
+    var r;
+    if (t.type === "valid") return t;
+    let n = t.error;
+    for (const a of e)
+      if (n = (r = n == null ? void 0 : n.dependencies) == null ? void 0 : r[a], n == null) return C.valid;
+    return C.invalid(n);
+  };
+}
+var L, ie, N, K;
+const ge = class ge {
+  constructor(s, t, n, r, a, l = W) {
+    h(this, "path");
+    h(this, "change");
+    h(this, "value");
+    h(this, "status");
+    h(this, "error");
+    h(this, "hasError");
+    h(this, "touched");
+    h(this, "errorVisible");
+    h(this, "dirty");
+    h(this, "dependencyErrors");
+    v(this, L, {
+      disabled: $(!1),
+      touched: $(!1)
+    });
+    v(this, ie);
+    v(this, N, $(void 0));
+    h(this, "parent");
+    h(this, "disabled");
+    v(this, K, []);
+    h(this, "disabledOrHasErrors");
+    h(this, "onDispose", (s) => {
+      o(this, K).push(s);
+    });
+    h(this, "dispose", () => {
+      for (const s of o(this, K))
+        try {
+          s();
+        } catch (t) {
+          console.error("Error in dispose callback:", t);
+        }
+      o(this, K).length = 0;
+    });
+    h(this, "setDisabled", (s) => {
+      o(this, L).disabled.set(s);
+    });
+    h(this, "disable", () => this.setDisabled(!0));
+    h(this, "enable", () => this.setDisabled(!1));
+    h(this, "markTouched", () => {
+      o(this, L).touched.set(!0);
+    });
+    h(this, "resetTouched", () => {
+      o(this, L).touched.set(!1);
+    });
+    h(this, "markPristine", () => {
+      o(this, N).set(this.value.value);
+    });
+    h(this, "reset", () => {
+      this.change(o(this, N).value);
+    });
+    h(this, "array", (s = W) => new _t(
+      this.path,
+      this.change,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.value,
+      this.status,
+      this.parent,
+      s
+    ));
+    h(this, "object", (s = W) => new Dt(
+      this.path,
+      this.change,
+      this.value,
+      this.status,
+      this.parent,
+      s
+    ));
+    h(this, "transform", (s, t, n = [], r = W) => new ge(
+      [...this.path, ...n],
+      (a) => this.change(t(a)),
+      this.value.map(s, r),
+      this.status.map(ve(n)),
+      this.parent,
+      r
+    ));
+    h(this, "asyncTransform", (s, t, n, r = [], a = W) => new ge(
+      [...this.path, ...r],
+      (l) => {
+        t(l).then((i) => this.change(i));
+      },
+      this.value.mapAsync(s, n, void 0, a),
+      this.status.map(ve(r)),
+      this.parent,
+      a
+    ));
+    this.path = s, this.change = t, this.value = n, this.status = r, z(this, ie, l), o(this, N).set(n.value), this.error = r.map(
+      (i) => {
+        var c;
+        return (i == null ? void 0 : i.type) === "invalid" ? (c = i.error) == null ? void 0 : c.message : void 0;
+      }
+    ), this.hasError = this.error.map((i) => i != null), this.touched = o(this, L).touched, a.validationMode ? this.errorVisible = T(
+      this.hasError,
+      this.touched,
+      a.validationMode
+    )((i, c, p) => p === "continuous" ? !!i : !!i && !!c) : this.errorVisible = T(
+      this.hasError,
+      this.touched
+    )((i, c) => !!i && !!c), this.dirty = T(
+      this.value,
+      o(this, N)
+    )((i, c) => !o(this, ie).call(this, i, c)), this.dependencyErrors = r.map(
+      (i) => {
+        var c;
+        return (i == null ? void 0 : i.type) === "invalid" ? (c = i.error) == null ? void 0 : c.dependencies : void 0;
+      }
+    ), this.parent = a, this.disabled = T(
+      o(this, L).disabled,
+      a.disabled
+    )((i, c) => i || c), this.disabledOrHasErrors = T(
+      this.disabled,
+      this.hasError
+    )((i, c) => i || c), this.onDispose(() => {
+      o(this, L).disabled.dispose(), o(this, L).touched.dispose(), this.disabled.dispose(), this.error.dispose(), this.errorVisible.dispose(), this.dirty.dispose(), o(this, N).dispose(), this.dependencyErrors.dispose(), this.disabledOrHasErrors.dispose();
+    });
+  }
+  get name() {
+    return It(this.path);
+  }
+};
+L = new WeakMap(), ie = new WeakMap(), N = new WeakMap(), K = new WeakMap();
+let G = ge;
+var O, J, Y, Z, Q, X, ee, oe, le, ce, te;
+class Dt extends G {
+  constructor(t, n, r, a, l, i) {
+    super(
+      t,
+      n,
+      r.map((p) => p ?? {}, i),
+      a,
+      l,
+      i
+    );
+    v(this, O, /* @__PURE__ */ new Map());
+    v(this, J, /* @__PURE__ */ new Map());
+    v(this, Y, /* @__PURE__ */ new Map());
+    v(this, Z, $(!1));
+    h(this, "touchedDeep", o(this, Z));
+    v(this, Q, /* @__PURE__ */ new Map());
+    v(this, X, /* @__PURE__ */ new Map());
+    v(this, ee, $(!1));
+    h(this, "dirtyDeep", o(this, ee));
+    v(this, oe);
+    v(this, le);
+    v(this, ce, () => {
+      let t = !1;
+      for (const n of o(this, J).values())
+        if (n) {
+          t = !0;
+          break;
+        }
+      o(this, Z).set(this.touched.value || t);
+    });
+    h(this, "field", (t) => {
+      if (o(this, O).has(t))
+        return o(this, O).get(t);
+      const n = async (i) => {
+        this.change({
+          ...this.value.value,
+          [t]: i
+        });
+      }, r = new G(
+        [...this.path, t],
+        n,
+        this.value.map((i) => i[t]),
+        this.status.map(ve([t])),
+        {
+          disabled: this.disabled,
+          // propagate validationMode to children if present
+          validationMode: this.parent.validationMode
+        }
+      );
+      o(this, O).set(t, r);
+      const a = r.touched.on((i) => {
+        o(this, J).set(t, i), o(this, ce).call(this);
+      });
+      o(this, Y).set(t, a);
+      const l = r.dirty.on((i) => {
+        o(this, Q).set(t, i), o(this, te).call(this);
+      });
+      return o(this, X).set(t, l), r;
+    });
+    h(this, "markAllTouched", () => {
+      this.markTouched();
+      const t = this.value.value;
+      for (const n of Object.keys(t))
+        this.field(n).markTouched();
+      for (const n of o(this, O).values())
+        n.markTouched();
+    });
+    h(this, "markAllPristine", () => {
+      var n, r, a;
+      this.markPristine();
+      const t = this.value.value;
+      for (const l of Object.keys(t))
+        (r = (n = this.field(l)).markPristine) == null || r.call(n);
+      for (const l of o(this, O).values())
+        (a = l.markPristine) == null || a.call(l);
+    });
+    v(this, te, () => {
+      let t = !1;
+      for (const n of o(this, Q).values())
+        if (n) {
+          t = !0;
+          break;
+        }
+      o(this, ee).set(this.dirty.value || t);
+    });
+    z(this, oe, this.touched.on(() => {
+      o(this, ce).call(this);
+    })), z(this, le, this.dirty.on(() => {
+      o(this, te).call(this);
+    }));
+    const c = this.value.on(() => o(this, te).call(this));
+    this.onDispose(() => {
+      for (const p of o(this, O).values())
+        p.dispose();
+      o(this, O).clear();
+      for (const p of o(this, Y).values()) p();
+      o(this, Y).clear(), o(this, J).clear(), o(this, Z).dispose();
+      for (const p of o(this, X).values()) p();
+      o(this, X).clear(), o(this, Q).clear(), o(this, ee).dispose(), o(this, oe).call(this), o(this, le).call(this), c();
+    });
+  }
+}
+O = new WeakMap(), J = new WeakMap(), Y = new WeakMap(), Z = new WeakMap(), Q = new WeakMap(), X = new WeakMap(), ee = new WeakMap(), oe = new WeakMap(), le = new WeakMap(), ce = new WeakMap(), te = new WeakMap();
+var V, R, F, se, H, q, ne, ue, de, re, U;
+class _t extends G {
+  constructor(t, n, r, a, l, i) {
+    const c = r.map((d) => d ?? [], i);
+    super(t, n, c, a, l, i);
+    v(this, V, new Array());
+    h(this, "length");
+    v(this, R, /* @__PURE__ */ new Map());
+    v(this, F, /* @__PURE__ */ new Map());
+    v(this, se, $(!1));
+    h(this, "touchedDeep", o(this, se));
+    v(this, H, /* @__PURE__ */ new Map());
+    v(this, q, /* @__PURE__ */ new Map());
+    v(this, ne, $(!1));
+    h(this, "dirtyDeep", o(this, ne));
+    v(this, ue);
+    v(this, de);
+    v(this, re, () => {
+      let t = !1;
+      for (const n of o(this, R).values())
+        if (n) {
+          t = !0;
+          break;
+        }
+      o(this, se).set(this.touched.value || t);
+    });
+    h(this, "item", (t) => {
+      if (o(this, V)[t])
+        return o(this, V)[t];
+      const n = async (i) => {
+        const c = this.value.value.slice();
+        c[t] = i, this.change(c);
+      }, r = new G(
+        [...this.path, t],
+        n,
+        this.value.map((i) => i[t]),
+        this.status.map(ve([t])),
+        {
+          disabled: this.disabled,
+          validationMode: this.parent.validationMode
+        }
+      );
+      o(this, V)[t] = r;
+      const a = r.touched.on((i) => {
+        o(this, R).set(t, i), o(this, re).call(this);
+      });
+      o(this, F).set(t, a);
+      const l = r.dirty.on((i) => {
+        o(this, H).set(t, i), o(this, U).call(this);
+      });
+      return o(this, q).set(t, l), r;
+    });
+    h(this, "push", (...t) => {
+      this.change([...this.value.value, ...t]);
+    });
+    h(this, "pop", () => {
+      this.splice(this.value.value.length - 1, 1);
+    });
+    h(this, "shift", () => {
+      this.splice(0, 1);
+    });
+    h(this, "unshift", (...t) => {
+      this.change([...t, ...this.value.value]);
+    });
+    h(this, "removeAt", (t) => {
+      this.splice(t, 1);
+    });
+    h(this, "splice", (t, n) => {
+      const r = this.value.value.slice();
+      r.splice(t, n), this.change(r);
+    });
+    h(this, "move", (t, n, r = 1) => {
+      if (r < 1 || t === n) return;
+      const a = this.value.value.slice(), l = a.splice(t, r);
+      a.splice(n, 0, ...l), this.change(a);
+    });
+    h(this, "markAllTouched", () => {
+      this.markTouched();
+      const t = this.value.value.length;
+      for (let n = 0; n < t; n++)
+        this.item(n).markTouched();
+    });
+    h(this, "markAllPristine", () => {
+      var n, r;
+      this.markPristine();
+      const t = this.value.value.length;
+      for (let a = 0; a < t; a++)
+        (r = (n = this.item(a)).markPristine) == null || r.call(n);
+    });
+    v(this, U, () => {
+      let t = !1;
+      for (const n of o(this, H).values())
+        if (n) {
+          t = !0;
+          break;
+        }
+      o(this, ne).set(this.dirty.value || t);
+    });
+    const p = c.on((d) => {
+      const g = o(this, V).length - d.length;
+      g > 0 && (o(this, V).splice(d.length, g).forEach((w, A) => {
+        const b = d.length + A;
+        w.dispose();
+        const I = o(this, F).get(b);
+        I == null || I(), o(this, F).delete(b), o(this, R).delete(b);
+        const D = o(this, q).get(b);
+        D == null || D(), o(this, q).delete(b), o(this, H).delete(b);
+      }), o(this, re).call(this), o(this, U).call(this));
+    });
+    this.length = c.map((d) => d.length), z(this, ue, this.touched.on(() => {
+      o(this, re).call(this);
+    })), z(this, de, this.dirty.on(() => {
+      o(this, U).call(this);
+    }));
+    const f = this.value.on(() => o(this, U).call(this));
+    this.onDispose(() => {
+      for (const d of o(this, V))
+        d.dispose();
+      this.length.dispose(), o(this, V).length = 0, p(), c.dispose();
+      for (const d of o(this, F).values()) d();
+      o(this, F).clear(), o(this, R).clear(), o(this, se).dispose();
+      for (const d of o(this, q).values()) d();
+      o(this, q).clear(), o(this, H).clear(), o(this, ne).dispose(), o(this, ue).call(this), o(this, de).call(this), f();
+    });
+  }
+}
+V = new WeakMap(), R = new WeakMap(), F = new WeakMap(), se = new WeakMap(), H = new WeakMap(), q = new WeakMap(), ne = new WeakMap(), ue = new WeakMap(), de = new WeakMap(), re = new WeakMap(), U = new WeakMap();
+function Et(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 Tt(e) {
+  const s = e.filter((r) => r.path == null || r.path.length === 0).map((r) => r.message), t = e.filter((r) => r.path != null && r.path.length > 0).reduce((r, a) => {
+    const l = Et(a.path), i = l.pop();
+    let c = r;
+    for (const p of l)
+      c.dependencies == null && (c.dependencies = {}), c.dependencies[p] == null && (c.dependencies[p] = {}), c = c.dependencies[p];
+    return c.dependencies == null && (c.dependencies = {}), c.dependencies[i] = { message: a.message }, r;
+  }, {}), n = s.join(`
+`);
+  return {
+    ...t,
+    message: n != "" ? n : void 0
+  };
+}
+function Ct({
+  initialValue: e,
+  onChange: s,
+  validate: t,
+  equals: n,
+  validationMode: r,
+  validateDebounceMs: a
+}) {
+  const l = x.deriveProp(e), i = $(C.valid), c = $(!1), p = $(r ?? "touchedOrSubmit"), f = (b) => {
+    i.set(b);
+  };
+  let d;
+  const g = async (b) => {
+    if (t != null) {
+      const I = await t(b);
+      f(I);
+    }
+  }, w = async (b) => {
+    l.set(b), s == null || s(b);
+    const I = p.value;
+    if (t != null) {
+      if (I === "onSubmit")
+        return;
+      const D = a ?? 0;
+      D > 0 ? (d && clearTimeout(d), d = setTimeout(() => {
+        g(b);
+      }, D)) : await g(b);
+    }
+  }, A = new G(
+    [],
+    w,
+    l,
+    i,
+    {
+      disabled: c,
+      validationMode: p
+    },
+    n ?? W
+  );
+  return A.onDispose(() => {
+    c.dispose(), l.dispose(), i.dispose(), p.dispose(), d && clearTimeout(d);
+  }), { controller: A, setStatus: f };
+}
+function Ne(e) {
+  return P(u.disabled(e.disabled), u.name(e.name));
+}
+function Zt(e, {
+  triggerOn: s = "change"
+} = {}) {
+  return P(
+    Ne(e),
+    u.value(e.value),
+    (s === "input" ? S.input : S.change)(B(e.change))
+  );
+}
+function Qt(e, {
+  triggerOn: s = "change"
+} = {}) {
+  return P(
+    Ne(e),
+    u.valueAsNumber(e.value),
+    (s === "input" ? S.input : S.change)(
+      ze(e.change)
+    )
+  );
+}
+function $e(e) {
+  return e.issues != null ? C.invalid(Tt(e.issues)) : C.valid;
+}
+async function Xt({
+  task: e,
+  errorMessage: s,
+  errorPath: t = ["root"],
+  validation: n
+}) {
+  try {
+    const r = await e();
+    return n != null ? n(r) : C.valid;
+  } catch (r) {
+    const a = s ?? (r instanceof Error ? r.message : "Operation failed");
+    return t.length === 1 && t[0] === "root" ? C.invalid({
+      message: a
+    }) : C.invalid({
+      dependencies: Fe(t, a)
+    });
+  }
+}
+function Fe(e, s) {
+  if (e.length === 1)
+    return {
+      [e[0]]: { message: s }
+    };
+  const [t, ...n] = e;
+  return {
+    [t]: {
+      dependencies: Fe(n, s)
+    }
+  };
+}
+function es({
+  initialValue: e = {},
+  schema: s,
+  submit: t = async () => C.valid,
+  validationMode: n,
+  validateDebounceMs: r
+}) {
+  const { controller: a, setStatus: l } = Ct({
+    initialValue: e,
+    validationMode: n ?? "touchedOrSubmit",
+    validateDebounceMs: r,
+    validate: (n ?? "touchedOrSubmit") === "onSubmit" ? void 0 : async (f) => $e(
+      await s["~standard"].validate(f)
+    )
+  }), i = $(!1), c = a.object();
+  return c.onDispose(i.dispose), {
+    controller: c,
+    setStatus: l,
+    onSubmit: async (f) => {
+      if (i.set(!0), f.preventDefault(), c.markAllTouched(), (n ?? "touchedOrSubmit") === "onSubmit") {
+        const g = c.value.value, w = $e(
+          await s["~standard"].validate(g)
+        );
+        if (l(w), w.type === "invalid") {
+          i.set(!1);
+          return;
+        }
+      }
+      const d = await t(c.value.value);
+      i.set(!1), d.type === "invalid" && l(d);
+    },
+    submitting: i
+  };
+}
+function $t(e) {
+  const s = e.split("-"), t = [e];
+  return s.length > 1 && t.push(s[0]), t;
+}
+function Mt({
+  locale: e,
+  defaultLocale: s = "en-US",
+  defaultMessages: t,
+  localeLoader: n
+}) {
+  const r = $(s), a = $(t), l = e.on(async (i) => {
+    if (i === r.value) return;
+    r.set(i);
+    const c = $t(i);
+    for (const p of c)
+      try {
+        const f = await n(p);
+        if (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          typeof f.default == "object" && Object.keys(f).length === 1
+        ) {
+          console.error(
+            "It appears that you are trying to load a translation module without referencing the default export. Please use `(await import(...)).default` in your loader function."
+          );
+          return;
+        }
+        if (i === r.value) {
+          a.set(f);
+          return;
+        }
+      } catch {
+        continue;
+      }
+    console.warn(`No locale found for "'${e}", using fallback`), i === r.value && a.set(t);
+  });
+  return {
+    /** Clean up all resources and event listeners */
+    dispose: () => {
+      l(), r.dispose(), a.dispose();
+    },
+    /** Translation functions that return reactive signals */
+    t: a
+  };
+}
+function Pt({
+  defaultLocale: e,
+  defaultMessages: s,
+  localeLoader: t,
+  providerName: n = "I18nProvider"
+}) {
+  return {
+    mark: Me(n),
+    create: (r, a) => {
+      const {
+        value: { locale: l }
+      } = a.getProvider(nt.mark), { t: i, dispose: c } = Mt({
+        locale: l,
+        defaultMessages: s,
+        defaultLocale: e,
+        localeLoader: t
+      });
+      return {
+        value: i,
+        dispose: c
+      };
+    }
+  };
+}
+const pe = Pt({
+  defaultLocale: Qe,
+  defaultMessages: Ze,
+  localeLoader: async (e) => (await Xe(/* @__PURE__ */ Object.assign({ "./locales/ar.ts": () => import("./ar-VA2yE-1i.js"), "./locales/de.ts": () => import("./de-C14QN5V1.js"), "./locales/en.ts": () => Promise.resolve().then(() => Ye), "./locales/es.ts": () => import("./es-B5GqMkMg.js"), "./locales/fa.ts": () => import("./fa-BxlrmcQK.js"), "./locales/fr.ts": () => import("./fr-BzFxzocR.js"), "./locales/he.ts": () => import("./he-DjHXtt_S.js"), "./locales/hi.ts": () => import("./hi-Xlc0IeoY.js"), "./locales/it.ts": () => import("./it-CR0FAQEB.js"), "./locales/ja.ts": () => import("./ja-WICb5O3K.js"), "./locales/ko.ts": () => import("./ko-30evSGGW.js"), "./locales/nl.ts": () => import("./nl-DaCzsF01.js"), "./locales/pl.ts": () => import("./pl-DlMR1sq8.js"), "./locales/pt.ts": () => import("./pt-lX3h34iM.js"), "./locales/ru.ts": () => import("./ru-2aVFFaQ-.js"), "./locales/tr.ts": () => import("./tr-DgRS_mcj.js"), "./locales/ur.ts": () => import("./ur-fgmvVBHY.js"), "./locales/vi.ts": () => import("./vi-DZzB43iu.js"), "./locales/zh.ts": () => import("./zh-Bcz-uyJp.js") }), `./locales/${e}.ts`, 3)).default,
+  providerName: "BeatUII18n"
+});
+export {
+  Mt as $,
+  St as A,
+  pe as B,
+  Nt as C,
+  It as D,
+  Gt as E,
+  Dt as F,
+  Ht as G,
+  _t as H,
+  ae as I,
+  Et as J,
+  Tt as K,
+  ft as L,
+  Jt as M,
+  Ct as N,
+  W as O,
+  Wt as P,
+  Ne as Q,
+  bt as R,
+  Ut as S,
+  zt as T,
+  Zt as U,
+  Qt as V,
+  $e as W,
+  Ft as X,
+  mt as Y,
+  qt as Z,
+  Xe as _,
+  ht as a,
+  Oe as a0,
+  tt as a1,
+  Ot as a2,
+  Vt as a3,
+  Bt as a4,
+  st as a5,
+  jt as a6,
+  C as b,
+  Rt as c,
+  Kt as d,
+  ye as e,
+  Te as f,
+  Ie as g,
+  yt as h,
+  wt as i,
+  Be as j,
+  Ze as k,
+  nt as l,
+  Pt as m,
+  G as n,
+  ve as o,
+  je as p,
+  dt as q,
+  Qe as r,
+  xe as s,
+  Xt as t,
+  es as u,
+  Ve as v,
+  it as w,
+  ot as x,
+  kt as y,
+  Yt as z
+};