form-father 0.7.1 → 0.8.2

package/dist/index.js

@@ -0,0 +1,1791 @@
+function formatDate(dateValue, format) {
+  const date = new Date(dateValue);
+  const pad = (num) => num.toString().padStart(2, "0");
+  const day = pad(date.getDate());
+  const month = pad(date.getMonth() + 1);
+  const year = date.getFullYear().toString();
+  return format.replace("dd", day).replace("mm", month).replace("yyyy", year);
+}
+function closest($el, selector) {
+  if ($el == null) return null;
+  let parent = $el;
+  while (parent) {
+    if (parent.matches(selector)) {
+      return parent;
+    }
+    parent = parent.parentElement;
+  }
+  return null;
+}
+function blockScrollBody() {
+  window.lastBlockScrollPosition = window.pageYOffset;
+  document.body.style.top = `${-window.lastBlockScrollPosition}px`;
+  document.body.classList.add("body--block-scroll");
+}
+function unblockScrollBody() {
+  document.body.classList.remove("body--block-scroll");
+  document.body.style.top = "";
+  window.scrollTo(0, window.lastBlockScrollPosition || 0);
+}
+function isEmailValid(value) {
+  return /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/iu.test(
+    value
+  );
+}
+const HTTP_PROTOCOLS = ["http:", "https:"];
+function getNormalizedUrlString(originalUrlString) {
+  const trimmedUrl = originalUrlString.trim();
+  if (trimmedUrl.length === 0) return "";
+  if (trimmedUrl.startsWith("//")) {
+    return `https:${trimmedUrl}`;
+  }
+  return /^[a-z][a-z\d+.-]*:\/\//i.test(trimmedUrl) ? trimmedUrl : `https://${trimmedUrl}`;
+}
+function isValidIpv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    if (!/^\d{1,3}$/.test(part)) return false;
+    const num = Number(part);
+    return num >= 0 && num <= 255;
+  });
+}
+function isValidIpv6(hostname) {
+  if (!hostname.startsWith("[") || !hostname.endsWith("]")) return false;
+  const normalizedHostname = hostname.slice(1, -1);
+  return normalizedHostname.includes(":") && /^[\da-f:.]+$/i.test(normalizedHostname);
+}
+function isValidDomainLabel(label) {
+  return label.length > 0 && label.length <= 63 && /^[a-z\d-]+$/i.test(label) && !label.startsWith("-") && !label.endsWith("-");
+}
+function isValidDomainHostname(hostname) {
+  const labels = hostname.split(".");
+  return labels.length >= 2 && labels.every(isValidDomainLabel);
+}
+function isAllowedHostname(hostname) {
+  if (!hostname) return false;
+  return hostname === "localhost" || isValidIpv4(hostname) || isValidIpv6(hostname) || isValidDomainHostname(hostname);
+}
+function isUrlValid(originalUrlString) {
+  const urlString = getNormalizedUrlString(originalUrlString);
+  if (urlString.length === 0) return false;
+  try {
+    const url = new URL(urlString);
+    return HTTP_PROTOCOLS.includes(url.protocol) && isAllowedHostname(url.hostname);
+  } catch (e) {
+    return false;
+  }
+}
+function isPhoneValid(value) {
+  const numbersArray = [];
+  Array.from(value).forEach((char) => {
+    if (!!Number(char) || Number(char) === 0) numbersArray.push(char);
+  });
+  if (numbersArray.length < 11 || numbersArray.length < 12 && value[1] === "+") return false;
+  return true;
+}
+function serializeToFormData($element) {
+  const elements = $element.tagName === "FORM" ? Array.from($element.elements) : Array.from($element.querySelectorAll("input, select, textarea, button"));
+  const data = new FormData();
+  elements.forEach((element) => {
+    if (!(element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement || element instanceof HTMLButtonElement)) {
+      return;
+    }
+    if (!element.name || element.disabled || element.hasAttribute("data-no-serialize")) {
+      return;
+    }
+    if (element instanceof HTMLButtonElement) {
+      return;
+    }
+    const { name, type } = element;
+    if (type === "file") {
+      if (element.multiple) {
+        const files = element.files;
+        if (files) {
+          for (let i = 0; i < files.length; i++) {
+            data.append(`${name}[${i}]`, files[i]);
+          }
+        }
+      } else {
+        const files = element.files;
+        if (files && files[0]) data.append(name, files[0]);
+      }
+    } else {
+      let value;
+      if (type === "select-one" || type === "select-multiple") {
+        const select = element;
+        if (type === "select-multiple") {
+          const selectedOptions = Array.from(select.selectedOptions).map((option) => option.value);
+          selectedOptions.forEach((val, index) => {
+            data.append(`${name}[${index}]`, val);
+          });
+        } else {
+          value = select.value;
+          if (value) data.append(name, value);
+        }
+      } else if (type === "tel") {
+        value = element.value.split(/[\s()-]/).join("").replace(/^8/, "+7");
+      } else if (type === "checkbox" || type === "radio") {
+        if (!element.checked) return;
+        value = element.value;
+      } else if (type === "date") {
+        const format = element.getAttribute("data-date-format");
+        value = format ? formatDate(element.value, format) : element.value;
+      } else {
+        value = element.value;
+      }
+      if (value && type !== "select-one" && type !== "select-multiple") {
+        data.append(name, value);
+      }
+    }
+  });
+  return data;
+}
+function parseCommonResponseProperties(responseBody) {
+  if (Object.prototype.hasOwnProperty.call(responseBody, "redirect-url")) {
+    if (responseBody["redirect-url-delay"]) {
+      const redirectUrlDelay = Number(responseBody["redirect-url-delay"]);
+      setTimeout(() => {
+        window.location.href = responseBody["redirect-url"];
+      }, redirectUrlDelay);
+    } else {
+      window.location.href = responseBody["redirect-url"];
+    }
+  } else if (Object.prototype.hasOwnProperty.call(responseBody, "reload")) {
+    if (responseBody.reload === true) {
+      if (responseBody["reload-delay"]) {
+        const reloadDelay = Number(responseBody["reload-delay"]);
+        setTimeout(() => {
+          window.location.reload();
+        }, reloadDelay);
+      } else {
+        window.location.reload();
+      }
+    }
+  } else {
+    if (Object.prototype.hasOwnProperty.call(responseBody, "toast")) {
+      const toasts = responseBody["toast"];
+      const normalizedToasts = Array.isArray(toasts) ? toasts : [toasts];
+      normalizedToasts.forEach((toast) => {
+        window.showToast(toast);
+      });
+    } else if (Object.prototype.hasOwnProperty.call(responseBody, "error-toast")) {
+      window.showToast(responseBody["error-toast"]);
+    }
+  }
+}
+function serializeFormToJSON(form) {
+  const obj = {};
+  const formData = new FormData(form);
+  formData.forEach((value, key) => {
+    if (obj.hasOwnProperty(key)) {
+      if (!Array.isArray(obj[key])) {
+        obj[key] = [obj[key]];
+      }
+      obj[key].push(value);
+    } else {
+      obj[key] = value;
+    }
+  });
+  return obj;
+}
+
+var _a$1;
+const GLOBAL_KEY = /* @__PURE__ */ Symbol.for("FormFather.validators");
+const validators = (_a$1 = globalThis[GLOBAL_KEY]) != null ? _a$1 : globalThis[GLOBAL_KEY] = /* @__PURE__ */ new Map();
+function registerValidator(name, fn, defaultMessage, { override = false } = {}) {
+  if (validators.has(name) && !override) {
+    console.warn(`[FormFather] Validator "${name}" already exists; pass { override: true } to replace`);
+    return;
+  }
+  validators.set(name, { fn, defaultMessage });
+}
+const getValidator = (name) => validators.get(name);
+function getAllValidators() {
+  return new Map(validators);
+}
+function registerBuiltinValidator(name, fn, defaultMessage) {
+  if (!validators.has(name)) {
+    validators.set(name, { fn, defaultMessage });
+  }
+}
+registerBuiltinValidator(
+  "required",
+  (value, $input, $form) => {
+    if ($input && $input.type) {
+      if ($input.type === "checkbox") {
+        return $input.checked;
+      }
+      if ($input.type === "radio") {
+        const group = $form.querySelectorAll(`input[type="radio"][name="${$input.name}"]`);
+        return Array.from(group).some((el) => el.checked);
+      }
+    }
+    return value.trim().length > 0;
+  },
+  "\u041F\u0443\u0441\u0442\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"
+);
+registerBuiltinValidator("email", (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v), "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+registerBuiltinValidator("tel", (v) => /^\+7\d{10}$/.test(v), "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+registerBuiltinValidator("url", (v) => isUrlValid(v), "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+registerBuiltinValidator("not-numbers", (v) => !/[0-9]/.test(v), "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+
+function readFirstIssueMessage(error) {
+  var _a;
+  if (!error || typeof error !== "object") return void 0;
+  const issues = error.issues || error.errors;
+  if (Array.isArray(issues)) {
+    const firstMessage = (_a = issues.find((issue) => typeof (issue == null ? void 0 : issue.message) === "string")) == null ? void 0 : _a.message;
+    if (firstMessage) return firstMessage;
+  }
+  return typeof error.message === "string" ? error.message : void 0;
+}
+function resolveMessage(error, message) {
+  if (typeof message === "function") return message(error);
+  return message || readFirstIssueMessage(error);
+}
+function normalizeResult(result, message) {
+  if (typeof result === "object" && result !== null) return result;
+  if (result === void 0) return true;
+  return result ? true : { valid: false, message };
+}
+function createSchemaValidator(schema, options = {}) {
+  return async (value, $input, $form, params) => {
+    const mappedValue = options.mapValue ? options.mapValue(value, $input, $form, params) : value;
+    try {
+      if (typeof schema === "function") {
+        return normalizeResult(await schema(mappedValue), resolveMessage(void 0, options.message));
+      }
+      if (typeof schema.safeParse === "function") {
+        const result = await schema.safeParse(mappedValue);
+        if (result.success) return true;
+        return { valid: false, message: resolveMessage(result.error || result, options.message) };
+      }
+      if (typeof schema.parse === "function") {
+        await schema.parse(mappedValue);
+        return true;
+      }
+    } catch (error) {
+      return { valid: false, message: resolveMessage(error, options.message) };
+    }
+    return { valid: false, message: resolveMessage(void 0, options.message) };
+  };
+}
+function registerSchemaValidator(name, schema, defaultMessage, options = {}) {
+  const { override, ...adapterOptions } = options;
+  registerValidator(name, createSchemaValidator(schema, adapterOptions), defaultMessage, { override });
+}
+function registerFieldValidator(name, predicate, defaultMessage, options = {}) {
+  registerValidator(name, createFieldValidator(predicate), defaultMessage, options);
+}
+function createFieldValidator(predicate, message) {
+  return async (value, $input, $form, params) => {
+    const valid = await predicate(value, $input, $form, params);
+    return valid ? true : { valid: false, message };
+  };
+}
+function createPatternValidator(pattern, message) {
+  return createFieldValidator((value) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  }, message);
+}
+function createLengthValidator(options, message) {
+  return createFieldValidator((value) => {
+    const normalizedValue = options.trim === false ? value : value.trim();
+    if (normalizedValue.length === 0 && options.emptyIsValid === true) return true;
+    if (typeof options.min === "number" && normalizedValue.length < options.min) return false;
+    if (typeof options.max === "number" && normalizedValue.length > options.max) return false;
+    return true;
+  }, message);
+}
+
+var _a;
+const FORM_GLOBAL_KEY = /* @__PURE__ */ Symbol.for("formfather.shared");
+const __shared = (
+  // уже существует? используем его
+  (_a = globalThis[FORM_GLOBAL_KEY]) != null ? _a : (
+    // иначе создаём
+    globalThis[FORM_GLOBAL_KEY] = {
+      defaultParams: {},
+      defaultValidationSchema: void 0
+    }
+  )
+);
+const FORM_ERROR_FIELD = "_form";
+function readFormValue(values, field) {
+  return values[field];
+}
+function isEmptyFormValue(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  return value === void 0 || value === null || String(value).trim().length === 0;
+}
+async function resolveFormValidatorIssue(context, issue, fallbackField, fallbackRule) {
+  const resolvedIssue = typeof issue === "function" ? await issue(context) : issue;
+  if (typeof resolvedIssue === "string") {
+    return {
+      field: fallbackField,
+      rule: fallbackRule,
+      message: resolvedIssue
+    };
+  }
+  return {
+    field: fallbackField,
+    rule: fallbackRule,
+    ...resolvedIssue
+  };
+}
+function createFormValidator(predicate, issue) {
+  return async (context) => {
+    const valid = await predicate(context);
+    return valid ? true : resolveFormValidatorIssue(context, issue);
+  };
+}
+function sameAsField(field, otherField, message = "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u044E\u0442", rule = "same-as-field") {
+  return createFormValidator(
+    ({ values }) => readFormValue(values, field) === readFormValue(values, otherField),
+    { field, rule, message }
+  );
+}
+function requiredIf(field, condition, message = "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E", rule = "conditional-required") {
+  return createFormValidator(
+    async (context) => !await condition(context) || !isEmptyFormValue(readFormValue(context.values, field)),
+    { field, rule, message }
+  );
+}
+function dateOrder(startField, endField, message = "\u0414\u0430\u0442\u0430 \u043E\u043A\u043E\u043D\u0447\u0430\u043D\u0438\u044F \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043F\u043E\u0437\u0436\u0435 \u0434\u0430\u0442\u044B \u043D\u0430\u0447\u0430\u043B\u0430", rule = "date-order") {
+  return createFormValidator(
+    ({ values }) => {
+      const start = readFormValue(values, startField);
+      const end = readFormValue(values, endField);
+      if (isEmptyFormValue(start) || isEmptyFormValue(end)) return true;
+      return Date.parse(String(start)) <= Date.parse(String(end));
+    },
+    { field: endField, rule, message }
+  );
+}
+let loaderIdCounter = 0;
+let errorIdCounter = 0;
+const FORM_INSTANCES = /* @__PURE__ */ new WeakMap();
+const ERROR_DESCRIBEDBY_ID_ATTRIBUTE = "data-form-father-describedby-id";
+const ADDED_DESCRIBEDBY_ID_ATTRIBUTE = "data-form-father-added-describedby-id";
+const ERROR_SUMMARY_ATTRIBUTE = "data-form-father-summary";
+const INITIAL_DEFAULT_SCHEMA = {
+  tel: {
+    selector: 'input[type="tel"]',
+    rules: ["tel"]
+  },
+  email: {
+    selector: 'input[type="email"]',
+    rules: ["email"]
+  },
+  required: {
+    selector: "[required]",
+    rules: ["required"]
+  },
+  url: {
+    selector: 'input[type="url"]',
+    rules: ["url"]
+  },
+  "not-numbers": {
+    selector: 'input[data-validate="not-numbers"]',
+    rules: ["not-numbers"]
+  }
+};
+class Form {
+  /**
+   * Создать форму.
+   *
+   * @param {HTMLElement} $el - Элемент формы (тег form!).
+   * @param {Object} options - Параметры формы.
+   */
+  constructor($el, options = {}) {
+    this.$submits = [];
+    this.waitResponse = false;
+    this.inputs = null;
+    this.fieldEventHandlers = [];
+    this.liveValidationTimers = /* @__PURE__ */ new WeakMap();
+    this.fieldValidationTokens = /* @__PURE__ */ new WeakMap();
+    this.fieldValidationTokenCounter = 0;
+    this.errors = [];
+    /** Общие настройки анимаций (можно подправить под вкус) */
+    this._anim = {
+      duration: 220,
+      easing: "ease",
+      paddingTopOpened: 16,
+      iconDuration: 700
+    };
+    this.$el = $el;
+    this.options = options;
+    const defaultConfig = {
+      onSubmit: () => {
+      },
+      onResponse: () => {
+      },
+      onResponseSuccess: () => {
+      },
+      onResponseUnsuccess: () => {
+      },
+      customTypeError: null,
+      loaderColor: "#fff",
+      showLoaderButton: true,
+      scrollToFirstErroredInput: true,
+      focusFirstErroredInput: false,
+      logging: false,
+      inputSelector: ".input",
+      inputWrapperSelector: ".input-primary",
+      validateOn: "submit",
+      revalidateOn: ["input", "change"],
+      validationDebounce: 0,
+      errorContainerAttribute: "data-error-container",
+      validationStateAttribute: "data-form-father-state",
+      ariaDescribeErrors: true,
+      errorIdPrefix: "form-father-error",
+      errorSummary: false,
+      observeMutations: false
+    };
+    this.config = Object.assign({}, defaultConfig, Form.defaultParams, options);
+    if (this.$el) {
+      this.$submits = this.findSubmitElements();
+      if (this.isCorrectArguments()) {
+        this.bindSubmitHandlers();
+        this.initialization();
+        this.bindFieldValidationEvents();
+        this.setupMutationObserver();
+        FORM_INSTANCES.set(this.$el, this);
+      }
+    } else {
+      console.warn("Empty $el");
+    }
+  }
+  static get defaultParams() {
+    return __shared.defaultParams;
+  }
+  static set defaultParams(v) {
+    __shared.defaultParams = v;
+  }
+  static get defaultValidationSchema() {
+    var _a2;
+    return (_a2 = __shared.defaultValidationSchema) != null ? _a2 : __shared.defaultValidationSchema = INITIAL_DEFAULT_SCHEMA;
+  }
+  static set defaultValidationSchema(v) {
+    __shared.defaultValidationSchema = v;
+  }
+  getOptions() {
+    return this.options;
+  }
+  /**
+   * Инициализирует сразу несколько форм по CSS-селектору. Если форма уже инициализирована, её настройки обновятся.
+   *
+   * @param selector - CSS-селектор форм. По умолчанию `form[data-form-father]`.
+   * @param options - Общие параметры для найденных форм.
+   */
+  static initAll(selector = "form[data-form-father]", options = {}) {
+    if (typeof document === "undefined") return [];
+    return Array.from(document.querySelectorAll(selector)).filter(($form) => $form.tagName === "FORM").map(($form) => {
+      const existing = FORM_INSTANCES.get($form);
+      if (existing) {
+        existing.updateOptions(options);
+        return existing;
+      }
+      return new Form($form, options);
+    });
+  }
+  /** Обновляет настройки конкретного инстанса формы без пересоздания обработчиков вручную. */
+  updateOptions(options) {
+    this.options = { ...this.options, ...options };
+    this.config = { ...this.config, ...options };
+    this.refreshControls();
+    this.bindSubmitHandlers();
+    this.bindFieldValidationEvents();
+    this.setupMutationObserver();
+    return this;
+  }
+  /** Возвращает текущий список ошибок формы. */
+  getErrors() {
+    return this.errors.map((error) => ({ ...error }));
+  }
+  /** Возвращает значения формы обычным объектом. */
+  getValues() {
+    return serializeFormToJSON(this.$el);
+  }
+  normalizeValueList(value) {
+    return Array.isArray(value) ? value.map(String) : [String(value)];
+  }
+  /** Проставляет значения полей по `name` и уведомляет UI через `input`/`change` события. */
+  setValues(values) {
+    this.getAllFields().forEach(($field) => {
+      if (!$field.name || !Object.prototype.hasOwnProperty.call(values, $field.name)) return;
+      const value = values[$field.name];
+      if ($field instanceof HTMLInputElement && $field.type === "file") return;
+      if ($field instanceof HTMLInputElement && $field.type === "checkbox") {
+        if (typeof value === "boolean") {
+          $field.checked = value;
+        } else {
+          $field.checked = this.normalizeValueList(value).includes($field.value);
+        }
+      } else if ($field instanceof HTMLInputElement && $field.type === "radio") {
+        $field.checked = String(value) === $field.value;
+      } else if ($field instanceof HTMLSelectElement && $field.multiple) {
+        const valuesList = this.normalizeValueList(value);
+        Array.from($field.options).forEach((option) => {
+          option.selected = valuesList.includes(option.value);
+        });
+      } else {
+        $field.value = value == null ? "" : String(value);
+      }
+      $field.dispatchEvent(new Event("input", { bubbles: true }));
+      $field.dispatchEvent(new Event("change", { bubbles: true }));
+    });
+    return this;
+  }
+  /** Снимает все клиентские и серверные ошибки с формы, не меняя значения полей. */
+  clearErrors() {
+    this.errors = [];
+    this.getAllFields().forEach(($field) => {
+      this.hideError($field);
+      this.clearFieldValidationState($field);
+    });
+    this.hideErrorForm();
+    this.hideErrorSummary();
+    return this;
+  }
+  isErrorResponse(issue) {
+    return !!issue && typeof issue === "object" && typeof issue.name === "string" && typeof issue["error-msg"] === "string";
+  }
+  normalizeValidationIssues(issues, source) {
+    if (issues == null || issues === true) return [];
+    if (issues === false) return [{ message: "\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u0444\u043E\u0440\u043C\u044B", source }];
+    if (typeof issues === "string") return [{ message: issues, source }];
+    if (Array.isArray(issues)) {
+      return issues.flatMap((issue) => this.normalizeValidationIssues(issue, source));
+    }
+    if (this.isErrorResponse(issues)) {
+      return [
+        {
+          field: issues.name,
+          rule: source,
+          message: issues["error-msg"],
+          source
+        }
+      ];
+    }
+    if (typeof issues === "object" && "message" in issues && typeof issues.message === "string") {
+      return [{ ...issues, source: issues.source || source }];
+    }
+    if (typeof issues === "object") {
+      return Object.entries(issues).map(([field, message]) => ({
+        field,
+        rule: source,
+        message,
+        source
+      }));
+    }
+    return [];
+  }
+  applyValidationIssue(issue, source) {
+    const issueSource = issue.source || source;
+    const rule = issue.rule || issueSource;
+    const field = issue.field || FORM_ERROR_FIELD;
+    if (field === FORM_ERROR_FIELD) {
+      this.setErrorRecord(FORM_ERROR_FIELD, rule, issue.message, issueSource);
+      this.showErrorForm(issue.message);
+      return null;
+    }
+    const $field = this.findFieldByName(field);
+    if (!$field) {
+      this.setErrorRecord(field, rule, issue.message, issueSource);
+      console.warn(`\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043F\u043E\u043B\u0435 \u0441 \u0438\u043C\u0435\u043D\u0435\u043C: ${field}, \u0434\u043B\u044F \u0432\u044B\u0432\u043E\u0434\u0430 \u043E\u0448\u0438\u0431\u043A\u0438: ${issue.message}`);
+      return null;
+    }
+    this.showFieldError($field, issue.message, issueSource, rule);
+    return $field;
+  }
+  /** Показывает несколько ошибок формы или полей: из backend map/array, `ErrorResponse[]` или form validators. */
+  setErrors(issues, source = "server") {
+    this.normalizeValidationIssues(issues, source).forEach((issue) => {
+      this.applyValidationIssue(issue, source);
+    });
+    this.syncErrorSummary();
+    return this;
+  }
+  async validateFormValidators() {
+    const validators = this.config.formValidators ? Array.isArray(this.config.formValidators) ? this.config.formValidators : [this.config.formValidators] : [];
+    const erroredInputs = [];
+    let ok = true;
+    for (const validator of validators) {
+      const result = await validator({
+        form: this,
+        formElement: this.$el,
+        values: this.getValues(),
+        errors: this.getErrors()
+      });
+      const issues = this.normalizeValidationIssues(result, "client");
+      if (issues.length === 0) continue;
+      ok = false;
+      issues.forEach((issue) => {
+        const $field = this.applyValidationIssue(issue, "client");
+        if ($field) erroredInputs.push($field);
+      });
+    }
+    return { ok, erroredInputs };
+  }
+  /** Сбрасывает форму через native `reset()` и опционально очищает ошибки. */
+  reset(options = {}) {
+    this.$el.reset();
+    this.refreshControls();
+    if (options.clearErrors !== false) {
+      this.clearErrors();
+    }
+    return this;
+  }
+  /**
+   * Обновляет параметры по умолчанию для настроек формы. Метод объединяет переданные параметры с уже существующими
+   * параметрами по умолчанию.
+   *
+   * @param {Partial<FormOptions>} params - Объект, содержащий новые значения параметров. Можно передать только те
+   *   свойства, которые необходимо обновить; остальные сохранятся без изменений.
+   */
+  static setDefaultParams(params) {
+    this.defaultParams = { ...this.defaultParams, ...params };
+  }
+  refreshControls() {
+    this.inputs = this.$el.querySelectorAll(this.config.inputSelector);
+  }
+  findSubmitElements() {
+    return Array.from(
+      this.$el.querySelectorAll('input[type="submit"], input[type="image"], button[type="submit"], button:not([type])')
+    );
+  }
+  bindSubmitHandlers() {
+    if (!this._onSubmitClickHandler) {
+      this._onSubmitClickHandler = async (e) => {
+        await this.handleSubmitEvent(e);
+      };
+    }
+    this.$submits.forEach(($submit) => {
+      $submit.removeEventListener("click", this._onSubmitClickHandler);
+    });
+    this.$submits = this.findSubmitElements();
+    this.$submits.forEach(($submit) => {
+      $submit.addEventListener("click", this._onSubmitClickHandler);
+    });
+  }
+  initialization() {
+    this.refreshControls();
+    this._onSubmitHandler = async (e) => {
+      await this.handleSubmitEvent(e);
+    };
+    this.$el.addEventListener("submit", this._onSubmitHandler);
+  }
+  async handleSubmitEvent(e) {
+    var _a2, _b, _c, _d, _e, _f;
+    e.preventDefault();
+    (_b = (_a2 = this.config).onBeforeValidate) == null ? void 0 : _b.call(_a2, this);
+    const isValid = await this.validate();
+    (_d = (_c = this.config).onAfterValidate) == null ? void 0 : _d.call(_c, isValid, this);
+    if (!isValid) {
+      (_f = (_e = this.config).onValidationError) == null ? void 0 : _f.call(_e, this.getErrors(), this);
+      return {
+        success: false,
+        error: this.getErrors()
+      };
+    }
+    return this.submit();
+  }
+  normalizeTriggers(value, fallback) {
+    const triggers = value == null ? fallback : Array.isArray(value) ? value : [value];
+    return Array.from(new Set(triggers));
+  }
+  clearFieldValidationEvents() {
+    this.fieldEventHandlers.forEach(({ $input, event, handler }) => {
+      $input.removeEventListener(event, handler);
+    });
+    this.fieldEventHandlers = [];
+  }
+  bindFieldValidationEvents() {
+    this.clearFieldValidationEvents();
+    const validateOn = this.normalizeTriggers(this.config.validateOn, ["submit"]).filter(
+      (event) => event !== "submit"
+    );
+    const revalidateOn = this.normalizeTriggers(this.config.revalidateOn, ["input", "change"]).filter(
+      (event) => event !== "submit"
+    );
+    const events = Array.from(/* @__PURE__ */ new Set([...validateOn, ...revalidateOn]));
+    if (events.length === 0) return;
+    const fields = this.getAllFields();
+    fields.forEach(($input) => {
+      events.forEach((event) => {
+        const handler = () => {
+          const shouldValidate = validateOn.includes(event) || this.hasFieldError($input);
+          if (shouldValidate) this.scheduleFieldValidation($input);
+        };
+        $input.addEventListener(event, handler);
+        this.fieldEventHandlers.push({ $input, event, handler });
+      });
+    });
+  }
+  scheduleFieldValidation($input) {
+    const currentTimer = this.liveValidationTimers.get($input);
+    if (currentTimer) clearTimeout(currentTimer);
+    const delay = Math.max(0, Number(this.config.validationDebounce) || 0);
+    const run = () => {
+      void this.validateField($input);
+    };
+    if (delay === 0) {
+      run();
+      return;
+    }
+    const timer = setTimeout(run, delay);
+    this.liveValidationTimers.set($input, timer);
+  }
+  setupMutationObserver() {
+    var _a2;
+    (_a2 = this.mutationObserver) == null ? void 0 : _a2.disconnect();
+    this.mutationObserver = void 0;
+    if (!this.config.observeMutations || typeof MutationObserver === "undefined") return;
+    this.mutationObserver = new MutationObserver(() => {
+      this.refreshControls();
+      this.bindSubmitHandlers();
+      this.bindFieldValidationEvents();
+    });
+    this.mutationObserver.observe(this.$el, {
+      childList: true,
+      subtree: true
+    });
+  }
+  getErrorContainer($input) {
+    const attrName = this.config.errorContainerAttribute || "data-error-container";
+    const selector = $input.getAttribute(attrName);
+    if (!selector) return null;
+    try {
+      return document.querySelector(selector);
+    } catch (e) {
+      console.warn(`[FormFather] Invalid error container selector "${selector}"`);
+      return null;
+    }
+  }
+  toSafeIdPart(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "") || "field";
+  }
+  createErrorId($input) {
+    const prefix = this.config.errorIdPrefix || "form-father-error";
+    return `${this.toSafeIdPart(prefix)}-${this.toSafeIdPart(this.getFieldKey($input))}-${++errorIdCounter}`;
+  }
+  ensureElementId($input, $error) {
+    if (!$error.id) {
+      $error.id = $input.getAttribute(ERROR_DESCRIBEDBY_ID_ATTRIBUTE) || this.createErrorId($input);
+    }
+    return $error.id;
+  }
+  addErrorDescription($input, $error) {
+    if (!$error.hasAttribute("role")) $error.setAttribute("role", "alert");
+    const errorId = this.ensureElementId($input, $error);
+    $input.setAttribute(ERROR_DESCRIBEDBY_ID_ATTRIBUTE, errorId);
+    if (this.config.ariaDescribeErrors === false) return;
+    const currentIds = ($input.getAttribute("aria-describedby") || "").split(/\s+/).filter(Boolean);
+    if (!currentIds.includes(errorId)) {
+      $input.setAttribute("aria-describedby", [...currentIds, errorId].join(" "));
+      $input.setAttribute(ADDED_DESCRIBEDBY_ID_ATTRIBUTE, errorId);
+    }
+  }
+  removeErrorDescription($input) {
+    const addedId = $input.getAttribute(ADDED_DESCRIBEDBY_ID_ATTRIBUTE);
+    if (addedId) {
+      const nextIds = ($input.getAttribute("aria-describedby") || "").split(/\s+/).filter((id) => id && id !== addedId);
+      if (nextIds.length > 0) {
+        $input.setAttribute("aria-describedby", nextIds.join(" "));
+      } else {
+        $input.removeAttribute("aria-describedby");
+      }
+    }
+    $input.removeAttribute(ERROR_DESCRIBEDBY_ID_ATTRIBUTE);
+    $input.removeAttribute(ADDED_DESCRIBEDBY_ID_ATTRIBUTE);
+  }
+  /**
+   * Показывает ошибку для поля ввода.
+   *
+   * @param {HTMLInputElement} $input - Поле ввода.
+   * @param {String} text - Текст ошибки.
+   */
+  showError($input, text) {
+    $input.setAttribute("aria-invalid", "true");
+    const $errorContainer = this.getErrorContainer($input);
+    if ($errorContainer) {
+      $errorContainer.textContent = text;
+      this.addErrorDescription($input, $errorContainer);
+      $errorContainer.removeAttribute("hidden");
+      return;
+    }
+    const $inputWrapper = closest($input, this.config.inputWrapperSelector);
+    if (!$inputWrapper) {
+      console.warn(`\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430 \u043E\u0431\u0451\u0440\u0442\u043A\u0430 \u0434\u043B\u044F \u043F\u043E\u043B\u044F \u0441 \u0438\u043C\u0435\u043D\u0435\u043C: ${$input.name || $input.type}`);
+      return;
+    }
+    const customShowError = $inputWrapper.showError;
+    if (typeof customShowError === "function") {
+      customShowError.call($inputWrapper, text);
+      const $customError = $inputWrapper.querySelector("[data-form-father-error]");
+      if ($customError) this.addErrorDescription($input, $customError);
+      return;
+    }
+    $inputWrapper.classList.add("input__wrapper--error");
+    let $error = $inputWrapper.querySelector("[data-form-father-error]");
+    if (!$error) {
+      $error = document.createElement("div");
+      $error.setAttribute("data-form-father-error", "");
+      $error.setAttribute("role", "alert");
+      $input.insertAdjacentElement("afterend", $error);
+    }
+    $error.textContent = text;
+    this.addErrorDescription($input, $error);
+  }
+  /** Показывает лоадер */
+  showLoader() {
+    this.$submits.forEach(($submit) => {
+      $submit.classList.add("button--loading");
+      if ($submit.querySelector(".button__loader")) return;
+      const gradientId = `form-father-loader-${loaderIdCounter++}`;
+      const loaderSvg = `
+				<svg height="38" viewBox="0 0 38 38" width="38" xmlns="http://www.w3.org/2000/svg">
+					<defs>
+					<linearGradient id="${gradientId}" x1="8.042%" x2="65.682%" y1="0%" y2="23.865%">
+						<stop offset="0%" stop-color="${this.config.loaderColor}" stop-opacity="0"/>
+						<stop offset="63.146%" stop-color="${this.config.loaderColor}" stop-opacity=".631"/>
+						<stop offset="100%" stop-color="${this.config.loaderColor}"/>
+					</linearGradient>
+					</defs>
+					<g fill-rule="evenodd" fill="none">
+					<g transform="translate(1 1)">
+						<path d="M36 18c0-9.94-8.06-18-18-18" id="Oval-2" stroke-width="5" stroke="url(#${gradientId})"></path>
+						<circle cx="36" cy="18" fill="${this.config.loaderColor}" r="1"></circle>
+					</g>
+					</g>
+				</svg>
+			`;
+      const $loaderEl = document.createElement("span");
+      $loaderEl.innerHTML = loaderSvg;
+      $loaderEl.className = "button__loader";
+      $submit.insertAdjacentElement("afterbegin", $loaderEl);
+      requestAnimationFrame(() => {
+        $loaderEl.setAttribute("data-showed", "");
+      });
+    });
+  }
+  /** Скрывает лоадер */
+  hideLoader() {
+    this.$submits.forEach(($submit) => {
+      $submit.classList.remove("button--loading");
+      const $loader = $submit.querySelector(".button__loader");
+      if ($loader) {
+        $loader.classList.remove("active");
+        $loader.removeAttribute("data-showed");
+        setTimeout(() => {
+          $loader.remove();
+        }, 250);
+      }
+    });
+  }
+  /**
+   * Скрывает ошибку.
+   *
+   * @param {HTMLInputElement} $input - Поле ввода.
+   */
+  hideError($input) {
+    var _a2;
+    const $inputWrapper = closest($input, this.config.inputWrapperSelector) || $input.parentElement;
+    const $errorContainer = this.getErrorContainer($input);
+    $input.removeAttribute("aria-invalid");
+    this.removeErrorDescription($input);
+    if ($errorContainer) {
+      $errorContainer.textContent = "";
+      $errorContainer.setAttribute("hidden", "");
+    }
+    (_a2 = $inputWrapper == null ? void 0 : $inputWrapper.querySelector("[data-form-father-error]")) == null ? void 0 : _a2.remove();
+    $inputWrapper == null ? void 0 : $inputWrapper.classList.remove("input__wrapper--error");
+    if ($inputWrapper && $inputWrapper.classList.contains("input__wrapper")) {
+      $inputWrapper.getAttribute("data-type-error") || "default";
+    }
+  }
+  getErrorSummaryOptions() {
+    if (!this.config.errorSummary) return null;
+    return this.config.errorSummary === true ? {} : this.config.errorSummary;
+  }
+  getErrorSummaryContainer(options, create) {
+    if (options.selector) {
+      try {
+        return this.$el.querySelector(options.selector) || document.querySelector(options.selector);
+      } catch (e) {
+        console.warn(`[FormFather] Invalid error summary selector "${options.selector}"`);
+        return null;
+      }
+    }
+    const existing = this.$el.querySelector(`[${ERROR_SUMMARY_ATTRIBUTE}]`);
+    if (existing || !create) return existing;
+    const $summary = document.createElement("div");
+    $summary.setAttribute(ERROR_SUMMARY_ATTRIBUTE, "");
+    this.$el.insertAdjacentElement("afterbegin", $summary);
+    return $summary;
+  }
+  prepareErrorSummaryContainer($summary) {
+    $summary.setAttribute(ERROR_SUMMARY_ATTRIBUTE, "");
+    if (!$summary.hasAttribute("role")) $summary.setAttribute("role", "alert");
+    if (!$summary.hasAttribute("tabindex")) $summary.setAttribute("tabindex", "-1");
+    $summary.removeAttribute("hidden");
+  }
+  focusErrorSummary($summary) {
+    try {
+      $summary.focus({ preventScroll: true });
+    } catch (e) {
+      $summary.focus();
+    }
+  }
+  focusFieldFromSummary($field) {
+    if (typeof $field.scrollIntoView === "function") {
+      $field.scrollIntoView({ behavior: "smooth", block: "center" });
+    }
+    try {
+      $field.focus({ preventScroll: true });
+    } catch (e) {
+      $field.focus();
+    }
+  }
+  renderDefaultErrorSummary($summary, errors, options) {
+    $summary.textContent = "";
+    const $title = document.createElement("p");
+    $title.setAttribute("data-form-father-summary-title", "");
+    $title.textContent = options.title || "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u043F\u043E\u043B\u044F \u0444\u043E\u0440\u043C\u044B";
+    const $list = document.createElement("ul");
+    $list.setAttribute("data-form-father-summary-list", "");
+    errors.forEach((error) => {
+      const $item = document.createElement("li");
+      const $field = error.field === FORM_ERROR_FIELD ? null : this.findFieldByName(error.field);
+      if ($field) {
+        const $button = document.createElement("button");
+        $button.type = "button";
+        $button.setAttribute("data-form-father-summary-field", error.field);
+        $button.textContent = error.message;
+        $button.addEventListener("click", () => this.focusFieldFromSummary($field));
+        $item.appendChild($button);
+      } else {
+        const $message = document.createElement("span");
+        $message.textContent = error.message;
+        $item.appendChild($message);
+      }
+      $list.appendChild($item);
+    });
+    $summary.append($title, $list);
+  }
+  renderErrorSummary(errors = this.getErrors()) {
+    var _a2;
+    const options = this.getErrorSummaryOptions();
+    if (!options) return;
+    if (errors.length === 0) {
+      this.hideErrorSummary();
+      return;
+    }
+    const $summary = this.getErrorSummaryContainer(options, true);
+    if (!$summary) return;
+    this.prepareErrorSummaryContainer($summary);
+    const rendered = (_a2 = options.render) == null ? void 0 : _a2.call(options, errors.map((error) => ({ ...error })), this);
+    if (rendered instanceof HTMLElement) {
+      $summary.replaceChildren(rendered);
+    } else if (typeof rendered === "string") {
+      $summary.innerHTML = rendered;
+    } else if (!options.render) {
+      this.renderDefaultErrorSummary($summary, errors, options);
+    }
+    if (options.focus) this.focusErrorSummary($summary);
+  }
+  hideErrorSummary() {
+    const options = this.getErrorSummaryOptions() || {};
+    const $summary = this.getErrorSummaryContainer(options, false);
+    if (!$summary) return;
+    $summary.replaceChildren();
+    $summary.setAttribute("hidden", "");
+  }
+  syncErrorSummary() {
+    if (this.errors.length === 0) {
+      this.hideErrorSummary();
+      return;
+    }
+    this.renderErrorSummary();
+  }
+  /**
+   * Проскроливает до первого ошибочного поля.
+   *
+   * @param {HTMLElement[]} inputsList - Массив элементов с ошибкой.
+   */
+  scrollToFirstErroredInput(inputsList) {
+    if (inputsList.length > 0) {
+      const allInputInFormList = Array.from(this.$el.querySelectorAll("input, textarea, select"));
+      let $firstInputOnForm = null;
+      let minIndex = Infinity;
+      inputsList.forEach(($input) => {
+        const findIndex = allInputInFormList.findIndex(($item) => $item === $input);
+        if (findIndex < minIndex) {
+          minIndex = findIndex;
+          $firstInputOnForm = $input;
+        }
+      });
+      if ($firstInputOnForm) {
+        const rect = $firstInputOnForm.getBoundingClientRect();
+        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+        const scrollTargetY = rect.top + scrollTop - window.innerHeight / 2;
+        document.documentElement.setAttribute("data-now-scrolling", "");
+        window.scrollTo({
+          top: scrollTargetY,
+          behavior: "smooth"
+        });
+        setTimeout(() => {
+          document.documentElement.removeAttribute("data-now-scrolling");
+        }, 800);
+      }
+    }
+  }
+  focusFirstErroredInput(inputsList) {
+    var _a2;
+    if (inputsList.length === 0) return;
+    const allInputInFormList = Array.from(this.$el.querySelectorAll("input, textarea, select"));
+    const $firstInputOnForm = inputsList.slice().sort((a, b) => allInputInFormList.indexOf(a) - allInputInFormList.indexOf(b))[0];
+    (_a2 = $firstInputOnForm == null ? void 0 : $firstInputOnForm.focus) == null ? void 0 : _a2.call($firstInputOnForm, { preventScroll: true });
+  }
+  getValidationSchema() {
+    return {
+      ...Form.defaultValidationSchema || {},
+      ...this.config.validationSchema || {}
+    };
+  }
+  getAllFields($block = this.$el) {
+    return Array.from($block.querySelectorAll("input, textarea, select"));
+  }
+  getFieldKey($input) {
+    return $input.name || $input.id || $input.getAttribute("data-field") || $input.type || "field";
+  }
+  hasFieldError($input) {
+    const field = this.getFieldKey($input);
+    return $input.getAttribute("aria-invalid") === "true" || this.errors.some((error) => error.field === field);
+  }
+  clearFieldErrorRecord($input) {
+    const field = this.getFieldKey($input);
+    this.errors = this.errors.filter((error) => error.field !== field);
+  }
+  setErrorRecord(field, rule, message, source) {
+    this.errors.push({
+      field,
+      rule,
+      message,
+      source
+    });
+  }
+  getValidationStateAttribute() {
+    return this.config.validationStateAttribute || "data-form-father-state";
+  }
+  setFieldValidationState($input, state) {
+    const attr = this.getValidationStateAttribute();
+    if (state) {
+      $input.setAttribute(attr, state);
+    } else {
+      $input.removeAttribute(attr);
+    }
+  }
+  startFieldValidation($input) {
+    const token = ++this.fieldValidationTokenCounter;
+    this.fieldValidationTokens.set($input, token);
+    $input.setAttribute("aria-busy", "true");
+    this.setFieldValidationState($input, "validating");
+    return token;
+  }
+  isLatestFieldValidation($input, token) {
+    return token == null || this.fieldValidationTokens.get($input) === token;
+  }
+  finishFieldValidation($input, token, isValid) {
+    if (!this.isLatestFieldValidation($input, token)) return;
+    $input.removeAttribute("aria-busy");
+    this.setFieldValidationState($input, isValid ? "valid" : "invalid");
+  }
+  clearFieldValidationState($input) {
+    this.fieldValidationTokens.delete($input);
+    $input.removeAttribute("aria-busy");
+    this.setFieldValidationState($input, null);
+  }
+  setValidationError($input, rule, message, source) {
+    this.clearFieldErrorRecord($input);
+    this.setErrorRecord(this.getFieldKey($input), rule, message, source);
+  }
+  resolveField(field) {
+    if (typeof field !== "string") return field;
+    return this.findFieldByName(field);
+  }
+  parseRuleString(ruleString) {
+    const [rule, ...params] = ruleString.split(":").map((s) => s.trim());
+    return params.length > 0 ? { rule, params: params.length === 1 ? params[0] : params } : rule;
+  }
+  parseValidationAttribute(value) {
+    return (value != null ? value : "").split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean).map((ruleString) => this.parseRuleString(ruleString));
+  }
+  getRuleName(rule) {
+    return typeof rule === "string" ? rule : rule.rule;
+  }
+  getRuleIdentity(rule) {
+    return JSON.stringify(rule);
+  }
+  collectRules($input, fromSchema = [], schemaKeys = /* @__PURE__ */ new Set()) {
+    const list = [];
+    if ($input.hasAttribute("required")) list.push("required");
+    list.push(...fromSchema);
+    const dataValidateRules = this.parseValidationAttribute($input.getAttribute("data-validate")).filter((rule) => {
+      const ruleName = this.getRuleName(rule);
+      return getValidator(ruleName) || !schemaKeys.has(ruleName);
+    });
+    list.push(...dataValidateRules);
+    list.push(...this.parseValidationAttribute($input.getAttribute("data-custom-validate")));
+    const filtered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const rule of list) {
+      const ruleName = this.getRuleName(rule);
+      if (!getValidator(ruleName)) {
+        console.warn(`[FormFather] Unknown validation rule "${ruleName}"`);
+        continue;
+      }
+      const identity = this.getRuleIdentity(rule);
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      filtered.push(rule);
+    }
+    return filtered;
+  }
+  getRuleMessage($input, rule, messages, defaultMessage, overrideMessage) {
+    const attrMessage = $input.getAttribute(`data-error-${rule}`);
+    return overrideMessage || attrMessage || messages[rule] || defaultMessage;
+  }
+  fieldMatchesSchemaDefinition($input, key, def) {
+    if (def.selector) {
+      try {
+        return $input.matches(def.selector);
+      } catch (e) {
+        console.warn(`[FormFather] Invalid validation selector "${def.selector}"`);
+        return false;
+      }
+    }
+    return this.parseValidationAttribute($input.getAttribute("data-validate")).some((rule) => this.getRuleName(rule) === key);
+  }
+  getFieldValidationConfig($input, schema = this.getValidationSchema()) {
+    const rules = [];
+    const messages = {};
+    for (const [key, def] of Object.entries(schema)) {
+      if (!this.fieldMatchesSchemaDefinition($input, key, def)) continue;
+      rules.push(...def.rules);
+      Object.assign(messages, def.messages || {});
+    }
+    return {
+      rules: this.collectRules($input, rules, new Set(Object.keys(schema))),
+      messages
+    };
+  }
+  getValidationFields($block, schema) {
+    const fields = /* @__PURE__ */ new Set();
+    const addFields = (nodeList) => {
+      Array.from(nodeList).forEach(($input) => {
+        if ($input instanceof HTMLInputElement || $input instanceof HTMLTextAreaElement || $input instanceof HTMLSelectElement) {
+          fields.add($input);
+        }
+      });
+    };
+    for (const [key, def] of Object.entries(schema)) {
+      if (def.selector) {
+        try {
+          addFields($block.querySelectorAll(def.selector));
+        } catch (e) {
+          console.warn(`[FormFather] Invalid validation selector "${def.selector}"`);
+        }
+        continue;
+      }
+      this.getAllFields($block).filter(
+        ($input) => this.parseValidationAttribute($input.getAttribute("data-validate")).some((rule) => this.getRuleName(rule) === key)
+      ).forEach(($input) => fields.add($input));
+    }
+    addFields($block.querySelectorAll("[required], [data-validate], [data-custom-validate]"));
+    return Array.from(fields);
+  }
+  async validateInput($input, rules, messages = {}, $block = this.$el, validationToken) {
+    if ($input.hasAttribute("data-no-validate")) return true;
+    const isCheckable = $input instanceof HTMLInputElement && ($input.type === "checkbox" || $input.type === "radio");
+    const empty = isCheckable ? !$input.checked : $input.value.trim().length === 0;
+    const hasRequiredRule = rules.some((rule) => this.getRuleName(rule) === "required");
+    if (empty && !hasRequiredRule) {
+      if (!this.isLatestFieldValidation($input, validationToken)) return !this.hasFieldError($input);
+      this.clearFieldErrorRecord($input);
+      this.hideError($input);
+      return true;
+    }
+    for (const validationRule of rules) {
+      const { rule, params } = typeof validationRule === "string" ? { rule: validationRule, params: void 0 } : { rule: validationRule.rule, params: validationRule.params };
+      const validator = getValidator(rule);
+      if (!validator) continue;
+      const raw = await validator.fn($input.value, $input, $block, params);
+      const isObjectResult = typeof raw === "object" && raw !== null;
+      const passed = isObjectResult ? raw.valid === true : !!raw;
+      if (!this.isLatestFieldValidation($input, validationToken)) return !this.hasFieldError($input);
+      if (isObjectResult && raw.effect) {
+        await raw.effect({
+          value: $input.value,
+          $input,
+          $form: $block,
+          params
+        });
+      }
+      if (!this.isLatestFieldValidation($input, validationToken)) return !this.hasFieldError($input);
+      if (!passed) {
+        const result = raw;
+        const message = this.getRuleMessage(
+          $input,
+          rule,
+          messages,
+          validator.defaultMessage,
+          isObjectResult && typeof result.message === "string" ? result.message : void 0
+        );
+        this.setValidationError($input, rule, message, "client");
+        this.showError($input, message);
+        return false;
+      }
+      if (isObjectResult && raw.stopOthers) {
+        return true;
+      }
+    }
+    if (!this.isLatestFieldValidation($input, validationToken)) return !this.hasFieldError($input);
+    this.clearFieldErrorRecord($input);
+    this.hideError($input);
+    return true;
+  }
+  async runFieldValidation($input, rules, messages = {}, $block = this.$el) {
+    const validationToken = this.startFieldValidation($input);
+    try {
+      const isValid = await this.validateInput($input, rules, messages, $block, validationToken);
+      this.finishFieldValidation($input, validationToken, isValid);
+      return isValid;
+    } catch (error) {
+      if (this.isLatestFieldValidation($input, validationToken)) {
+        this.clearFieldValidationState($input);
+      }
+      throw error;
+    }
+  }
+  getRadioGroup($input, $block) {
+    if (!($input instanceof HTMLInputElement) || $input.type !== "radio" || !$input.name) return [];
+    return Array.from($block.querySelectorAll('input[type="radio"]')).filter(
+      ($radio) => $radio.name === $input.name
+    );
+  }
+  /** Показывает ошибку конкретного поля по имени или DOM-элементу. */
+  showFieldError(field, message, source = "manual", rule = source) {
+    const $field = this.resolveField(field);
+    if (!$field) {
+      console.warn(`[FormFather] Field "${String(field)}" not found`);
+      return false;
+    }
+    this.setValidationError($field, rule, message, source);
+    this.showError($field, message);
+    $field.removeAttribute("aria-busy");
+    this.setFieldValidationState($field, "invalid");
+    this.syncErrorSummary();
+    return true;
+  }
+  /** Проверяет одно поле по имени или DOM-элементу. */
+  async validateField(field) {
+    const $field = this.resolveField(field);
+    if (!$field) {
+      console.warn(`[FormFather] Field "${String(field)}" not found`);
+      return false;
+    }
+    const { rules, messages } = this.getFieldValidationConfig($field);
+    const isValid = await this.runFieldValidation($field, rules, messages);
+    this.syncErrorSummary();
+    return isValid;
+  }
+  /**
+   * Проверяет все поля ввода.
+   *
+   * Порядок для каждого поля:
+   *
+   * 1. `required` — если атрибут `required`
+   * 2. правила из `validationSchema`
+   * 3. правила из `data-validate`
+   * 4. правила из `data-custom-validate`
+   *
+   * Для одного поля показывается только первая ошибка. Неизвестные правила фиксируются `console.warn` и исключаются ДО
+   * валидации.
+   */
+  async validate($block = this.$el) {
+    const schema = this.getValidationSchema();
+    const erroredInputs = [];
+    const processed = /* @__PURE__ */ new WeakSet();
+    let ok = true;
+    this.errors = [];
+    for (const $input of this.getValidationFields($block, schema)) {
+      if (processed.has($input)) continue;
+      const radioGroup = this.getRadioGroup($input, $block);
+      if (radioGroup.length > 0) {
+        radioGroup.forEach(($radio) => processed.add($radio));
+      } else {
+        processed.add($input);
+      }
+      const { rules, messages } = this.getFieldValidationConfig($input, schema);
+      const fieldValid = await this.runFieldValidation($input, rules, messages, $block);
+      if (!fieldValid) {
+        ok = false;
+        erroredInputs.push($input);
+      }
+    }
+    const formValidation = await this.validateFormValidators();
+    if (!formValidation.ok) {
+      ok = false;
+      erroredInputs.push(...formValidation.erroredInputs);
+    }
+    const visibleErroredInputs = erroredInputs.filter((item) => !item.hasAttribute("data-no-error-scroll"));
+    if (!ok && this.config.scrollToFirstErroredInput) {
+      this.scrollToFirstErroredInput(visibleErroredInputs);
+    }
+    if (!ok && this.config.focusFirstErroredInput) {
+      this.focusFirstErroredInput(visibleErroredInputs);
+    }
+    if (ok) {
+      this.hideErrorSummary();
+    } else {
+      this.renderErrorSummary();
+    }
+    return ok;
+  }
+  /** Блокирует кнопку отправки данных. */
+  disableSubmit() {
+    this.$submits.forEach(($submit) => {
+      $submit.setAttribute("disabled", "");
+    });
+  }
+  /** Снимает блокировку с кнопки отправки данных. */
+  enableSubmit() {
+    this.$submits.forEach(($submit) => {
+      $submit.removeAttribute("disabled");
+    });
+  }
+  /** Очищает поля ввода формы. */
+  clearInputs() {
+    var _a2;
+    (_a2 = this.inputs) == null ? void 0 : _a2.forEach(($inputEl) => {
+      var _a3;
+      const $input = $inputEl;
+      if ($input.type === "radio" || $input.type === "checkbox") {
+        $input.checked = false;
+      } else {
+        $input.value = "";
+        (_a3 = $input.parentElement) == null ? void 0 : _a3.classList.remove("filled");
+        $input.dispatchEvent(new Event("input"));
+      }
+    });
+  }
+  _prefersReducedMotion() {
+    var _a2;
+    return typeof window !== "undefined" && ((_a2 = window.matchMedia) == null ? void 0 : _a2.call(window, "(prefers-reduced-motion: reduce)").matches);
+  }
+  _canAnimate(el) {
+    return !!(el && "animate" in el && !this._prefersReducedMotion());
+  }
+  _cancelAnimations(el) {
+    var _a2;
+    const animatedEl = el;
+    (_a2 = animatedEl == null ? void 0 : animatedEl.getAnimations) == null ? void 0 : _a2.call(animatedEl).forEach((animation) => animation.cancel());
+  }
+  /**
+   * Показывает ошибку под полями ввода - ошибку, относящуюся ко всей форме.
+   *
+   * @param {String} text - Текст ошибки.
+   */
+  showErrorForm(text) {
+    var _a2;
+    const inputWrappersList = this.$el.querySelectorAll(this.config.inputWrapperSelector);
+    const $lastInputWrapper = inputWrappersList[inputWrappersList.length - 1];
+    let $errorWrapper = this.$el.querySelector(".error-block-under-input__wrapper");
+    if (!$errorWrapper || $lastInputWrapper && !($lastInputWrapper.nextElementSibling === $errorWrapper)) {
+      $errorWrapper = document.createElement("div");
+      $errorWrapper.className = "error-block-under-input__wrapper";
+      $errorWrapper.innerHTML = `
+      <div class="error-block-under-input error-block-under-input--warning" style="display:grid;grid-template-columns:auto 1fr;gap:8px;align-items:start;">
+        <div class="error-block-under-input__icon-wrapper" style="position:relative;width:20px;height:20px;">
+          <span class="error-block-under-input__icon" style="display:block;width:20px;height:20px;"></span>
+          <span class="error-block-under-input__icon error-block-under-input__icon--animated" style="display:block;position:absolute;inset:0;"></span>
+        </div>
+        <p class="error-block-under-input__text" style="margin:0;">
+          <span class="error-block-under-input__main-text"></span>
+          <span class="error-block-under-input__secondary-text"></span>
+        </p>
+      </div>
+    `;
+      Object.assign($errorWrapper.style, {
+        boxSizing: "border-box",
+        overflow: "hidden",
+        height: "0px",
+        paddingTop: "0px",
+        opacity: "0"
+      });
+      if ($lastInputWrapper) {
+        $lastInputWrapper.insertAdjacentElement("afterend", $errorWrapper);
+      } else {
+        this.$el.appendChild($errorWrapper);
+      }
+    } else {
+      $errorWrapper.style.boxSizing = "border-box";
+      $errorWrapper.style.overflow = "hidden";
+    }
+    $errorWrapper.querySelector(".error-block-under-input__main-text").textContent = text;
+    const $secondaryText = $errorWrapper.querySelector(
+      ".error-block-under-input__secondary-text"
+    );
+    if ($secondaryText) $secondaryText.textContent = "";
+    (_a2 = $errorWrapper.querySelector(".error-block-under-input")) == null ? void 0 : _a2.classList.remove("error-block-under-input--success");
+    const prevHeight = $errorWrapper.style.height;
+    const prevPadding = $errorWrapper.style.paddingTop;
+    $errorWrapper.style.height = "auto";
+    $errorWrapper.style.paddingTop = `${this._anim.paddingTopOpened}px`;
+    const targetHeight = $errorWrapper.clientHeight;
+    $errorWrapper.style.height = prevHeight || "0px";
+    $errorWrapper.style.paddingTop = prevPadding || "0px";
+    if (parseFloat($errorWrapper.style.height) === targetHeight && parseFloat($errorWrapper.style.opacity || "1") === 1) {
+      this._ringIcon($errorWrapper);
+    } else {
+      this._cancelAnimations($errorWrapper);
+      if (this._canAnimate($errorWrapper)) {
+        const anim = $errorWrapper.animate(
+          [
+            {
+              height: `${parseFloat($errorWrapper.style.height) || 0}px`,
+              paddingTop: `${parseFloat($errorWrapper.style.paddingTop) || 0}px`,
+              opacity: parseFloat($errorWrapper.style.opacity || "0")
+            },
+            {
+              height: `${targetHeight}px`,
+              paddingTop: `${this._anim.paddingTopOpened}px`,
+              opacity: 1
+            }
+          ],
+          { duration: this._anim.duration, easing: this._anim.easing, fill: "forwards" }
+        );
+        anim.addEventListener("finish", () => {
+          $errorWrapper.style.height = "auto";
+          $errorWrapper.style.paddingTop = `${this._anim.paddingTopOpened}px`;
+          $errorWrapper.style.opacity = "1";
+        });
+      } else {
+        $errorWrapper.style.height = "auto";
+        $errorWrapper.style.paddingTop = `${this._anim.paddingTopOpened}px`;
+        $errorWrapper.style.opacity = "1";
+      }
+      this._ringIcon($errorWrapper);
+    }
+    this.$el.addEventListener("input", () => this.hideErrorForm(), { passive: true, once: true });
+  }
+  /** Скрывает ошибку под полями ввода - ошибку, относящуюся ко всей форме. */
+  hideErrorForm() {
+    const inputWrappersList = this.$el.querySelectorAll(this.config.inputWrapperSelector);
+    const $lastInputWrapper = inputWrappersList[inputWrappersList.length - 1];
+    const $errorWrapper = ($lastInputWrapper == null ? void 0 : $lastInputWrapper.nextElementSibling) || this.$el.querySelector(".error-block-under-input__wrapper");
+    if (!$errorWrapper || !$errorWrapper.classList.contains("error-block-under-input__wrapper")) return;
+    const wasAuto = $errorWrapper.style.height === "" || $errorWrapper.style.height === "auto";
+    if (wasAuto) {
+      $errorWrapper.style.height = `${$errorWrapper.clientHeight}px`;
+    }
+    $errorWrapper.style.paddingTop = $errorWrapper.style.paddingTop || `${this._anim.paddingTopOpened}px`;
+    $errorWrapper.style.opacity = $errorWrapper.style.opacity || "1";
+    this._cancelAnimations($errorWrapper);
+    if (this._canAnimate($errorWrapper)) {
+      const anim = $errorWrapper.animate(
+        [
+          {
+            height: `${parseFloat($errorWrapper.style.height) || $errorWrapper.clientHeight}px`,
+            paddingTop: `${parseFloat($errorWrapper.style.paddingTop) || this._anim.paddingTopOpened}px`,
+            opacity: parseFloat($errorWrapper.style.opacity || "1")
+          },
+          { height: "0px", paddingTop: "0px", opacity: 0 }
+        ],
+        { duration: this._anim.duration, easing: this._anim.easing, fill: "forwards" }
+      );
+      anim.addEventListener("finish", () => {
+        $errorWrapper.remove();
+      });
+    } else {
+      $errorWrapper.remove();
+    }
+  }
+  /** Короткая анимация иконки без CSS */
+  _ringIcon($wrapper) {
+    const $icon = $wrapper.querySelector(".error-block-under-input__icon--animated");
+    if (!$icon) return;
+    this._cancelAnimations($icon);
+    if (!this._canAnimate($icon)) return;
+    $icon.animate(
+      [
+        { transform: "rotate(0deg) scale(1)", opacity: 0 },
+        { transform: "rotate(-8deg) scale(1.05)", opacity: 1, offset: 0.15 },
+        { transform: "rotate(8deg)  scale(1.05)", opacity: 1, offset: 0.3 },
+        { transform: "rotate(-6deg) scale(1.03)", opacity: 1, offset: 0.45 },
+        { transform: "rotate(6deg)  scale(1.03)", opacity: 1, offset: 0.6 },
+        { transform: "rotate(0deg)  scale(1)", opacity: 0 }
+      ],
+      { duration: this._anim.iconDuration, easing: "ease" }
+    );
+  }
+  /** Полностью снимает слушатели и чистит артефакты формы. */
+  destroy() {
+    var _a2;
+    if (this._onSubmitHandler) {
+      this.$el.removeEventListener("submit", this._onSubmitHandler);
+      this._onSubmitHandler = void 0;
+    }
+    if (this._onSubmitClickHandler) {
+      this.$submits.forEach(($submit) => {
+        $submit.removeEventListener("click", this._onSubmitClickHandler);
+      });
+      this._onSubmitClickHandler = void 0;
+    }
+    this.clearFieldValidationEvents();
+    (_a2 = this.mutationObserver) == null ? void 0 : _a2.disconnect();
+    this.mutationObserver = void 0;
+    const formErrorWrapper = this.$el.querySelector(".error-block-under-input__wrapper");
+    if (formErrorWrapper) {
+      this._cancelAnimations(formErrorWrapper);
+      formErrorWrapper.remove();
+    }
+    this.hideErrorSummary();
+    this.$submits.forEach(($submit) => {
+      $submit.classList.remove("button--loading");
+      const btnLoader = $submit.querySelector(".button__loader");
+      if (btnLoader) btnLoader.remove();
+    });
+    const inputs = this.$el.querySelectorAll("input, textarea, select");
+    inputs.forEach(($i) => {
+      this.hideError($i);
+      this.clearFieldValidationState($i);
+    });
+    document.documentElement.removeAttribute("data-now-scrolling");
+    this.inputs = null;
+    this.$submits = [];
+    this.errors = [];
+    this.waitResponse = false;
+    FORM_INSTANCES.delete(this.$el);
+  }
+  /**
+   * Проверяет входные данные на их корректность.
+   *
+   * @returns {boolean} Корректны данные или нет (true/false).
+   */
+  isCorrectArguments() {
+    if (this.$el.tagName !== "FORM") {
+      console.warn(`$el \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0442\u0435\u0433\u043E\u043C form`);
+      return false;
+    }
+    if (this.$submits.length === 0) {
+      console.warn(`\u0412 \u0444\u043E\u0440\u043C\u0435 \u043D\u0435\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 \u0441 \u0442\u0438\u043F\u043E\u043C submit`);
+      return false;
+    }
+    return true;
+  }
+  formDataToObject(formData) {
+    const data = {};
+    formData.forEach((value, key) => {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        if (!Array.isArray(data[key])) {
+          data[key] = [data[key]];
+        }
+        data[key].push(value);
+      } else {
+        data[key] = value;
+      }
+    });
+    return data;
+  }
+  appendFormDataValue(formData, key, value) {
+    if (value === void 0 || value === null) return;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        this.appendFormDataValue(formData, `${key}[${index}]`, item);
+      });
+      return;
+    }
+    if (value instanceof Blob) {
+      formData.append(key, value);
+      return;
+    }
+    formData.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+  }
+  objectToFormData(data) {
+    const formData = new FormData();
+    Object.entries(data).forEach(([key, value]) => {
+      this.appendFormDataValue(formData, key, value);
+    });
+    return formData;
+  }
+  stringifyFormDataValue(value) {
+    return typeof value === "string" ? value : value.name;
+  }
+  formDataToUrlSearchParams(formData) {
+    const params = new URLSearchParams();
+    formData.forEach((value, key) => {
+      params.append(key, this.stringifyFormDataValue(value));
+    });
+    return params;
+  }
+  formDataToTextBody(formData) {
+    return Array.from(formData).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(this.stringifyFormDataValue(value))}`).join("\n");
+  }
+  isBodylessMethod(method) {
+    return method === "GET" || method === "HEAD";
+  }
+  appendQueryString(action, params) {
+    const query = params.toString();
+    if (!query) return action;
+    const separator = action.includes("?") ? "&" : "?";
+    return `${action}${separator}${query}`;
+  }
+  findFieldByName(name) {
+    const fields = Array.from(this.$el.querySelectorAll("input, textarea, select"));
+    return fields.find(($field) => $field.name === name) || null;
+  }
+  async parseResponseBody(response) {
+    try {
+      const responseBody = await response.json();
+      return responseBody && typeof responseBody === "object" ? responseBody : {
+        success: false,
+        error: true,
+        "error-msg": "\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 \u043E\u0442\u0432\u0435\u0442 \u0441\u0435\u0440\u0432\u0435\u0440\u0430"
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: true,
+        "error-msg": "\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 \u043E\u0442\u0432\u0435\u0442 \u0441\u0435\u0440\u0432\u0435\u0440\u0430"
+      };
+    }
+  }
+  handleUnsuccessfulResponse(responseBody) {
+    if (responseBody.error !== true) return;
+    if (responseBody["error-msg"]) {
+      this.setErrorRecord(FORM_ERROR_FIELD, "server", responseBody["error-msg"], "server");
+      this.showErrorForm(responseBody["error-msg"]);
+    }
+    if (responseBody.errors) {
+      const fieldsList = [];
+      responseBody.errors.forEach((error) => {
+        const $field = this.findFieldByName(error.name);
+        if ($field) {
+          fieldsList.push($field);
+          this.setValidationError($field, "server", error["error-msg"], "server");
+          this.showError($field, error["error-msg"]);
+          $field.removeAttribute("aria-busy");
+          this.setFieldValidationState($field, "invalid");
+        } else {
+          this.setErrorRecord(error.name, "server", error["error-msg"], "server");
+          console.warn(`\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043F\u043E\u043B\u0435 \u0441 \u0438\u043C\u0435\u043D\u0435\u043C: ${error.name}, \u0434\u043B\u044F \u0432\u044B\u0432\u043E\u0434\u0430 \u043E\u0448\u0438\u0431\u043A\u0438: ${error["error-msg"]}`);
+        }
+      });
+      if (this.config.scrollToFirstErroredInput === true) this.scrollToFirstErroredInput(fieldsList);
+      if (this.config.focusFirstErroredInput === true) this.focusFirstErroredInput(fieldsList);
+    }
+    this.syncErrorSummary();
+  }
+  async sendData() {
+    var _a2;
+    const action = this.$el.getAttribute("action") || "";
+    const method = ((_a2 = this.$el.getAttribute("method")) == null ? void 0 : _a2.toUpperCase()) || "POST";
+    const enctype = this.$el.getAttribute("enctype") || "application/x-www-form-urlencoded";
+    let body = null;
+    let headers = {};
+    const formData = serializeToFormData(this.$el);
+    let data = this.formDataToObject(formData);
+    if (this.config.logging) {
+      for (const key of formData.keys()) console.log(formData.get(key));
+    }
+    const hasDataWrapper = typeof this.config.wrapData === "function";
+    if (typeof this.config.wrapData === "function") {
+      data = this.config.wrapData(data);
+    }
+    const requestFormData = hasDataWrapper ? this.objectToFormData(data) : formData;
+    if (this.isBodylessMethod(method)) {
+      return fetch(this.appendQueryString(action, this.formDataToUrlSearchParams(requestFormData)), {
+        method,
+        headers
+      });
+    }
+    switch (enctype) {
+      case "application/x-www-form-urlencoded":
+        body = this.formDataToUrlSearchParams(requestFormData).toString();
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+        break;
+      case "multipart/form-data":
+        body = requestFormData;
+        break;
+      case "text/plain":
+        body = this.formDataToTextBody(requestFormData);
+        headers["Content-Type"] = "text/plain";
+        break;
+      case "application/json":
+        body = JSON.stringify(data);
+        headers["Content-Type"] = "application/json";
+        break;
+      default:
+        console.warn(`\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 enctype: ${enctype}. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442\u0441\u044F application/x-www-form-urlencoded.`);
+        body = this.formDataToUrlSearchParams(requestFormData).toString();
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    return fetch(action, {
+      method,
+      body,
+      headers
+    });
+  }
+  async submit() {
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (!this.waitResponse) {
+      let loadingFinished = false;
+      const finishLoading = () => {
+        if (loadingFinished) return;
+        this.waitResponse = false;
+        if (this.config.showLoaderButton === true) this.hideLoader();
+        loadingFinished = true;
+      };
+      try {
+        const beforeSubmitResult = await ((_b = (_a2 = this.config).onBeforeSubmit) == null ? void 0 : _b.call(_a2, this));
+        if (beforeSubmitResult === false) {
+          return {
+            success: false
+          };
+        }
+        if (this.config.showLoaderButton === true) this.showLoader();
+        (_d = (_c = this.config).onSubmit) == null ? void 0 : _d.call(_c, this);
+        this.waitResponse = true;
+        const response = await this.sendData();
+        const responseBody = await this.parseResponseBody(response);
+        finishLoading();
+        (_f = (_e = this.config).onResponse) == null ? void 0 : _f.call(_e, responseBody, this);
+        if (response.ok && responseBody.success === true) {
+          (_h = (_g = this.config).onResponseSuccess) == null ? void 0 : _h.call(_g, responseBody, this);
+        } else {
+          (_j = (_i = this.config).onResponseUnsuccess) == null ? void 0 : _j.call(_i, responseBody, this);
+          this.handleUnsuccessfulResponse(responseBody);
+        }
+        parseCommonResponseProperties(responseBody);
+        return {
+          success: response.ok && responseBody.success === true,
+          response,
+          responseBody
+        };
+      } catch (error) {
+        finishLoading();
+        (_l = (_k = this.config).onSubmitError) == null ? void 0 : _l.call(_k, error, this);
+        throw error;
+      }
+    }
+    return void 0;
+  }
+}
+
+export { FORM_ERROR_FIELD, blockScrollBody, closest, createFieldValidator, createFormValidator, createLengthValidator, createPatternValidator, createSchemaValidator, dateOrder, Form as default, getAllValidators, getValidator, isEmailValid, isPhoneValid, isUrlValid, parseCommonResponseProperties, registerFieldValidator, registerSchemaValidator, registerValidator, requiredIf, sameAsField, serializeFormToJSON, serializeToFormData, unblockScrollBody };
+//# sourceMappingURL=index.js.map