@tempots/beatui 0.19.1 → 0.21.0

package/dist/translations-ClgoCEFC.js

@@ -0,0 +1,1969 @@
+import { makeProviderMark as Y, localStorageProp as W, computedOf as I, Use as O, html as p, attr as c, When as T, Fragment as M, aria as k, coalesce as G, style as j, prop as _, on as y, OnDispose as Z, Value as P, WithElement as ue, Empty as v, dataAttr as U, input as X, emitValue as $, emitValueAsNumber as de } from "@tempots/dom";
+import { WhenInViewport as he, Query as pe, ElementRect as fe } from "@tempots/ui";
+function K(e, {
+  units: t = ["B", "KB", "MB", "GB", "TB"],
+  decimalPlaces: s = 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", t[0]);
+  let r, a;
+  if (typeof e == "bigint") {
+    let l = e < 0n ? -e : e;
+    for (r = 0; l >= 1024n && r < t.length - 1; )
+      l = l / 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, t.length - 1), a = e / Math.pow(1024, r);
+  return new Intl.NumberFormat(n, {
+    style: "unit",
+    unit: "byte",
+    unitDisplay: "short",
+    minimumFractionDigits: r === 0 ? 0 : s,
+    maximumFractionDigits: r === 0 ? 0 : s
+  }).format(a).replace("byte", t[r]);
+}
+const J = /* @__PURE__ */ new Map();
+function ee(e) {
+  const t = J.get(e) ?? 0;
+  return J.set(e, t + 1), `${e}-${t}`;
+}
+const w = {
+  /**
+   * 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, t) {
+    return w.isSuccess(e) ? e.value : t;
+  },
+  /**
+   * 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, t) {
+    return w.isSuccess(e) ? e.value : t();
+  },
+  /**
+   * 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 w.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 w.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 (w.isSuccess(e))
+      return e.value;
+    throw w.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: t,
+    failure: s,
+    loading: n,
+    notAsked: r = n
+  }) => w.isSuccess(e) ? t(e.value) : w.isFailure(e) ? s(e.error) : w.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, t) => (w.isSuccess(e) && t(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, t) => (w.isFailure(e) && t(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, t, s = {
+    valueEquals: (n, r) => n === r,
+    errorEquals: (n, r) => n === r
+  }) => e.type === "AsyncSuccess" && t.type === "AsyncSuccess" ? s.valueEquals(e.value, t.value) : e.type === "AsyncFailure" && t.type === "AsyncFailure" ? s.errorEquals(e.error, t.error) : e.type === "Loading" && t.type === "Loading" ? s.valueEquals(e.previousValue, t.previousValue) : e.type === "NotAsked" && t.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 t = [];
+    for (const s of e)
+      if (w.isSuccess(s))
+        t.push(s.value);
+      else
+        return s;
+    return w.success(t);
+  },
+  /**
+   * 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 t = await e;
+      return w.success(t);
+    } catch (t) {
+      return w.failure(t instanceof Error ? t : new Error(String(t)));
+    }
+  }
+}, L = (e, t) => e === t || e !== e && t !== t, D = {
+  /**
+   * 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, t, s) => D.isValid(e) ? t() : s(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, t) => D.match(
+    e,
+    () => f.success(t),
+    (s) => f.failure(s)
+  ),
+  /**
+   * 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, t) => (D.isValid(e) && t(), 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, t) => (D.isInvalid(e) && t(e.error), e)
+}, f = {
+  /**
+   * 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, t) => e.type === "Success" ? f.success(t(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, t) => e.type === "Success" ? t(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 f.match(
+      e,
+      (t) => w.success(t),
+      (t) => w.failure(t)
+    );
+  },
+  /**
+   * 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 f.match(
+      e,
+      () => D.valid,
+      (t) => D.invalid(t)
+    );
+  },
+  /**
+   * 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, t) {
+    return f.isSuccess(e) ? e.value : t;
+  },
+  /**
+   * 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, t) {
+    return f.isSuccess(e) ? e.value : t();
+  },
+  /**
+   * 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 f.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 f.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 (f.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, t, s) => f.isSuccess(e) ? t(e.value) : s(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, t) => (f.isSuccess(e) && t(e.value), e),
+  whenFailure: (e, t) => (f.isFailure(e) && t(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, t, s, n) => f.match(
+    e,
+    (r) => f.match(
+      t,
+      (a) => f.success(s(r, a)),
+      (a) => f.failure(a)
+    ),
+    (r) => f.match(
+      t,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (a) => f.failure(r),
+      (a) => f.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, t, s = {
+    valueEquals: (n, r) => n === r,
+    errorEquals: (n, r) => n === r
+  }) => e.type === "Success" && t.type === "Success" ? s.valueEquals(e.value, t.value) : e.type === "Failure" && t.type === "Failure" ? s.errorEquals(e.error, t.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 t = [];
+    for (const s of e)
+      if (f.isSuccess(s))
+        t.push(s.value);
+      else
+        return s;
+    return f.success(t);
+  }
+}, te = {
+  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, t, s) => {
+    let n = e == null || e > 1 ? "Click to choose or drag files here" : "Click to choose or drag a file here";
+    if (e || t) {
+      const r = [];
+      if (e != null && e > 1 && r.push(`up to ${e} files`), t && s) {
+        const a = K(t, {
+          units: s
+        });
+        r.push(`max ${a} each`);
+      }
+      r.length > 0 && (n += ` (${r.join(", ")})`);
+    } else if (t && s) {
+      const r = K(t, {
+        units: s
+      });
+      n += ` (max ${r})`;
+    }
+    return n;
+  }
+}, me = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: te
+}, Symbol.toStringTag, { value: "Module" })), be = te, ge = "en", ve = (e, t, s) => {
+  const n = e[t];
+  return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((r, a) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(a.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + t + (t.split("/").length !== s ? ". Note that variables only represent file names one level deep." : ""))));
+  });
+}, ye = /* @__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 se(e) {
+  if (!e) return "ltr";
+  const t = e.split(/[-_]/)[0].toLowerCase();
+  return ye.has(t) ? "rtl" : "ltr";
+}
+function we(e, t) {
+  return e === "auto" ? se(t) : e;
+}
+function Xe(e) {
+  return `b-${e}`;
+}
+function et(e) {
+  return se(e) === "rtl";
+}
+function tt(e) {
+  return e === "ltr" ? "rtl" : "ltr";
+}
+const ke = {
+  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 st(e, t) {
+  return ke[t][e];
+}
+const Se = {
+  mark: Y("Locale"),
+  create: (e) => {
+    const t = W({
+      defaultValue: navigator.language ?? "en-US",
+      key: "beatui-locale"
+    }), s = W({
+      defaultValue: "auto",
+      key: "beatui-direction-preference"
+    }), n = I(
+      t,
+      s
+    )(
+      (a, i) => we(i, a)
+    );
+    return {
+      value: {
+        locale: t,
+        setLocale: (a) => t.set(a),
+        direction: n,
+        directionPreference: s,
+        setDirectionPreference: (a) => s.set(a)
+      },
+      dispose: () => {
+        t.dispose(), s.dispose(), n.dispose();
+      }
+    };
+  }
+}, Ie = "bui-icons", N = /* @__PURE__ */ new Map(), ne = (() => {
+  try {
+    return typeof indexedDB < "u" && indexedDB !== null;
+  } catch {
+    return !1;
+  }
+})();
+function De() {
+  return ne ? new Promise((e, t) => {
+    const s = indexedDB.open(Ie, 1);
+    s.onupgradeneeded = function(n) {
+      const r = n.target.result;
+      r.objectStoreNames.contains("icons") || r.createObjectStore("icons");
+    }, s.onsuccess = function() {
+      e(s.result);
+    }, s.onerror = function() {
+      t(s.error);
+    };
+  }) : Promise.reject(new Error("IndexedDB not available"));
+}
+const F = ne ? De() : null;
+function _e(e, t) {
+  return new Promise(async (s, n) => {
+    try {
+      if (F) {
+        const a = (await F).transaction("icons", "readwrite");
+        a.objectStore("icons").put(t, e), a.oncomplete = s, a.onerror = n;
+      } else
+        N.set(e, t), s(void 0);
+    } catch {
+      N.set(e, t), s(void 0);
+    }
+  });
+}
+function Ce(e) {
+  return new Promise(async (t, s) => {
+    try {
+      if (F) {
+        const i = (await F).transaction("icons", "readonly").objectStore("icons").get(e);
+        i.onsuccess = function() {
+          t(i.result);
+        }, i.onerror = s;
+      } else
+        t(N.get(e) || null);
+    } catch {
+      t(N.get(e) || null);
+    }
+  });
+}
+async function Ee(e) {
+  const t = `https://api.iconify.design/${e}.svg`;
+  return fetch(t).then((s) => {
+    if (s.status === 200)
+      return s.text();
+    throw new Error(`Failed to load icon: ${e}`);
+  });
+}
+async function Te(e) {
+  const t = e.replace(":", "/"), s = await Ce(t);
+  if (s)
+    return s;
+  const n = await Ee(t);
+  return await _e(t, n), n;
+}
+function Me(e, t) {
+  const s = ["bc-icon", `bc-icon--${e}`];
+  return t && s.push(`bu-fg-${t}`), s.join(" ");
+}
+function B({ icon: e, size: t = "md", color: s, title: n, accessibility: r = "auto" }, ...a) {
+  const i = I(
+    r,
+    n
+  )((o, l) => o === "decorative" ? !1 : o === "informative" ? !0 : l != null && l !== "");
+  return O(
+    V,
+    (o) => p.span(
+      c.class("bu-content-box"),
+      c.class(
+        I(
+          t,
+          s
+        )((l, h) => Me(l ?? "md", h))
+      ),
+      // Add accessibility attributes based on icon type
+      T(
+        i,
+        () => M(
+          c.role("img"),
+          k.label(G(n, o.$.iconDescription))
+        ),
+        () => k.hidden(!0)
+      ),
+      he(
+        { once: !0 },
+        () => pe({
+          request: e,
+          load: ({ request: l }) => Te(l),
+          convertError: String,
+          success: ({ value: l }) => p.span(
+            j.width("100%"),
+            j.height("100%"),
+            c.innerHTML(l)
+          ),
+          pending: () => p.span(
+            c.class("animate-spin"),
+            // Loading state accessibility
+            T(
+              i,
+              () => M(c.role("img"), k.label(o.$.loadingIcon)),
+              () => k.hidden(!0)
+            ),
+            "↻"
+          ),
+          failure: ({ error: l }) => p.span(
+            c.title(l),
+            c.class("text-red-500"),
+            // Error state accessibility
+            T(
+              i,
+              () => M(c.role("img"), k.label(o.$.failedToLoadIcon)),
+              () => k.hidden(!0)
+            ),
+            "🚫"
+          )
+        })
+      ),
+      ...a
+    )
+  );
+}
+function Pe(e, t, s, n, r, a) {
+  const i = [
+    "bc-button",
+    `bu-text-${t}`,
+    `bc-control--padding-${t}`,
+    `bu-rounded-${n}`
+  ];
+  switch (a && i.push("bc-button--loading"), e) {
+    case "filled":
+      i.push(`bu-bg-${s}`), r || i.push(`hover:bu-bg-${s}`);
+      break;
+    case "light":
+      i.push(`bu-bg-light-${s}`), r || i.push(`hover:bu-bg-light-${s}`);
+      break;
+    case "outline":
+      i.push(`bu-border--${s}`), r || i.push(`hover:bu-bg-light-${s}`);
+      break;
+    case "default":
+      i.push("bu-bg-light-neutral"), i.push(`bu-text-${s}`), r || i.push("hover:bu-bg-light-base");
+      break;
+    case "text":
+      i.push("bu-bg-inherit"), i.push(`bu-text-${s}`), r || i.push("hover:bu-underline");
+      break;
+  }
+  return i.join(" ");
+}
+function $e({
+  type: e = "button",
+  disabled: t,
+  loading: s,
+  variant: n = "filled",
+  size: r = "md",
+  color: a = "base",
+  roundedness: i = "sm",
+  onClick: o = () => {
+  }
+}, ...l) {
+  const h = _(null);
+  return O(
+    V,
+    (d) => p.button(
+      c.type(e),
+      c.disabled(
+        I(
+          t,
+          s
+        )((u, b) => u || b)
+      ),
+      // Add ARIA attributes for accessibility
+      k.busy(s ?? !1),
+      T(s ?? !1, () => k.label(d.$.loadingExtended)),
+      c.class(
+        I(
+          n,
+          r,
+          a,
+          i,
+          t,
+          s
+        )(
+          (u, b, g, S, m, C) => Pe(
+            u ?? "filled",
+            b ?? "md",
+            g ?? "base",
+            S ?? "sm",
+            m,
+            C
+          )
+        )
+      ),
+      T(
+        s ?? !1,
+        () => M(
+          j.width(
+            h.map((u) => u == null ? "" : `${u.width}px`)
+          ),
+          j.height(
+            h.map((u) => u == null ? "" : `${u.height}px`)
+          ),
+          B({ icon: "line-md:loading-twotone-loop", size: r ?? "md" }),
+          // Hidden live region for screen reader announcements
+          p.span(
+            c.class("sr-only"),
+            k.live("polite"),
+            d.$.loadingExtended
+          )
+        ),
+        () => M(y.click(o), ...l)
+      ),
+      T(
+        s != null,
+        () => fe(
+          (u) => Z(
+            u.on((b) => {
+              P.get(s ?? !1) || h.set(b);
+            })
+          )
+        )
+      )
+    )
+  );
+}
+function nt({
+  size: e = "sm",
+  icon: t = "line-md:close",
+  disabled: s,
+  roundedness: n = "full",
+  color: r = "base",
+  onClick: a,
+  label: i
+}, ...o) {
+  return O(V, (l) => {
+    const h = G(i, l.$.closeModal);
+    return $e(
+      {
+        variant: "text",
+        size: e,
+        roundedness: n,
+        disabled: s,
+        color: r,
+        onClick: a
+      },
+      c.title(h),
+      k.label(h),
+      ...o,
+      B({ icon: t, size: e ?? "sm" })
+    );
+  });
+}
+function Ae(e, t, s) {
+  const n = [
+    e ? "bc-base-input-container" : "bc-input-container"
+  ];
+  return t ? n.push(
+    e ? "bc-base-input-container--disabled" : "bc-input-container--disabled"
+  ) : n.push(
+    e ? "bc-base-input-container--default" : "bc-input-container--default"
+  ), s && n.push("bc-input-container--error"), n.join(" ");
+}
+const R = ({
+  baseContainer: e,
+  disabled: t,
+  input: s,
+  before: n,
+  after: r,
+  hasError: a,
+  focusableSelector: i = "input, select, textarea",
+  growInput: o = !0
+}, ...l) => {
+  const h = P.map(t ?? !1, (d) => d);
+  return p.div(
+    ue((d) => {
+      const u = () => {
+        d.querySelector(i)?.focus();
+      };
+      return d.addEventListener("click", u), Z(() => d.removeEventListener("click", u));
+    }),
+    c.class(
+      I(
+        e,
+        h,
+        a ?? !1
+      )(
+        (d, u, b) => Ae(
+          d ?? !1,
+          u ?? !1,
+          b ?? !1
+        )
+      )
+    ),
+    n != null ? p.span(c.class("bc-input-container__before"), n) : null,
+    p.div(
+      c.class("bc-input-container__input"),
+      c.class(
+        P.map(
+          o,
+          (d) => d ? "bc-input-container__input--grow" : ""
+        )
+      ),
+      s
+    ),
+    r != null ? p.span(c.class("bc-input-container__after"), r) : null,
+    ...l
+  );
+};
+function H(e) {
+  return `bc-label bc-label--${e}`;
+}
+const rt = (...e) => p.span(c.class(H("emphasis")), ...e), xe = (...e) => p.span(c.class(H("default")), ...e), Le = (...e) => p.span(c.class(H("muted")), ...e), at = (...e) => p.span(c.class(H("error")), ...e), it = (e) => {
+  const { value: t, onBlur: s, onChange: n, placeholder: r, disabled: a, id: i } = e, o = i ?? ee("checkbox"), l = `${o}-label`, h = () => {
+    if (P.get(a ?? !1)) return;
+    const u = P.get(t);
+    n?.(!u);
+  }, d = (u) => {
+    P.get(a ?? !1) || (u.key === " " || u.key === "Enter") && (u.preventDefault(), h());
+  };
+  return R(
+    {
+      baseContainer: !0,
+      growInput: !1,
+      ...e,
+      input: p.span(
+        c.class("bc-checkbox-input"),
+        p.span(
+          c.class("bc-checkbox-input__checkbox"),
+          c.class(
+            P.map(
+              t,
+              (u) => u ? "bc-checkbox-input__checkbox--checked" : ""
+            )
+          ),
+          c.class(
+            P.map(
+              a ?? !1,
+              (u) => u ? "bc-checkbox-input__checkbox--disabled" : ""
+            )
+          ),
+          c.id(o),
+          c.role("checkbox"),
+          c.tabindex(
+            P.map(
+              a ?? !1,
+              (u) => u ? -1 : 0
+            )
+          ),
+          k.checked(t),
+          k.disabled(a),
+          r != null ? k.labelledby(l) : v,
+          y.keydown(d),
+          s != null ? y.blur(s) : v
+        ),
+        r != null ? p.label(
+          c.class("bc-checkbox-input__label"),
+          c.id(l),
+          c.for(o),
+          Le(r)
+        ) : v
+      )
+    },
+    y.click(h)
+  );
+}, z = ({
+  autocomplete: e,
+  autofocus: t,
+  class: s,
+  disabled: n,
+  name: r,
+  placeholder: a,
+  id: i,
+  required: o,
+  hasError: l
+}) => M(
+  c.autocomplete(e),
+  c.autofocus(t),
+  c.class(s),
+  c.disabled(n),
+  c.name(r ?? i),
+  c.placeholder(a),
+  c.id(i),
+  k.required(o),
+  l != null ? k.invalid(
+    l ?? !1
+  ) : null
+), Be = p.span(
+  c.class("bc-input-wrapper__required"),
+  " *"
+);
+function Oe(e) {
+  const t = ["bc-input-wrapper"];
+  return e && t.push("bc-input-wrapper--horizontal"), t.join(" ");
+}
+function Ve(e, t) {
+  const s = ["bc-input-wrapper__label-text"];
+  return e ? s.push("bc-input-wrapper__label-text--error") : t ? s.push("bc-input-wrapper__label-text--disabled") : s.push("bc-input-wrapper__label-text--default"), s.join(" ");
+}
+const re = ({
+  required: e,
+  label: t,
+  context: s,
+  description: n,
+  content: r,
+  error: a,
+  labelFor: i,
+  hasError: o,
+  disabled: l,
+  horizontal: h
+}, ...d) => {
+  const u = o ?? a != null, b = l ?? !1, g = h ?? !1, S = ee("input-wrapper"), m = n ? `${S}-description` : void 0, C = a != null ? `${S}-error` : void 0;
+  return p.div(
+    c.class(
+      P.map(g, (E) => Oe(E))
+    ),
+    t != null || s != null ? p.div(
+      c.class("bc-input-wrapper__header"),
+      p.div(
+        c.class("bc-input-wrapper__label-section"),
+        p.label(
+          c.class("bc-input-wrapper__label"),
+          i != null ? c.for(i) : v,
+          p.span(
+            c.class(
+              I(
+                u,
+                b
+              )(
+                (E, A) => Ve(
+                  E ?? !1,
+                  A ?? !1
+                )
+              )
+            ),
+            t
+          ),
+          t != null && e ? Be : v
+        ),
+        // Show description under label when horizontal
+        T(
+          I(
+            g,
+            n
+          )((E, A) => E && A != null),
+          () => p.div(
+            c.class(
+              "bc-input-wrapper__description bc-input-wrapper__description--under-label"
+            ),
+            c.id(m),
+            n
+          )
+        )
+      ),
+      s != null ? xe(s) : v
+    ) : v,
+    p.div(
+      c.class("bc-input-wrapper__content"),
+      // Add data attributes to help inputs inherit accessibility information
+      [m, C].filter(Boolean).length > 0 ? U.describedby(
+        [m, C].filter(Boolean).join(" ")
+      ) : v,
+      e ? U.required("true") : v,
+      T(u, () => U.invalid("true")),
+      r
+    ),
+    // Show description at bottom only when not horizontal
+    T(
+      I(
+        g,
+        n
+      )((E, A) => !E && A != null),
+      () => p.div(
+        c.class("bc-input-wrapper__description"),
+        c.id(m),
+        n
+      )
+    ),
+    a != null ? T(
+      u,
+      () => p.div(
+        c.class("bc-input-wrapper__error"),
+        c.id(C),
+        k.live("polite"),
+        // Announce errors to screen readers
+        c.role("alert"),
+        // Mark as alert for immediate attention
+        a
+      )
+    ) : null,
+    ...d
+  );
+};
+function ot(...e) {
+  return p.div(c.class("bc-group"), ...e);
+}
+function lt(...e) {
+  return p.div(c.class("bc-stack"), ...e);
+}
+const ct = (e) => {
+  const t = {
+    name: "email",
+    autocomplete: "email",
+    ...e
+  }, {
+    value: s,
+    before: n,
+    onBlur: r,
+    onChange: a,
+    onInput: i,
+    placeholder: o
+  } = t, l = n ?? B({
+    icon: "line-md:email",
+    size: "sm",
+    color: "neutral"
+  });
+  return O(
+    V,
+    (h) => R({
+      ...e,
+      before: l,
+      input: X.email(
+        z(t),
+        c.placeholder(G(o, h.$.emailPlaceholderText)),
+        c.value(s),
+        c.class("bc-input"),
+        r != null ? y.blur($(r)) : v,
+        a != null ? y.change($(a)) : v,
+        i != null ? y.input($(i)) : v
+      )
+    })
+  );
+}, ut = (e) => {
+  const { value: t, onBlur: s, onChange: n, onInput: r } = e;
+  return R({
+    ...e,
+    input: X.text(
+      z(e),
+      c.value(t),
+      c.class("bc-input"),
+      s != null ? y.blur($(s)) : v,
+      n != null ? y.change($(n)) : v,
+      r != null ? y.input($(r)) : v
+    )
+  });
+}, dt = (e) => {
+  const {
+    value: t,
+    onBlur: s,
+    onChange: n,
+    onInput: r,
+    before: a,
+    after: i,
+    hasError: o,
+    disabled: l,
+    autocomplete: h,
+    placeholder: d,
+    ...u
+  } = e, b = {
+    name: "password",
+    disabled: l,
+    ...u
+  }, g = _(!0), S = I(
+    g,
+    h
+  )((m, C) => m ? C ?? "current-password" : "off");
+  return O(V, (m) => {
+    const C = I(
+      m.$.passwordPlaceholderText,
+      g,
+      d
+    )((A, le, ce) => le ? "•••••••••••••••" : ce ?? A), E = p.button(
+      c.class("bc-input-container__password-toggle bu-text-light-gray"),
+      k.label(m.$.togglePasswordVisibility),
+      y.click(() => g.update((A) => !A)),
+      T(
+        g,
+        () => B({ icon: "line-md:watch" }),
+        () => B({ icon: "line-md:watch-off" })
+      )
+    );
+    return R({
+      before: a,
+      disabled: l,
+      hasError: o,
+      input: p.input(
+        z({
+          ...b,
+          autocomplete: S,
+          placeholder: C
+        }),
+        T(
+          g,
+          () => M(c.type("password")),
+          () => M(c.type("text"))
+        ),
+        c.class("bc-input"),
+        c.value(t),
+        s != null ? y.blur($(s)) : v,
+        n != null ? y.change($(n)) : v,
+        r != null ? y.input($(r)) : v
+      ),
+      after: i != null ? M(E, i) : E
+    });
+  });
+}, je = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (e, t) => () => {
+    e.markTouched(), t?.();
+  }
+), Ne = (e, t) => (s) => {
+  e.change(s), t?.(s);
+};
+function ae(e, t) {
+  const { controller: s, onBlur: n, onChange: r, ...a } = t;
+  return e({
+    id: s.name,
+    disabled: s.disabled,
+    value: s.value,
+    hasError: s.errorVisible,
+    ...a,
+    onChange: Ne(s, r),
+    onBlur: je(s, n)
+  });
+}
+function ht(e, t, ...s) {
+  return re(
+    {
+      ...t,
+      content: ae(
+        e,
+        t
+      )
+    },
+    ...s
+  );
+}
+function Fe(e, t) {
+  const { toInput: s, fromInput: n, controller: r, ...a } = t, i = r.transform(s, n);
+  return ae(e, {
+    ...a,
+    controller: i
+  });
+}
+function pt(e, t, ...s) {
+  return re(
+    {
+      ...t,
+      content: Fe(e, t)
+    },
+    ...s
+  );
+}
+function ft(e) {
+  return e.split(".").map((s) => {
+    const n = s.match(/^\[(\d+)\]$/);
+    return n ? Number(n[1]) : s;
+  });
+}
+function qe(e) {
+  return typeof e == "number" ? `[${e}]` : `.${e}`;
+}
+function Re(e) {
+  if (e.length === 0) return "";
+  const [t, ...s] = e;
+  return [
+    typeof t == "number" ? `[${t}]` : t,
+    ...s.map(qe)
+  ].join("");
+}
+function q(e) {
+  return function(s) {
+    if (s.type === "valid") return s;
+    let n = s.error;
+    for (const r of e)
+      if (n = n?.dependencies?.[r], n == null) return D.valid;
+    return D.invalid(n);
+  };
+}
+class x {
+  path;
+  change;
+  value;
+  status;
+  error;
+  hasError;
+  touched;
+  errorVisible;
+  dirty;
+  dependencyErrors;
+  #e = {
+    disabled: _(!1),
+    touched: _(!1)
+  };
+  #s;
+  #t = _(void 0);
+  parent;
+  disabled;
+  #n = [];
+  disabledOrHasErrors;
+  constructor(t, s, n, r, a, i = L) {
+    this.path = t, this.change = s, this.value = n, this.status = r, this.#s = i, this.#t.set(n.value), this.error = r.map(
+      (o) => o?.type === "invalid" ? o.error?.message : void 0
+    ), this.hasError = this.error.map((o) => o != null), this.touched = this.#e.touched, a.validationMode ? this.errorVisible = I(
+      this.hasError,
+      this.touched,
+      a.validationMode
+    )((o, l, h) => h === "continuous" ? !!o : !!o && !!l) : this.errorVisible = I(
+      this.hasError,
+      this.touched
+    )((o, l) => !!o && !!l), this.dirty = I(
+      this.value,
+      this.#t
+    )((o, l) => !this.#s(o, l)), this.dependencyErrors = r.map(
+      (o) => o?.type === "invalid" ? o.error?.dependencies : void 0
+    ), this.parent = a, this.disabled = I(
+      this.#e.disabled,
+      a.disabled
+    )((o, l) => o || l), this.disabledOrHasErrors = I(
+      this.disabled,
+      this.hasError
+    )((o, l) => o || l), this.onDispose(() => {
+      this.#e.disabled.dispose(), this.#e.touched.dispose(), this.disabled.dispose(), this.error.dispose(), this.errorVisible.dispose(), this.dirty.dispose(), this.#t.dispose(), this.dependencyErrors.dispose(), this.disabledOrHasErrors.dispose();
+    });
+  }
+  get name() {
+    return Re(this.path);
+  }
+  onDispose = (t) => {
+    this.#n.push(t);
+  };
+  dispose = () => {
+    for (const t of this.#n)
+      try {
+        t();
+      } catch (s) {
+        console.error("Error in dispose callback:", s);
+      }
+    this.#n.length = 0;
+  };
+  setDisabled = (t) => {
+    this.#e.disabled.set(t);
+  };
+  disable = () => this.setDisabled(!0);
+  enable = () => this.setDisabled(!1);
+  markTouched = () => {
+    this.#e.touched.set(!0);
+  };
+  resetTouched = () => {
+    this.#e.touched.set(!1);
+  };
+  markPristine = () => {
+    this.#t.set(this.value.value);
+  };
+  reset = () => {
+    this.change(this.#t.value);
+  };
+  array = (t = L) => new Ue(
+    this.path,
+    this.change,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.value,
+    this.status,
+    this.parent,
+    t
+  );
+  object = (t = L) => new He(
+    this.path,
+    this.change,
+    this.value,
+    this.status,
+    this.parent,
+    t
+  );
+  transform = (t, s, n = [], r = L) => new x(
+    [...this.path, ...n],
+    (a) => this.change(s(a)),
+    this.value.map(t, r),
+    this.status.map(q(n)),
+    this.parent,
+    r
+  );
+  asyncTransform = (t, s, n, r = [], a = L) => new x(
+    [...this.path, ...r],
+    (i) => {
+      s(i).then((o) => this.change(o));
+    },
+    this.value.mapAsync(t, n, void 0, a),
+    this.status.map(q(r)),
+    this.parent,
+    a
+  );
+}
+class He extends x {
+  #e = /* @__PURE__ */ new Map();
+  #s = /* @__PURE__ */ new Map();
+  #t = /* @__PURE__ */ new Map();
+  #n = _(!1);
+  touchedDeep = this.#n;
+  #a = /* @__PURE__ */ new Map();
+  #r = /* @__PURE__ */ new Map();
+  #o = _(!1);
+  dirtyDeep = this.#o;
+  #c;
+  #u;
+  #l = () => {
+    let t = !1;
+    for (const s of this.#s.values())
+      if (s) {
+        t = !0;
+        break;
+      }
+    this.#n.set(this.touched.value || t);
+  };
+  constructor(t, s, n, r, a, i) {
+    super(
+      t,
+      s,
+      n.map((l) => l ?? {}, i),
+      r,
+      a,
+      i
+    ), this.#c = this.touched.on(() => {
+      this.#l();
+    }), this.#u = this.dirty.on(() => {
+      this.#i();
+    });
+    const o = this.value.on(() => this.#i());
+    this.onDispose(() => {
+      for (const l of this.#e.values())
+        l.dispose();
+      this.#e.clear();
+      for (const l of this.#t.values()) l();
+      this.#t.clear(), this.#s.clear(), this.#n.dispose();
+      for (const l of this.#r.values()) l();
+      this.#r.clear(), this.#a.clear(), this.#o.dispose(), this.#c(), this.#u(), o();
+    });
+  }
+  field = (t) => {
+    if (this.#e.has(t))
+      return this.#e.get(t);
+    const s = async (i) => {
+      this.change({
+        ...this.value.value,
+        [t]: i
+      });
+    }, n = new x(
+      [...this.path, t],
+      s,
+      this.value.map((i) => i[t]),
+      this.status.map(q([t])),
+      {
+        disabled: this.disabled,
+        // propagate validationMode to children if present
+        validationMode: this.parent.validationMode
+      }
+    );
+    this.#e.set(t, n);
+    const r = n.touched.on((i) => {
+      this.#s.set(t, i), this.#l();
+    });
+    this.#t.set(t, r);
+    const a = n.dirty.on((i) => {
+      this.#a.set(t, i), this.#i();
+    });
+    return this.#r.set(t, a), n;
+  };
+  markAllTouched = () => {
+    this.markTouched();
+    const t = this.value.value;
+    for (const s of Object.keys(t))
+      this.field(s).markTouched();
+    for (const s of this.#e.values())
+      s.markTouched();
+  };
+  markAllPristine = () => {
+    this.markPristine();
+    const t = this.value.value;
+    for (const s of Object.keys(t))
+      this.field(s).markPristine?.();
+    for (const s of this.#e.values())
+      s.markPristine?.();
+  };
+  #i = () => {
+    let t = !1;
+    for (const s of this.#a.values())
+      if (s) {
+        t = !0;
+        break;
+      }
+    this.#o.set(this.dirty.value || t);
+  };
+}
+class Ue extends x {
+  #e = new Array();
+  length;
+  #s = /* @__PURE__ */ new Map();
+  #t = /* @__PURE__ */ new Map();
+  #n = _(!1);
+  touchedDeep = this.#n;
+  #a = /* @__PURE__ */ new Map();
+  #r = /* @__PURE__ */ new Map();
+  #o = _(!1);
+  dirtyDeep = this.#o;
+  #c;
+  #u;
+  #l = () => {
+    let t = !1;
+    for (const s of this.#s.values())
+      if (s) {
+        t = !0;
+        break;
+      }
+    this.#n.set(this.touched.value || t);
+  };
+  constructor(t, s, n, r, a, i) {
+    const o = n.map((d) => d ?? [], i);
+    super(t, s, o, r, a, i);
+    const l = o.on((d) => {
+      const u = this.#e.length - d.length;
+      u > 0 && (this.#e.splice(d.length, u).forEach((b, g) => {
+        const S = d.length + g;
+        b.dispose(), this.#t.get(S)?.(), this.#t.delete(S), this.#s.delete(S), this.#r.get(S)?.(), this.#r.delete(S), this.#a.delete(S);
+      }), this.#l(), this.#i());
+    });
+    this.length = o.map((d) => d.length), this.#c = this.touched.on(() => {
+      this.#l();
+    }), this.#u = this.dirty.on(() => {
+      this.#i();
+    });
+    const h = this.value.on(() => this.#i());
+    this.onDispose(() => {
+      for (const d of this.#e)
+        d.dispose();
+      this.length.dispose(), this.#e.length = 0, l(), o.dispose();
+      for (const d of this.#t.values()) d();
+      this.#t.clear(), this.#s.clear(), this.#n.dispose();
+      for (const d of this.#r.values()) d();
+      this.#r.clear(), this.#a.clear(), this.#o.dispose(), this.#c(), this.#u(), h();
+    });
+  }
+  item = (t) => {
+    if (this.#e[t])
+      return this.#e[t];
+    const s = async (i) => {
+      const o = this.value.value.slice();
+      o[t] = i, this.change(o);
+    }, n = new x(
+      [...this.path, t],
+      s,
+      this.value.map((i) => i[t]),
+      this.status.map(q([t])),
+      {
+        disabled: this.disabled,
+        validationMode: this.parent.validationMode
+      }
+    );
+    this.#e[t] = n;
+    const r = n.touched.on((i) => {
+      this.#s.set(t, i), this.#l();
+    });
+    this.#t.set(t, r);
+    const a = n.dirty.on((i) => {
+      this.#a.set(t, i), this.#i();
+    });
+    return this.#r.set(t, a), n;
+  };
+  push = (...t) => {
+    this.change([...this.value.value, ...t]);
+  };
+  pop = () => {
+    this.splice(this.value.value.length - 1, 1);
+  };
+  shift = () => {
+    this.splice(0, 1);
+  };
+  unshift = (...t) => {
+    this.change([...t, ...this.value.value]);
+  };
+  removeAt = (t) => {
+    this.splice(t, 1);
+  };
+  splice = (t, s) => {
+    const n = this.value.value.slice();
+    n.splice(t, s), this.change(n);
+  };
+  move = (t, s, n = 1) => {
+    if (n < 1 || t === s) return;
+    const r = this.value.value.slice(), a = r.splice(t, n);
+    r.splice(s, 0, ...a), this.change(r);
+  };
+  markAllTouched = () => {
+    this.markTouched();
+    const t = this.value.value.length;
+    for (let s = 0; s < t; s++)
+      this.item(s).markTouched();
+  };
+  markAllPristine = () => {
+    this.markPristine();
+    const t = this.value.value.length;
+    for (let s = 0; s < t; s++)
+      this.item(s).markPristine?.();
+  };
+  #i = () => {
+    let t = !1;
+    for (const s of this.#a.values())
+      if (s) {
+        t = !0;
+        break;
+      }
+    this.#o.set(this.dirty.value || t);
+  };
+}
+function Ge(e) {
+  function t(s) {
+    return typeof s == "number" ? s : s.toString();
+  }
+  return e.map(
+    (s) => typeof s == "object" && s.key != null ? t(s.key) : t(s)
+  );
+}
+function ze(e) {
+  const t = e.filter((r) => r.path == null || r.path.length === 0).map((r) => r.message), s = e.filter((r) => r.path != null && r.path.length > 0).reduce((r, a) => {
+    const i = Ge(a.path), o = i.pop();
+    let l = r;
+    for (const h of i)
+      l.dependencies == null && (l.dependencies = {}), l.dependencies[h] == null && (l.dependencies[h] = {}), l = l.dependencies[h];
+    return l.dependencies == null && (l.dependencies = {}), l.dependencies[o] = { message: a.message }, r;
+  }, {}), n = t.join(`
+`);
+  return {
+    ...s,
+    message: n != "" ? n : void 0
+  };
+}
+function We({
+  initialValue: e,
+  onChange: t,
+  validate: s,
+  equals: n,
+  validationMode: r,
+  validateDebounceMs: a
+}) {
+  const i = P.deriveProp(e), o = _(D.valid), l = _(!1), h = _(r ?? "touchedOrSubmit"), d = (m) => {
+    o.set(m);
+  };
+  let u;
+  const b = async (m) => {
+    if (s != null) {
+      const C = await s(m);
+      d(C);
+    }
+  }, g = async (m) => {
+    i.set(m), t?.(m);
+    const C = h.value;
+    if (s != null) {
+      if (C === "onSubmit")
+        return;
+      const E = a ?? 0;
+      E > 0 ? (u && clearTimeout(u), u = setTimeout(() => {
+        b(m);
+      }, E)) : await b(m);
+    }
+  }, S = new x(
+    [],
+    g,
+    i,
+    o,
+    {
+      disabled: l,
+      validationMode: h
+    },
+    n ?? L
+  );
+  return S.onDispose(() => {
+    l.dispose(), i.dispose(), o.dispose(), h.dispose(), u && clearTimeout(u);
+  }), { controller: S, setStatus: d };
+}
+function ie(e) {
+  return M(c.disabled(e.disabled), c.name(e.name));
+}
+function mt(e, {
+  triggerOn: t = "change"
+} = {}) {
+  return M(
+    ie(e),
+    c.value(e.value),
+    (t === "input" ? y.input : y.change)($(e.change))
+  );
+}
+function bt(e, {
+  triggerOn: t = "change"
+} = {}) {
+  return M(
+    ie(e),
+    c.valueAsNumber(e.value),
+    (t === "input" ? y.input : y.change)(
+      de(e.change)
+    )
+  );
+}
+function Q(e) {
+  return e.issues != null ? D.invalid(ze(e.issues)) : D.valid;
+}
+async function gt({
+  task: e,
+  errorMessage: t,
+  errorPath: s = ["root"],
+  validation: n
+}) {
+  try {
+    const r = await e();
+    return n != null ? n(r) : D.valid;
+  } catch (r) {
+    const a = t ?? (r instanceof Error ? r.message : "Operation failed");
+    return s.length === 1 && s[0] === "root" ? D.invalid({
+      message: a
+    }) : D.invalid({
+      dependencies: oe(s, a)
+    });
+  }
+}
+function oe(e, t) {
+  if (e.length === 1)
+    return {
+      [e[0]]: { message: t }
+    };
+  const [s, ...n] = e;
+  return {
+    [s]: {
+      dependencies: oe(n, t)
+    }
+  };
+}
+function vt({
+  initialValue: e = {},
+  schema: t,
+  submit: s = async () => D.valid,
+  validationMode: n,
+  validateDebounceMs: r
+}) {
+  const { controller: a, setStatus: i } = We({
+    initialValue: e,
+    validationMode: n ?? "touchedOrSubmit",
+    validateDebounceMs: r,
+    validate: (n ?? "touchedOrSubmit") === "onSubmit" ? void 0 : async (d) => Q(
+      await t["~standard"].validate(d)
+    )
+  }), o = _(!1), l = a.object();
+  return l.onDispose(o.dispose), {
+    controller: l,
+    setStatus: i,
+    onSubmit: async (d) => {
+      if (o.set(!0), d.preventDefault(), l.markAllTouched(), (n ?? "touchedOrSubmit") === "onSubmit") {
+        const b = l.value.value, g = Q(
+          await t["~standard"].validate(b)
+        );
+        if (i(g), g.type === "invalid") {
+          o.set(!1);
+          return;
+        }
+      }
+      const u = await s(l.value.value);
+      o.set(!1), u.type === "invalid" && i(u);
+    },
+    submitting: o
+  };
+}
+function Ke(e) {
+  const t = e.split("-"), s = [e];
+  return t.length > 1 && s.push(t[0]), s;
+}
+function Je({
+  locale: e,
+  defaultLocale: t = "en-US",
+  defaultMessages: s,
+  localeLoader: n
+}) {
+  const r = _(t), a = _(s), i = e.on(async (o) => {
+    if (o === r.value) return;
+    r.set(o);
+    const l = Ke(o);
+    for (const h of l)
+      try {
+        const d = await n(h);
+        if (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          typeof d.default == "object" && Object.keys(d).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 (o === r.value) {
+          a.set(d);
+          return;
+        }
+      } catch {
+        continue;
+      }
+    console.warn(`No locale found for "'${e}", using fallback`), o === r.value && a.set(s);
+  });
+  return {
+    /** Clean up all resources and event listeners */
+    dispose: () => {
+      i(), r.dispose(), a.dispose();
+    },
+    /** Translation functions that return reactive signals */
+    t: a
+  };
+}
+function Qe({
+  defaultLocale: e,
+  defaultMessages: t,
+  localeLoader: s,
+  providerName: n = "I18nProvider"
+}) {
+  return {
+    mark: Y(n),
+    create: (r, a) => {
+      const {
+        value: { locale: i }
+      } = a.getProvider(Se.mark), { t: o, dispose: l } = Je({
+        locale: i,
+        defaultMessages: t,
+        defaultLocale: e,
+        localeLoader: s
+      });
+      return {
+        value: o,
+        dispose: l
+      };
+    }
+  };
+}
+const V = Qe({
+  defaultLocale: ge,
+  defaultMessages: be,
+  localeLoader: async (e) => (await ve(/* @__PURE__ */ Object.assign({ "./locales/ar.ts": () => import("./ar-RkpJ2n6w.js"), "./locales/de.ts": () => import("./de-BdSVR4Zm.js"), "./locales/en.ts": () => Promise.resolve().then(() => me), "./locales/es.ts": () => import("./es-B_Qn5EUy.js"), "./locales/fa.ts": () => import("./fa-jBaLjqfG.js"), "./locales/fr.ts": () => import("./fr-B0KaMM2j.js"), "./locales/he.ts": () => import("./he-DjeYjcW7.js"), "./locales/hi.ts": () => import("./hi-DxBQV0uz.js"), "./locales/it.ts": () => import("./it-B4qZsicu.js"), "./locales/ja.ts": () => import("./ja-BnCSmhkg.js"), "./locales/ko.ts": () => import("./ko-D_gGkjrC.js"), "./locales/nl.ts": () => import("./nl-CsLCWUFF.js"), "./locales/pl.ts": () => import("./pl-Bsmj1KbZ.js"), "./locales/pt.ts": () => import("./pt-BR_NuRJS.js"), "./locales/ru.ts": () => import("./ru-CiQ_qKD_.js"), "./locales/tr.ts": () => import("./tr-Q9xP1nE4.js"), "./locales/ur.ts": () => import("./ur-CGTjSoJt.js"), "./locales/vi.ts": () => import("./vi-BF3HTFU9.js"), "./locales/zh.ts": () => import("./zh-BreM8U2w.js") }), `./locales/${e}.ts`, 3)).default,
+  providerName: "BeatUII18n"
+});
+export {
+  Je as $,
+  qe as A,
+  V as B,
+  nt as C,
+  Re as D,
+  ct as E,
+  He as F,
+  ot as G,
+  Ue as H,
+  B as I,
+  Ge as J,
+  ze as K,
+  xe as L,
+  pt as M,
+  We as N,
+  L as O,
+  dt as P,
+  ie as Q,
+  Be as R,
+  lt as S,
+  ut as T,
+  mt as U,
+  bt as V,
+  Q as W,
+  rt as X,
+  Le as Y,
+  at as Z,
+  ve as _,
+  $e as a,
+  se as a0,
+  we as a1,
+  Xe as a2,
+  et as a3,
+  tt as a4,
+  ke as a5,
+  st as a6,
+  D as b,
+  it as c,
+  ht as d,
+  R as e,
+  K as f,
+  z as g,
+  je as h,
+  Ne as i,
+  re as j,
+  be as k,
+  Se as l,
+  Qe as m,
+  x as n,
+  q as o,
+  ae as p,
+  Pe as q,
+  ge as r,
+  ee as s,
+  gt as t,
+  vt as u,
+  ne as v,
+  _e as w,
+  Ce as x,
+  Fe as y,
+  ft as z
+};