mal-ui 0.1.3

package/dist/form/index.js

@@ -0,0 +1,1605 @@
+"use client";
+import {
+  __commonJS,
+  __toESM
+} from "../chunks/index-mc01z7m9.js";
+
+// node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS((exports, module) => {
+  module.exports = function equal(a, b) {
+    if (a === b)
+      return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+      if (a.constructor !== b.constructor)
+        return false;
+      var length, i, keys;
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length)
+          return false;
+        for (i = length;i-- !== 0; )
+          if (!equal(a[i], b[i]))
+            return false;
+        return true;
+      }
+      if (a.constructor === RegExp)
+        return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf)
+        return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString)
+        return a.toString() === b.toString();
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length)
+        return false;
+      for (i = length;i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+          return false;
+      for (i = length;i-- !== 0; ) {
+        var key = keys[i];
+        if (!equal(a[key], b[key]))
+          return false;
+      }
+      return true;
+    }
+    return a !== a && b !== b;
+  };
+});
+
+// node_modules/@mantine/form/esm/actions/actions.mjs
+import { useEffect, useLayoutEffect } from "react";
+
+function dispatchEvent(type, detail) {
+  window.dispatchEvent(new CustomEvent(type, { detail }));
+}
+function validateFormName(name) {
+  if (!/^[0-9a-zA-Z-]+$/.test(name))
+    throw new Error(`[@mantine/use-form] Form name "${name}" is invalid, it should contain only letters, numbers and dashes`);
+}
+var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function createFormActions(name) {
+  validateFormName(name);
+  const setFieldValue = (path, value) => dispatchEvent(`mantine-form:${name}:set-field-value`, {
+    path,
+    value
+  });
+  const setValues = (values) => dispatchEvent(`mantine-form:${name}:set-values`, values);
+  const setInitialValues = (values) => dispatchEvent(`mantine-form:${name}:set-initial-values`, values);
+  const setErrors = (errors) => dispatchEvent(`mantine-form:${name}:set-errors`, errors);
+  const setFieldError = (path, error) => dispatchEvent(`mantine-form:${name}:set-field-error`, {
+    path,
+    error
+  });
+  const clearFieldError = (path) => dispatchEvent(`mantine-form:${name}:clear-field-error`, path);
+  const clearErrors = () => dispatchEvent(`mantine-form:${name}:clear-errors`);
+  const reset = () => dispatchEvent(`mantine-form:${name}:reset`);
+  const validate = () => dispatchEvent(`mantine-form:${name}:validate`);
+  const validateField = (path) => dispatchEvent(`mantine-form:${name}:validate-field`, path);
+  const reorderListItem = (path, payload) => dispatchEvent(`mantine-form:${name}:reorder-list-item`, {
+    path,
+    payload
+  });
+  const removeListItem = (path, index) => dispatchEvent(`mantine-form:${name}:remove-list-item`, {
+    path,
+    index
+  });
+  const insertListItem = (path, item, index) => dispatchEvent(`mantine-form:${name}:insert-list-item`, {
+    path,
+    index,
+    item
+  });
+  const setDirty = (value) => dispatchEvent(`mantine-form:${name}:set-dirty`, value);
+  const setTouched = (value) => dispatchEvent(`mantine-form:${name}:set-touched`, value);
+  const resetDirty = (values) => dispatchEvent(`mantine-form:${name}:reset-dirty`, values);
+  const resetTouched = () => dispatchEvent(`mantine-form:${name}:reset-touched`);
+  return {
+    setFieldValue,
+    setValues,
+    setInitialValues,
+    setErrors,
+    setFieldError,
+    clearFieldError,
+    clearErrors,
+    reset,
+    validate,
+    validateField,
+    reorderListItem,
+    removeListItem,
+    insertListItem,
+    setDirty,
+    setTouched,
+    resetDirty,
+    resetTouched
+  };
+}
+function useFormEvent(eventKey, handler) {
+  useIsomorphicEffect(() => {
+    if (eventKey) {
+      window.addEventListener(eventKey, handler);
+      return () => window.removeEventListener(eventKey, handler);
+    }
+  }, [eventKey]);
+}
+function useFormActions(name, form) {
+  if (name)
+    validateFormName(name);
+  useFormEvent(`mantine-form:${name}:set-field-value`, (event) => form.setFieldValue(event.detail.path, event.detail.value));
+  useFormEvent(`mantine-form:${name}:set-values`, (event) => form.setValues(event.detail));
+  useFormEvent(`mantine-form:${name}:set-initial-values`, (event) => form.setInitialValues(event.detail));
+  useFormEvent(`mantine-form:${name}:set-errors`, (event) => form.setErrors(event.detail));
+  useFormEvent(`mantine-form:${name}:set-field-error`, (event) => form.setFieldError(event.detail.path, event.detail.error));
+  useFormEvent(`mantine-form:${name}:clear-field-error`, (event) => form.clearFieldError(event.detail));
+  useFormEvent(`mantine-form:${name}:clear-errors`, form.clearErrors);
+  useFormEvent(`mantine-form:${name}:reset`, form.reset);
+  useFormEvent(`mantine-form:${name}:validate`, form.validate);
+  useFormEvent(`mantine-form:${name}:validate-field`, (event) => form.validateField(event.detail));
+  useFormEvent(`mantine-form:${name}:reorder-list-item`, (event) => form.reorderListItem(event.detail.path, event.detail.payload));
+  useFormEvent(`mantine-form:${name}:remove-list-item`, (event) => form.removeListItem(event.detail.path, event.detail.index));
+  useFormEvent(`mantine-form:${name}:insert-list-item`, (event) => form.insertListItem(event.detail.path, event.detail.item, event.detail.index));
+  useFormEvent(`mantine-form:${name}:set-dirty`, (event) => form.setDirty(event.detail));
+  useFormEvent(`mantine-form:${name}:set-touched`, (event) => form.setTouched(event.detail));
+  useFormEvent(`mantine-form:${name}:reset-dirty`, (event) => form.resetDirty(event.detail));
+  useFormEvent(`mantine-form:${name}:reset-touched`, form.resetTouched);
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-errors/filter-errors/filter-errors.mjs
+
+function filterErrors(errors) {
+  if (errors === null || typeof errors !== "object")
+    return {};
+  return Object.keys(errors).reduce((acc, key) => {
+    const errorValue = errors[key];
+    if (errorValue !== undefined && errorValue !== null && errorValue !== false)
+      acc[key] = errorValue;
+    return acc;
+  }, {});
+}
+
+// node_modules/@mantine/form/esm/paths/get-splitted-path.mjs
+
+function getSplittedPath(path) {
+  if (typeof path !== "string")
+    return [];
+  return path.split(".");
+}
+
+// node_modules/@mantine/form/esm/paths/get-path.mjs
+
+function getPath(path, values) {
+  const splittedPath = getSplittedPath(path);
+  if (splittedPath.length === 0 || typeof values !== "object" || values === null)
+    return;
+  let value = values[splittedPath[0]];
+  for (let i = 1;i < splittedPath.length; i += 1) {
+    if (value == null)
+      break;
+    value = value[splittedPath[i]];
+  }
+  return value;
+}
+
+// node_modules/@mantine/form/esm/validate/validate-values.mjs
+
+var formRootRule = Symbol("root-rule");
+function getValidationResults(errors) {
+  const filteredErrors = filterErrors(errors);
+  return {
+    hasErrors: Object.keys(filteredErrors).length > 0,
+    errors: filteredErrors
+  };
+}
+function validateRulesRecord(rules, values, resolveValidationError, signal, path = "", errors = {}) {
+  if (typeof rules !== "object" || rules === null)
+    return errors;
+  const asyncTasks = [];
+  const pendingRecursions = [];
+  for (const ruleKey of Object.keys(rules)) {
+    const rule = rules[ruleKey];
+    const rulePath = `${path === "" ? "" : `${path}.`}${ruleKey}`;
+    const value = getPath(rulePath, values);
+    let arrayValidation = false;
+    if (typeof rule === "function") {
+      const result = rule(value, values, rulePath, signal);
+      if (result instanceof Promise)
+        asyncTasks.push({
+          rulePath,
+          promise: result
+        });
+      else
+        errors[rulePath] = result;
+    }
+    if (typeof rule === "object" && Array.isArray(value)) {
+      arrayValidation = true;
+      for (let index = 0;index < value.length; index++) {
+        const recursionResult = validateRulesRecord(rule, values, resolveValidationError, signal, `${rulePath}.${index}`, errors);
+        if (recursionResult instanceof Promise)
+          pendingRecursions.push(recursionResult);
+      }
+      if (formRootRule in rule) {
+        const rootResult = rule[formRootRule](value, values, rulePath, signal);
+        if (rootResult instanceof Promise)
+          asyncTasks.push({
+            rulePath,
+            promise: rootResult
+          });
+        else
+          errors[rulePath] = rootResult;
+      }
+    }
+    if (typeof rule === "object" && typeof value === "object" && value !== null) {
+      if (!arrayValidation) {
+        const recursionResult = validateRulesRecord(rule, values, resolveValidationError, signal, rulePath, errors);
+        if (recursionResult instanceof Promise)
+          pendingRecursions.push(recursionResult);
+      }
+      if (formRootRule in rule) {
+        const rootResult = rule[formRootRule](value, values, rulePath, signal);
+        if (rootResult instanceof Promise)
+          asyncTasks.push({
+            rulePath,
+            promise: rootResult
+          });
+        else
+          errors[rulePath] = rootResult;
+      }
+    }
+  }
+  if (asyncTasks.length === 0 && pendingRecursions.length === 0)
+    return errors;
+  return (async () => {
+    await Promise.all(pendingRecursions);
+    if (asyncTasks.length > 0)
+      (await Promise.allSettled(asyncTasks.map((t) => t.promise))).forEach((result, index) => {
+        const { rulePath } = asyncTasks[index];
+        if (result.status === "fulfilled")
+          errors[rulePath] = result.value;
+        else
+          errors[rulePath] = resolveValidationError(result.reason);
+      });
+    return errors;
+  })();
+}
+var defaultResolveError = (err) => err instanceof Error ? err.message : String(err);
+function validateValues(validate, values, resolveValidationError = defaultResolveError, signal = new AbortController().signal) {
+  if (typeof validate === "function") {
+    const result = validate(values);
+    if (result instanceof Promise)
+      return result.then(getValidationResults);
+    return getValidationResults(result);
+  }
+  const errorsResult = validateRulesRecord(validate, values, resolveValidationError, signal);
+  if (errorsResult instanceof Promise)
+    return errorsResult.then(getValidationResults);
+  return getValidationResults(errorsResult);
+}
+
+// node_modules/@mantine/form/esm/form-index.mjs
+
+var FORM_INDEX = "__MANTINE_FORM_INDEX__";
+
+// node_modules/@mantine/form/esm/get-input-on-change/get-input-on-change.mjs
+
+function getInputOnChange(setValue) {
+  return (val) => {
+    if (!val)
+      setValue(val);
+    else if (typeof val === "function")
+      setValue(val);
+    else if (typeof val === "object" && "nativeEvent" in val) {
+      const { currentTarget } = val;
+      if (currentTarget instanceof HTMLInputElement)
+        if (currentTarget.type === "checkbox")
+          setValue(currentTarget.checked);
+        else
+          setValue(currentTarget.value);
+      else if (currentTarget instanceof HTMLTextAreaElement || currentTarget instanceof HTMLSelectElement)
+        setValue(currentTarget.value);
+    } else
+      setValue(val);
+  };
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-errors/use-form-errors.mjs
+import { useCallback, useRef, useState } from "react";
+
+function useFormErrors(initialErrors) {
+  const [errorsState, setErrorsState] = useState(filterErrors(initialErrors));
+  const errorsRef = useRef(errorsState);
+  const setErrors = useCallback((errors) => {
+    setErrorsState((current) => {
+      const newErrors = filterErrors(typeof errors === "function" ? errors(current) : errors);
+      errorsRef.current = newErrors;
+      return newErrors;
+    });
+  }, []);
+  const clearErrors = useCallback(() => setErrors({}), []);
+  const clearFieldError = useCallback((path) => {
+    if (errorsRef.current[path] === undefined)
+      return;
+    setErrors((current) => {
+      const errors = { ...current };
+      delete errors[path];
+      return errors;
+    });
+  }, [errorsState]);
+  return {
+    errorsState,
+    setErrors,
+    clearErrors,
+    setFieldError: useCallback((path, error) => {
+      if (error == null || error === false)
+        clearFieldError(path);
+      else if (errorsRef.current[path] !== error)
+        setErrors((current) => ({
+          ...current,
+          [path]: error
+        }));
+    }, [errorsState]),
+    clearFieldError
+  };
+}
+
+// node_modules/@mantine/form/esm/paths/get-data-path.mjs
+
+function getDataPath(formName, fieldPath) {
+  return formName ? `${formName}-${fieldPath.toString()}` : fieldPath.toString();
+}
+
+// node_modules/@mantine/form/esm/lists/clear-list-state.mjs
+
+function clearListState(field, state) {
+  if (state === null || typeof state !== "object")
+    return {};
+  const clone = { ...state };
+  Object.keys(state).forEach((errorKey) => {
+    if (errorKey.includes(`${String(field)}.`))
+      delete clone[errorKey];
+  });
+  return clone;
+}
+
+// node_modules/@mantine/form/esm/lists/change-error-indices.mjs
+
+function getIndexFromKeyAfterPath(key, path) {
+  const split = key.substring(path.length + 1).split(".")[0];
+  return parseInt(split, 10);
+}
+function changeErrorIndices(path, index, errors, change) {
+  if (index === undefined)
+    return errors;
+  const pathString = `${String(path)}`;
+  let clearedErrors = errors;
+  if (change === -1)
+    clearedErrors = clearListState(`${pathString}.${index}`, clearedErrors);
+  const cloned = { ...clearedErrors };
+  const changedKeys = /* @__PURE__ */ new Set;
+  Object.entries(clearedErrors).filter(([key]) => {
+    if (!key.startsWith(`${pathString}.`))
+      return false;
+    const currIndex = getIndexFromKeyAfterPath(key, pathString);
+    if (Number.isNaN(currIndex))
+      return false;
+    return currIndex >= index;
+  }).forEach(([key, value]) => {
+    const currIndex = getIndexFromKeyAfterPath(key, pathString);
+    const newKey = key.replace(`${pathString}.${currIndex}`, `${pathString}.${currIndex + change}`);
+    cloned[newKey] = value;
+    changedKeys.add(newKey);
+    if (!changedKeys.has(key))
+      delete cloned[key];
+  });
+  return cloned;
+}
+
+// node_modules/@mantine/form/esm/lists/reorder-errors.mjs
+
+function reorderErrors(path, { from, to }, errors) {
+  const oldKeyStart = `${path}.${from}`;
+  const newKeyStart = `${path}.${to}`;
+  const clone = { ...errors };
+  const processedKeys = /* @__PURE__ */ new Set;
+  Object.keys(errors).forEach((key) => {
+    if (processedKeys.has(key))
+      return;
+    let oldKey;
+    let newKey;
+    if (key.startsWith(oldKeyStart)) {
+      oldKey = key;
+      newKey = key.replace(oldKeyStart, newKeyStart);
+    } else if (key.startsWith(newKeyStart)) {
+      oldKey = key.replace(newKeyStart, oldKeyStart);
+      newKey = key;
+    }
+    if (oldKey && newKey) {
+      const value1 = clone[oldKey];
+      const value2 = clone[newKey];
+      value2 === undefined ? delete clone[oldKey] : clone[oldKey] = value2;
+      value1 === undefined ? delete clone[newKey] : clone[newKey] = value1;
+      processedKeys.add(oldKey);
+      processedKeys.add(newKey);
+    }
+  });
+  return clone;
+}
+
+// node_modules/klona/full/index.mjs
+function set(obj, key, val) {
+  if (typeof val.value === "object")
+    val.value = klona(val.value);
+  if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
+    Object.defineProperty(obj, key, val);
+  } else
+    obj[key] = val.value;
+}
+function klona(x) {
+  if (typeof x !== "object")
+    return x;
+  var i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
+  if (str === "[object Object]") {
+    tmp = Object.create(x.__proto__ || null);
+  } else if (str === "[object Array]") {
+    tmp = Array(x.length);
+  } else if (str === "[object Set]") {
+    tmp = new Set;
+    x.forEach(function(val) {
+      tmp.add(klona(val));
+    });
+  } else if (str === "[object Map]") {
+    tmp = new Map;
+    x.forEach(function(val, key) {
+      tmp.set(klona(key), klona(val));
+    });
+  } else if (str === "[object Date]") {
+    tmp = new Date(+x);
+  } else if (str === "[object RegExp]") {
+    tmp = new RegExp(x.source, x.flags);
+  } else if (str === "[object DataView]") {
+    tmp = new x.constructor(klona(x.buffer));
+  } else if (str === "[object ArrayBuffer]") {
+    tmp = x.slice(0);
+  } else if (str.slice(-6) === "Array]") {
+    tmp = new x.constructor(x);
+  }
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x);i < list.length; i++) {
+      set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+    }
+    for (i = 0, list = Object.getOwnPropertyNames(x);i < list.length; i++) {
+      if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k])
+        continue;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+  return tmp || x;
+}
+
+// node_modules/@mantine/form/esm/paths/set-path.mjs
+
+function setPath(path, value, values) {
+  const splittedPath = getSplittedPath(path);
+  if (splittedPath.length === 0)
+    return values;
+  const cloned = klona(values);
+  if (splittedPath.length === 1) {
+    cloned[splittedPath[0]] = value;
+    return cloned;
+  }
+  let val = cloned[splittedPath[0]];
+  for (let i = 1;i < splittedPath.length - 1; i += 1) {
+    if (val === undefined)
+      return cloned;
+    val = val[splittedPath[i]];
+  }
+  val[splittedPath[splittedPath.length - 1]] = value;
+  return cloned;
+}
+
+// node_modules/@mantine/form/esm/paths/reorder-path.mjs
+
+function reorderPath(path, { from, to }, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue))
+    return values;
+  const cloned = [...currentValue];
+  const item = currentValue[from];
+  cloned.splice(from, 1);
+  cloned.splice(to, 0, item);
+  return setPath(path, cloned, values);
+}
+
+// node_modules/@mantine/form/esm/paths/insert-path.mjs
+
+function insertPath(path, value, index, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue))
+    return values;
+  const cloned = [...currentValue];
+  cloned.splice(typeof index === "number" ? index : cloned.length, 0, value);
+  return setPath(path, cloned, values);
+}
+
+// node_modules/@mantine/form/esm/paths/remove-path.mjs
+
+function removePath(path, index, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue))
+    return values;
+  return setPath(path, currentValue.filter((_, itemIndex) => itemIndex !== index), values);
+}
+
+// node_modules/@mantine/form/esm/paths/replace-path.mjs
+
+function replacePath(path, item, index, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue))
+    return values;
+  if (currentValue.length <= index)
+    return values;
+  const cloned = [...currentValue];
+  cloned[index] = item;
+  return setPath(path, cloned, values);
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-list/use-form-list.mjs
+import { useCallback as useCallback2 } from "react";
+
+function useFormList({ $values, $errors, $status, $watch }) {
+  return {
+    reorderListItem: useCallback2((path, payload) => {
+      const previousValues = $values.refValues.current;
+      $status.clearFieldDirty(path);
+      $errors.setErrors((errs) => reorderErrors(path, payload, errs));
+      $values.setValues({
+        values: reorderPath(path, payload, $values.refValues.current),
+        updateState: true
+      });
+      $watch.notifyWatchSubscribers(previousValues);
+    }, []),
+    removeListItem: useCallback2((path, index) => {
+      const previousValues = $values.refValues.current;
+      $status.clearFieldDirty(path);
+      $errors.setErrors((errs) => changeErrorIndices(path, index, errs, -1));
+      $values.setValues({
+        values: removePath(path, index, $values.refValues.current),
+        updateState: true
+      });
+      $watch.notifyWatchSubscribers(previousValues);
+    }, []),
+    insertListItem: useCallback2((path, item, index) => {
+      const previousValues = $values.refValues.current;
+      $status.clearFieldDirty(path);
+      $errors.setErrors((errs) => changeErrorIndices(path, index, errs, 1));
+      $values.setValues({
+        values: insertPath(path, item, index, $values.refValues.current),
+        updateState: true
+      });
+      $watch.notifyWatchSubscribers(previousValues);
+    }, []),
+    replaceListItem: useCallback2((path, index, item) => {
+      const previousValues = $values.refValues.current;
+      $status.clearFieldDirty(path);
+      $values.setValues({
+        values: replacePath(path, item, index, $values.refValues.current),
+        updateState: true
+      });
+      $watch.notifyWatchSubscribers(previousValues);
+    }, [])
+  };
+}
+
+// node_modules/@mantine/form/esm/get-status/get-status.mjs
+
+function getStatus(status, path) {
+  const paths = Object.keys(status);
+  if (typeof path === "string") {
+    const nestedPaths = paths.filter((statusPath) => statusPath.startsWith(`${path}.`));
+    return status[path] || nestedPaths.some((statusPath) => status[statusPath]) || false;
+  }
+  return paths.some((statusPath) => status[statusPath]);
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-status/use-form-status.mjs
+var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
+import { useCallback as useCallback3, useRef as useRef2, useState as useState2 } from "react";
+
+function useFormStatus({ initialDirty, initialTouched, mode, $values }) {
+  const [touchedState, setTouchedState] = useState2(initialTouched);
+  const [dirtyState, setDirtyState] = useState2(initialDirty);
+  const touchedRef = useRef2(initialTouched);
+  const dirtyRef = useRef2(initialDirty);
+  const setTouched = useCallback3((values) => {
+    const resolvedValues = typeof values === "function" ? values(touchedRef.current) : values;
+    touchedRef.current = resolvedValues;
+    if (mode === "controlled")
+      setTouchedState(resolvedValues);
+  }, []);
+  const setDirty = useCallback3((values, forceUpdate = false) => {
+    const resolvedValues = typeof values === "function" ? values(dirtyRef.current) : values;
+    dirtyRef.current = resolvedValues;
+    if (mode === "controlled" || forceUpdate)
+      setDirtyState(resolvedValues);
+  }, []);
+  const resetTouched = useCallback3(() => setTouched({}), []);
+  const resetDirty = useCallback3((values) => {
+    const newSnapshot = values ? {
+      ...$values.refValues.current,
+      ...values
+    } : $values.refValues.current;
+    $values.setValuesSnapshot(newSnapshot);
+    setDirty({});
+  }, []);
+  const setFieldTouched = useCallback3((path, touched) => {
+    setTouched((currentTouched) => {
+      if (getStatus(currentTouched, path) === touched)
+        return currentTouched;
+      return {
+        ...currentTouched,
+        [path]: touched
+      };
+    });
+  }, []);
+  const setFieldDirty = useCallback3((path, dirty, forceUpdate) => {
+    setDirty((currentDirty) => {
+      if (getStatus(currentDirty, path) === dirty)
+        return currentDirty;
+      return {
+        ...currentDirty,
+        [path]: dirty
+      };
+    }, forceUpdate);
+  }, []);
+  const setCalculatedFieldDirty = useCallback3((path, value) => {
+    const currentDirty = getStatus(dirtyRef.current, path);
+    const dirty = !import_fast_deep_equal.default(getPath(path, $values.getValuesSnapshot()), value);
+    const clearedState = clearListState(path, dirtyRef.current);
+    clearedState[path] = dirty;
+    setDirty(clearedState, currentDirty !== dirty);
+  }, []);
+  return {
+    touchedState,
+    dirtyState,
+    touchedRef,
+    dirtyRef,
+    setTouched,
+    setDirty,
+    resetDirty,
+    resetTouched,
+    isTouched: useCallback3((path) => getStatus(touchedRef.current, path), []),
+    setFieldTouched,
+    setFieldDirty,
+    setTouchedState,
+    setDirtyState,
+    clearFieldDirty: useCallback3((path) => setDirty((current) => {
+      if (typeof path !== "string")
+        return current;
+      const result = clearListState(path, current);
+      delete result[path];
+      if (import_fast_deep_equal.default(result, current))
+        return current;
+      return result;
+    }), []),
+    isDirty: useCallback3((path) => {
+      if (path) {
+        const overriddenValue = getPath(path, dirtyRef.current);
+        if (typeof overriddenValue === "boolean")
+          return overriddenValue;
+        return !import_fast_deep_equal.default(getPath(path, $values.refValues.current), getPath(path, $values.valuesSnapshot.current));
+      }
+      if (Object.keys(dirtyRef.current).length > 0)
+        return getStatus(dirtyRef.current);
+      return !import_fast_deep_equal.default($values.refValues.current, $values.valuesSnapshot.current);
+    }, []),
+    getDirty: useCallback3(() => dirtyRef.current, []),
+    getTouched: useCallback3(() => touchedRef.current, []),
+    setCalculatedFieldDirty
+  };
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-validating/use-form-validating.mjs
+import { useCallback as useCallback4, useRef as useRef3, useState as useState3 } from "react";
+
+function useFormValidating() {
+  const [validatingFields, setValidatingFields] = useState3({});
+  const [formValidating, setFormValidatingState] = useState3(false);
+  const validatingRef = useRef3({});
+  const formValidatingRef = useRef3(false);
+  const abortControllers = useRef3({});
+  const setFieldValidating = useCallback4((path, value) => {
+    validatingRef.current = {
+      ...validatingRef.current,
+      [path]: value
+    };
+    setValidatingFields({ ...validatingRef.current });
+  }, []);
+  const setFormValidating = useCallback4((value) => {
+    formValidatingRef.current = value;
+    setFormValidatingState(value);
+  }, []);
+  const isValidating = useCallback4((path) => {
+    if (path)
+      return !!validatingRef.current[path];
+    if (formValidatingRef.current)
+      return true;
+    return Object.values(validatingRef.current).some(Boolean);
+  }, []);
+  const getAbortSignal = useCallback4((path) => {
+    abortControllers.current[path]?.abort();
+    abortControllers.current[path] = new AbortController;
+    return abortControllers.current[path].signal;
+  }, []);
+  const clearValidating = useCallback4(() => {
+    validatingRef.current = {};
+    setValidatingFields({});
+    formValidatingRef.current = false;
+    setFormValidatingState(false);
+    Object.values(abortControllers.current).forEach((c) => c.abort());
+    abortControllers.current = {};
+  }, []);
+  return {
+    validating: formValidating || Object.values(validatingFields).some(Boolean),
+    isValidating,
+    setFieldValidating,
+    setFormValidating,
+    getAbortSignal,
+    clearValidating
+  };
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-values/use-form-values.mjs
+import { useCallback as useCallback5, useRef as useRef4, useState as useState4 } from "react";
+
+function useFormValues({ initialValues, onValuesChange, mode }) {
+  const initialized = useRef4(false);
+  const [stateValues, setStateValues] = useState4(initialValues || {});
+  const refValues = useRef4(stateValues);
+  const valuesSnapshot = useRef4(stateValues);
+  const setValues = useCallback5(({ values, subscribers, updateState = true, mergeWithPreviousValues = true }) => {
+    const previousValues = refValues.current;
+    const resolvedValues = values instanceof Function ? values(refValues.current) : values;
+    const updatedValues = mergeWithPreviousValues ? {
+      ...previousValues,
+      ...resolvedValues
+    } : resolvedValues;
+    refValues.current = updatedValues;
+    if (updateState) {
+      setStateValues(updatedValues);
+      if (mode === "uncontrolled")
+        refValues.current = updatedValues;
+    }
+    onValuesChange?.(updatedValues, previousValues);
+    subscribers?.filter(Boolean).forEach((subscriber) => subscriber({
+      updatedValues,
+      previousValues
+    }));
+  }, [onValuesChange]);
+  const setFieldValue = useCallback5((payload) => {
+    const currentValue = getPath(payload.path, refValues.current);
+    const updatedValue = payload.value instanceof Function ? payload.value(currentValue) : payload.value;
+    if (currentValue !== updatedValue) {
+      const previousValues = refValues.current;
+      const updatedValues = setPath(payload.path, updatedValue, refValues.current);
+      setValues({
+        values: updatedValues,
+        updateState: payload.updateState
+      });
+      payload.subscribers?.filter(Boolean).forEach((subscriber) => subscriber({
+        path: payload.path,
+        updatedValues,
+        previousValues
+      }));
+    }
+  }, [setValues]);
+  const setValuesSnapshot = useCallback5((payload) => {
+    valuesSnapshot.current = payload;
+  }, []);
+  const initialize = useCallback5((values, onInitialize) => {
+    if (!initialized.current) {
+      initialized.current = true;
+      setValues({
+        values,
+        updateState: mode === "controlled"
+      });
+      setValuesSnapshot(values);
+      onInitialize();
+    }
+  }, [setValues]);
+  return {
+    initialized,
+    stateValues,
+    refValues,
+    valuesSnapshot,
+    setValues,
+    setFieldValue,
+    resetValues: useCallback5(() => {
+      setValues({
+        values: valuesSnapshot.current,
+        updateState: true,
+        mergeWithPreviousValues: false
+      });
+    }, [setValues]),
+    setValuesSnapshot,
+    initialize,
+    getValues: useCallback5(() => refValues.current, []),
+    getValuesSnapshot: useCallback5(() => valuesSnapshot.current, []),
+    resetField: useCallback5((path, subscribers) => {
+      const snapshotValue = getPath(path, valuesSnapshot.current);
+      if (typeof snapshotValue === "undefined")
+        return;
+      setFieldValue({
+        path,
+        value: snapshotValue,
+        updateState: mode === "controlled",
+        subscribers
+      });
+    }, [setFieldValue, mode])
+  };
+}
+
+// node_modules/@mantine/form/esm/hooks/use-form-watch/use-form-watch.mjs
+import { useCallback as useCallback6, useEffect as useEffect2, useRef as useRef5 } from "react";
+
+function useFormWatch({ $values, $status, cascadeUpdates }) {
+  const subscribers = useRef5({});
+  return {
+    subscribers,
+    watch: useCallback6((path, callback) => {
+      useEffect2(() => {
+        subscribers.current[path] = subscribers.current[path] || [];
+        subscribers.current[path].push(callback);
+        return () => {
+          subscribers.current[path] = subscribers.current[path].filter((cb) => cb !== callback);
+        };
+      }, [callback]);
+    }, []),
+    getFieldSubscribers: useCallback6((path) => {
+      const result = subscribers.current[path]?.map((callback) => (input) => callback({
+        previousValue: getPath(path, input.previousValues),
+        value: getPath(path, input.updatedValues),
+        touched: $status.isTouched(path),
+        dirty: $status.isDirty(path)
+      })) ?? [];
+      for (const subscriptionKey in subscribers.current) {
+        const isParent = String(path).startsWith(`${subscriptionKey}.`);
+        const isChild = String(subscriptionKey).startsWith(`${path}.`);
+        if (isParent || cascadeUpdates && isChild)
+          result.push(...subscribers.current[subscriptionKey].map((cb) => (input) => cb({
+            previousValue: getPath(subscriptionKey, input.previousValues),
+            value: getPath(subscriptionKey, input.updatedValues),
+            touched: $status.isTouched(subscriptionKey),
+            dirty: $status.isDirty(subscriptionKey)
+          })));
+      }
+      return result;
+    }, []),
+    notifyWatchSubscribers: useCallback6((previousValues) => {
+      Object.keys(subscribers.current).forEach((path) => {
+        if (getPath(path, $values.refValues.current) !== getPath(path, previousValues))
+          subscribers.current[path]?.forEach((cb) => cb({
+            previousValue: getPath(path, previousValues),
+            value: getPath(path, $values.refValues.current),
+            touched: $status.isTouched(path),
+            dirty: $status.isDirty(path)
+          }));
+      });
+    }, [])
+  };
+}
+
+// node_modules/@mantine/form/esm/validate/get-rule-for-path.mjs
+
+function getRuleForPath(path, rules) {
+  if (!rules)
+    return null;
+  const segments = path.split(".");
+  let current = rules;
+  for (let i = 0;i < segments.length; i++) {
+    const segment = segments[i];
+    if (/^\d+$/.test(segment))
+      continue;
+    if (current == null || typeof current !== "object")
+      return null;
+    current = current[segment];
+  }
+  if (typeof current === "function")
+    return current;
+  return null;
+}
+
+// node_modules/@mantine/form/esm/validate/validate-field-value.mjs
+
+var defaultResolveError2 = (err) => err instanceof Error ? err.message : String(err);
+function fieldResultFromErrors(path, errors) {
+  const pathInError = Object.keys(errors).find((errorKey) => path.split(".").every((pathPart, i) => pathPart === errorKey.split(".")[i]));
+  return {
+    hasError: !!pathInError,
+    error: pathInError ? errors[pathInError] : null
+  };
+}
+function validateFieldValue(path, rules, values, resolveValidationError = defaultResolveError2, signal = new AbortController().signal) {
+  if (typeof path !== "string")
+    return {
+      hasError: false,
+      error: null
+    };
+  if (typeof rules === "function") {
+    const results2 = validateValues(rules, values, resolveValidationError, signal);
+    if (results2 instanceof Promise)
+      return results2.then((r) => fieldResultFromErrors(path, r.errors));
+    return fieldResultFromErrors(path, results2.errors);
+  }
+  const rule = getRuleForPath(path, rules);
+  if (rule) {
+    const value = getPath(path, values);
+    try {
+      const result = rule(value, values, path, signal);
+      if (result instanceof Promise)
+        return result.then((error) => {
+          if (error)
+            return {
+              hasError: true,
+              error
+            };
+          return {
+            hasError: false,
+            error: null
+          };
+        }, (err) => ({
+          hasError: true,
+          error: resolveValidationError(err)
+        }));
+      if (result)
+        return {
+          hasError: true,
+          error: result
+        };
+      return {
+        hasError: false,
+        error: null
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        error: resolveValidationError(err)
+      };
+    }
+  }
+  const results = validateValues(rules, values, resolveValidationError, signal);
+  if (results instanceof Promise)
+    return results.then((r) => fieldResultFromErrors(path, r.errors));
+  return fieldResultFromErrors(path, results.errors);
+}
+
+// node_modules/@mantine/form/esm/validate/should-validate-on-change.mjs
+
+function shouldValidateOnChange(path, validateInputOnChange) {
+  if (!validateInputOnChange)
+    return false;
+  if (typeof validateInputOnChange === "boolean")
+    return validateInputOnChange;
+  if (Array.isArray(validateInputOnChange))
+    return validateInputOnChange.includes(path.replace(/[.][0-9]+/g, `.${FORM_INDEX}`));
+  return false;
+}
+
+// node_modules/@mantine/form/esm/use-form.mjs
+import { useCallback as useCallback7, useMemo, useRef as useRef6, useState as useState5 } from "react";
+
+var defaultResolveValidationError = (err) => err instanceof Error ? err.message : String(err);
+function useForm({ name, mode = "controlled", initialValues, initialErrors = {}, initialDirty = {}, initialTouched = {}, clearInputErrorOnChange = true, validateInputOnChange = false, validateInputOnBlur = false, onValuesChange, transformValues = (values) => values, enhanceGetInputProps, validate: rules, onSubmitPreventDefault = "always", touchTrigger = "change", cascadeUpdates = false, validateDebounce = 0, resolveValidationError = defaultResolveValidationError } = {}) {
+  const $errors = useFormErrors(initialErrors);
+  const $values = useFormValues({
+    initialValues,
+    onValuesChange,
+    mode
+  });
+  const $status = useFormStatus({
+    initialDirty,
+    initialTouched,
+    $values,
+    mode
+  });
+  const $watch = useFormWatch({
+    $values,
+    $status,
+    cascadeUpdates
+  });
+  const $list = useFormList({
+    $values,
+    $errors,
+    $status,
+    $watch
+  });
+  const $validating = useFormValidating();
+  const [formKey, setFormKey] = useState5(0);
+  const [fieldKeys, setFieldKeys] = useState5({});
+  const [submitting, setSubmitting] = useState5(false);
+  const validateGeneration = useRef6(0);
+  const reset = useCallback7(() => {
+    $values.resetValues();
+    $errors.clearErrors();
+    $status.resetDirty();
+    $status.resetTouched();
+    $validating.clearValidating();
+    mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
+  }, []);
+  const handleValuesChanges = useCallback7((previousValues) => {
+    clearInputErrorOnChange && $errors.clearErrors();
+    mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
+    $watch.notifyWatchSubscribers(previousValues);
+  }, [clearInputErrorOnChange]);
+  const initialize = useCallback7((values) => {
+    const previousValues = $values.refValues.current;
+    $values.initialize(values, () => mode === "uncontrolled" && setFormKey((key2) => key2 + 1));
+    handleValuesChanges(previousValues);
+  }, [handleValuesChanges]);
+  const debouncedValidateField = useMemo(() => {
+    const timers = {};
+    const handleValidation = (path) => {
+      const signal = $validating.getAbortSignal(path);
+      const result = validateFieldValue(path, rules, $values.refValues.current, resolveValidationError, signal);
+      const applyResult = (results) => {
+        if (signal.aborted)
+          return;
+        if (results.hasError)
+          $errors.setFieldError(path, results.error);
+        else
+          $errors.clearFieldError(path);
+      };
+      const cleanup = () => {
+        if (!signal.aborted)
+          $validating.setFieldValidating(path, false);
+      };
+      if (result instanceof Promise) {
+        $validating.setFieldValidating(path, true);
+        result.then(applyResult).finally(cleanup);
+      } else
+        applyResult(result);
+    };
+    return (path) => {
+      clearTimeout(timers[path]);
+      if (validateDebounce > 0)
+        timers[path] = setTimeout(() => handleValidation(path), validateDebounce);
+      else
+        handleValidation(path);
+    };
+  }, [
+    validateDebounce,
+    rules,
+    resolveValidationError
+  ]);
+  const setFieldValue = useCallback7((path, value, options) => {
+    const shouldValidate = shouldValidateOnChange(path, validateInputOnChange);
+    const resolvedValue = value instanceof Function ? value(getPath(path, $values.refValues.current)) : value;
+    $status.setCalculatedFieldDirty(path, resolvedValue);
+    touchTrigger === "change" && $status.setFieldTouched(path, true);
+    !shouldValidate && clearInputErrorOnChange && $errors.clearFieldError(path);
+    $values.setFieldValue({
+      path,
+      value,
+      updateState: mode === "controlled",
+      subscribers: [
+        ...$watch.getFieldSubscribers(path),
+        shouldValidate ? () => debouncedValidateField(String(path)) : null,
+        options?.forceUpdate !== false && mode !== "controlled" ? () => setFieldKeys((keys) => ({
+          ...keys,
+          [path]: (keys[path] || 0) + 1
+        })) : null
+      ]
+    });
+  }, [
+    onValuesChange,
+    rules,
+    debouncedValidateField
+  ]);
+  const setValues = useCallback7((values) => {
+    const previousValues = $values.refValues.current;
+    $values.setValues({
+      values,
+      updateState: mode === "controlled"
+    });
+    handleValuesChanges(previousValues);
+  }, [onValuesChange, handleValuesChanges]);
+  const validate = useCallback7(() => {
+    const generation = ++validateGeneration.current;
+    const signal = $validating.getAbortSignal("__form__");
+    const handleResult = (results) => {
+      if (generation !== validateGeneration.current)
+        return {
+          hasErrors: false,
+          errors: {}
+        };
+      $errors.setErrors(results.errors);
+      return results;
+    };
+    const cleanup = () => {
+      if (generation === validateGeneration.current)
+        $validating.setFormValidating(false);
+    };
+    const result = validateValues(rules, $values.refValues.current, resolveValidationError, signal);
+    if (result instanceof Promise) {
+      $validating.setFormValidating(true);
+      return result.then(handleResult).finally(cleanup);
+    }
+    return handleResult(result);
+  }, [rules, resolveValidationError]);
+  const validateField = useCallback7((path) => {
+    const signal = $validating.getAbortSignal(String(path));
+    const applyResult = (results) => {
+      if (signal.aborted)
+        return {
+          hasError: false,
+          error: null
+        };
+      if (results.hasError)
+        $errors.setFieldError(path, results.error);
+      else
+        $errors.clearFieldError(path);
+      return results;
+    };
+    const cleanup = () => {
+      if (!signal.aborted)
+        $validating.setFieldValidating(String(path), false);
+    };
+    const result = validateFieldValue(path, rules, $values.refValues.current, resolveValidationError, signal);
+    if (result instanceof Promise) {
+      $validating.setFieldValidating(String(path), true);
+      return result.then(applyResult).finally(cleanup);
+    }
+    return applyResult(result);
+  }, [rules, resolveValidationError]);
+  const getInputProps = (path, { type = "input", withError = true, withFocus, ...otherOptions } = {}) => {
+    const _withFocus = withFocus ?? type !== "radio";
+    const payload = {
+      onChange: getInputOnChange((value) => setFieldValue(path, value, { forceUpdate: false })),
+      "data-path": getDataPath(name, path)
+    };
+    if (withError)
+      payload.error = $errors.errorsState[path];
+    if (type === "checkbox")
+      payload[mode === "controlled" ? "checked" : "defaultChecked"] = getPath(path, $values.refValues.current);
+    else if (type === "radio") {
+      payload[mode === "controlled" ? "checked" : "defaultChecked"] = getPath(path, $values.refValues.current) === otherOptions.value;
+      payload.value = otherOptions.value;
+    } else
+      payload[mode === "controlled" ? "value" : "defaultValue"] = getPath(path, $values.refValues.current);
+    if (_withFocus) {
+      payload.onFocus = () => $status.setFieldTouched(path, true);
+      payload.onBlur = () => {
+        if (shouldValidateOnChange(path, validateInputOnBlur))
+          debouncedValidateField(String(path));
+      };
+    }
+    return Object.assign(payload, enhanceGetInputProps?.({
+      inputProps: payload,
+      field: path,
+      options: {
+        type,
+        withError,
+        withFocus: _withFocus,
+        ...otherOptions
+      },
+      form
+    }));
+  };
+  const onSubmit = (handleSubmit, handleValidationFailure) => (event) => {
+    if (onSubmitPreventDefault === "always")
+      event?.preventDefault();
+    setSubmitting(true);
+    const handleValidation = (results) => {
+      if (results.hasErrors) {
+        if (onSubmitPreventDefault === "validation-failed")
+          event?.preventDefault();
+        handleValidationFailure?.(results.errors, $values.refValues.current, event);
+        setSubmitting(false);
+      } else {
+        const submitResult = handleSubmit?.(transformValues($values.refValues.current), event);
+        if (submitResult instanceof Promise)
+          submitResult.finally(() => setSubmitting(false));
+        else
+          setSubmitting(false);
+      }
+    };
+    const result = validate();
+    if (result instanceof Promise)
+      result.then(handleValidation).catch(() => {
+        setSubmitting(false);
+      });
+    else
+      handleValidation(result);
+  };
+  const getTransformedValues = (input) => transformValues(input || $values.refValues.current);
+  const onReset = useCallback7((event) => {
+    event.preventDefault();
+    reset();
+  }, []);
+  const isValid = useCallback7((path) => {
+    const signal = new AbortController().signal;
+    if (path) {
+      const result2 = validateFieldValue(path, rules, $values.refValues.current, resolveValidationError, signal);
+      if (result2 instanceof Promise)
+        return result2.then((r) => !r.hasError);
+      return !result2.hasError;
+    }
+    const result = validateValues(rules, $values.refValues.current, resolveValidationError, signal);
+    if (result instanceof Promise)
+      return result.then((r) => !r.hasErrors);
+    return !result.hasErrors;
+  }, [rules, resolveValidationError]);
+  const key = (path) => `${formKey}-${String(path)}-${fieldKeys[String(path)] || 0}`;
+  const getInputNode = useCallback7((path) => document.querySelector(`[data-path="${getDataPath(name, path)}"]`), []);
+  const resetField = useCallback7((path) => {
+    $values.resetField(path, [mode !== "controlled" ? () => setFieldKeys((keys) => ({
+      ...keys,
+      [path]: (keys[path] || 0) + 1
+    })) : null]);
+  }, [
+    $values.resetField,
+    mode,
+    setFieldKeys
+  ]);
+  const form = {
+    watch: $watch.watch,
+    initialized: $values.initialized.current,
+    values: mode === "uncontrolled" ? $values.refValues.current : $values.stateValues,
+    getValues: $values.getValues,
+    getInitialValues: $values.getValuesSnapshot,
+    setInitialValues: $values.setValuesSnapshot,
+    resetField,
+    initialize,
+    setValues,
+    setFieldValue,
+    submitting,
+    setSubmitting,
+    validating: $validating.validating,
+    isValidating: $validating.isValidating,
+    errors: $errors.errorsState,
+    setErrors: $errors.setErrors,
+    setFieldError: $errors.setFieldError,
+    clearFieldError: $errors.clearFieldError,
+    clearErrors: $errors.clearErrors,
+    resetDirty: $status.resetDirty,
+    setTouched: $status.setTouched,
+    setDirty: $status.setDirty,
+    isTouched: $status.isTouched,
+    resetTouched: $status.resetTouched,
+    isDirty: $status.isDirty,
+    getTouched: $status.getTouched,
+    getDirty: $status.getDirty,
+    reorderListItem: $list.reorderListItem,
+    insertListItem: $list.insertListItem,
+    removeListItem: $list.removeListItem,
+    replaceListItem: $list.replaceListItem,
+    reset,
+    validate,
+    validateField,
+    getInputProps,
+    onSubmit,
+    onReset,
+    isValid,
+    getTransformedValues,
+    key,
+    getInputNode
+  };
+  useFormActions(name, form);
+  return form;
+}
+
+// node_modules/@mantine/form/esm/FormProvider/FormProvider.mjs
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+
+function createFormContext() {
+  const FormContext = createContext(null);
+  function FormProvider({ form, children }) {
+    return /* @__PURE__ */ jsx(FormContext, {
+      value: form,
+      children
+    });
+  }
+  function useFormContext() {
+    const ctx = use(FormContext);
+    if (!ctx)
+      throw new Error("useFormContext was called outside of FormProvider context");
+    return ctx;
+  }
+  return [
+    FormProvider,
+    useFormContext,
+    useForm
+  ];
+}
+
+// node_modules/@mantine/form/esm/validators/is-not-empty/is-not-empty.mjs
+
+function isNotEmpty(error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value === "string")
+      return value.trim().length > 0 ? null : _error;
+    if (Array.isArray(value))
+      return value.length > 0 ? null : _error;
+    if (value === null || value === undefined)
+      return _error;
+    if (value === false)
+      return _error;
+    return null;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/matches/matches.mjs
+
+function matches(regexp, error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value !== "string")
+      return _error;
+    return regexp.test(value) ? null : _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-email/is-email.mjs
+
+function isEmail(error) {
+  return matches(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/, error);
+}
+
+// node_modules/@mantine/form/esm/validators/has-length/has-length.mjs
+
+function isLengthValid(payload, value) {
+  if (typeof payload === "number")
+    return value.length === payload;
+  const { max, min } = payload;
+  let valid = true;
+  if (typeof max === "number" && value.length > max)
+    valid = false;
+  if (typeof min === "number" && value.length < min)
+    valid = false;
+  return valid;
+}
+function hasLength(payload, error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value === "string")
+      return isLengthValid(payload, value.trim()) ? null : _error;
+    if (typeof value === "object" && value !== null && "length" in value)
+      return isLengthValid(payload, value) ? null : _error;
+    return _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-in-range/is-in-range.mjs
+
+function isInRange({ min, max }, error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value !== "number")
+      return _error;
+    let valid = true;
+    if (typeof min === "number" && value < min)
+      valid = false;
+    if (typeof max === "number" && value > max)
+      valid = false;
+    return valid ? null : _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/matches-field/matches-field.mjs
+
+function matchesField(field, error) {
+  const _error = error || true;
+  return (value, values) => {
+    if (!values || !(field in values))
+      return _error;
+    return value === values[field] ? null : _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-not-empty-html/is-not-empty-html.mjs
+
+function removeHtmlTags(input) {
+  return input.replace(/<\/?[^>]+(>|$)/g, "");
+}
+function isNotEmptyHTML(error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value === "string")
+      return removeHtmlTags(value).trim().length > 0 ? null : _error;
+    return _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-json-string/is-json-string.mjs
+
+function isJSONString(error) {
+  const _error = error || true;
+  return (value) => {
+    if (typeof value === "string")
+      try {
+        JSON.parse(value);
+        return null;
+      } catch (e) {
+        return _error;
+      }
+    return _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-url/is-url.mjs
+
+function isUrl(optionsOrError, error) {
+  let _options = {};
+  let _error;
+  if (optionsOrError !== null && optionsOrError !== undefined && typeof optionsOrError === "object" && !Array.isArray(optionsOrError) && (("protocols" in optionsOrError) || ("allowLocalhost" in optionsOrError))) {
+    _options = optionsOrError;
+    _error = error || true;
+  } else
+    _error = optionsOrError || true;
+  const protocols = _options.protocols ?? ["http", "https"];
+  const allowLocalhost = _options.allowLocalhost ?? false;
+  return (value) => {
+    if (typeof value !== "string")
+      return _error;
+    try {
+      const url = new URL(value);
+      const protocol = url.protocol.replace(":", "");
+      if (!protocols.includes(protocol))
+        return _error;
+      if (!allowLocalhost && url.hostname === "localhost")
+        return _error;
+      return null;
+    } catch {
+      return _error;
+    }
+  };
+}
+
+// node_modules/@mantine/form/esm/validators/is-one-of/is-one-of.mjs
+
+function isOneOf(values, error) {
+  const _error = error || true;
+  return (value) => {
+    return values.includes(value) ? null : _error;
+  };
+}
+
+// node_modules/@mantine/form/esm/use-field.mjs
+import { useCallback as useCallback8, useMemo as useMemo2, useRef as useRef7, useState as useState6 } from "react";
+
+function useField({ mode = "controlled", clearErrorOnChange = true, initialValue, initialError = null, initialTouched = false, onValueChange, validateOnChange = false, validateOnBlur = false, validate, resolveValidationError, type = "input" }) {
+  const [valueState, setValueState] = useState6(initialValue);
+  const valueRef = useRef7(valueState);
+  const [key, setKey] = useState6(0);
+  const [error, setError] = useState6(initialError || null);
+  const touchedRef = useRef7(initialTouched || false);
+  const [, setTouchedState] = useState6(touchedRef.current);
+  const [isValidating, setIsValidating] = useState6(false);
+  const errorResolver = useMemo2(() => resolveValidationError || ((err) => err), [resolveValidationError]);
+  const setTouched = useCallback8((val, { updateState = mode === "controlled" } = {}) => {
+    touchedRef.current = val;
+    updateState && setTouchedState(val);
+  }, []);
+  const setValue = useCallback8((value, { updateKey = mode === "uncontrolled", updateState = mode === "controlled" } = {}) => {
+    if (valueRef.current === value)
+      return;
+    valueRef.current = value;
+    onValueChange?.(value);
+    if (clearErrorOnChange && error !== null)
+      setError(null);
+    if (updateState)
+      setValueState(value);
+    if (updateKey)
+      setKey((currentKey) => currentKey + 1);
+    if (validateOnChange)
+      _validate();
+  }, [
+    error,
+    clearErrorOnChange,
+    onValueChange
+  ]);
+  const reset = useCallback8(() => {
+    setValue(initialValue);
+    setError(null);
+    setTouched(false);
+  }, [initialValue]);
+  const getValue = useCallback8(() => valueRef.current, []);
+  const isTouched = useCallback8(() => touchedRef.current, []);
+  const isDirty = useCallback8(() => valueRef.current !== initialValue, [initialValue]);
+  const _validate = useCallback8(async () => {
+    const validationResult = validate?.(valueRef.current);
+    if (validationResult instanceof Promise) {
+      setIsValidating(true);
+      try {
+        const result = await validationResult;
+        setIsValidating(false);
+        setError(result);
+      } catch (err) {
+        setIsValidating(false);
+        const resolvedError = errorResolver(err);
+        setError(resolvedError);
+        return resolvedError;
+      }
+    } else {
+      setError(validationResult);
+      return validationResult;
+    }
+  }, []);
+  const getInputProps = ({ withError = true, withFocus = true, ...otherOptions } = {}) => {
+    const payload = { onChange: getInputOnChange((val) => setValue(val, { updateKey: false })) };
+    if (withError)
+      payload.error = error;
+    if (type === "checkbox")
+      payload[mode === "controlled" ? "checked" : "defaultChecked"] = valueRef.current;
+    else if (type === "radio") {
+      payload[mode === "controlled" ? "checked" : "defaultChecked"] = valueRef.current === otherOptions.value;
+      payload.value = otherOptions.value;
+    } else
+      payload[mode === "controlled" ? "value" : "defaultValue"] = valueRef.current;
+    if (withFocus) {
+      payload.onFocus = () => {
+        setTouched(true);
+      };
+      payload.onBlur = () => {
+        if (shouldValidateOnChange("", !!validateOnBlur))
+          _validate();
+      };
+    }
+    return payload;
+  };
+  return {
+    key,
+    getValue,
+    setValue,
+    reset,
+    getInputProps,
+    isValidating,
+    validate: _validate,
+    error,
+    setError,
+    isTouched,
+    isDirty,
+    resetTouched: useCallback8(() => setTouched(false), [])
+  };
+}
+
+// node_modules/@mantine/form/esm/schema-resolver.mjs
+
+function issuesToFormErrors(issues) {
+  const errors = {};
+  for (const issue of issues) {
+    const path = issue.path ? issue.path.map((segment) => typeof segment === "object" ? segment.key : segment).join(".") : "";
+    if (!errors[path])
+      errors[path] = issue.message;
+  }
+  return filterErrors(errors);
+}
+function schemaResolver(schema, _options) {
+  const sync = _options?.sync ?? false;
+  return (values) => {
+    const result = schema["~standard"].validate(values);
+    if (result instanceof Promise)
+      return result.then((resolved) => resolved.issues ? issuesToFormErrors(resolved.issues) : {});
+    const errors = result.issues ? issuesToFormErrors(result.issues) : {};
+    return sync ? errors : Promise.resolve(errors);
+  };
+}
+export {
+  useForm,
+  useField,
+  schemaResolver,
+  matchesField,
+  matches,
+  isUrl,
+  isOneOf,
+  isNotEmptyHTML,
+  isNotEmpty,
+  isJSONString,
+  isInRange,
+  isEmail,
+  hasLength,
+  formRootRule,
+  createFormContext,
+  createFormActions,
+  FORM_INDEX
+};
+
+//# debugId=EE2EA1E0683CD80964756E2164756E21