form-father 0.2.8 → 0.2.10

package/{index.js → dist/index.js}

@@ -73,6 +73,103 @@ function closest($el, selector) {
     }
     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);
+}
+/**
+ * Проверяет является ли строка валидным адресом электронной почты.
+ *
+ * @param {string} value - Строка, которую нужно проверить.
+ *
+ * @returns {boolean} Является ли строка валидным адресом электронной почты true/false.
+ */
+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));
+}
+/**
+ * Проверяет является ли строка валидным url.
+ *
+ * @param {string} originalUrlString - Строка, которую нужно проверить.
+ *
+ * @returns {boolean} Является ли строка валидным url адресом true/false.
+ */
+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 (_a) {
+        return false;
+    }
+}
+/**
+ * Проверяет является ли строка валидным номером телефона.
+ *
+ * @param {string} value - Строка, которую нужно проверить.
+ *
+ * @returns {boolean} Является ли строка валидным номером телефона true/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;
+}
 /**
  * Кастомная сериализация формы в объект FormData.
  *
@@ -92,12 +189,15 @@ function serializeToFormData($element) {
             element instanceof HTMLButtonElement)) {
             return;
         }
-        if (!element.name || element.hasAttribute('data-no-serialize')) {
+        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.getAttribute('multiple') === 'true') {
+            if (element.multiple) {
                 const files = element.files;
                 if (files) {
                     for (let i = 0; i < files.length; i++) {
@@ -199,6 +299,29 @@ function parseCommonResponseProperties(responseBody) {
         }
     }
 }
+/**
+ * Сериализует данные формы в объект JSON.
+ *
+ * @param {HTMLFormElement} form - Элемент формы.
+ *
+ * @returns {Object} Сериализованные данные формы.
+ */
+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;
 /* ---------- singleton-storage на globalThis ---------- */
@@ -217,7 +340,12 @@ function getAllValidators() {
     return new Map(validators); // копию, чтобы никто не мутировал оригинал
 }
 /* ---------- built-in rules ---------- */
-registerValidator('required', (value, $input, $form) => {
+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;
@@ -230,10 +358,10 @@ registerValidator('required', (value, $input, $form) => {
     // fallback — если нет $input (например, в unit-тестах)
     return value.trim().length > 0;
 }, 'Пустое значение');
-registerValidator('email', v => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v), 'Неверный формат');
-registerValidator('tel', v => /^\+7\d{10}$/.test(v), 'Неверный формат');
-registerValidator('url', v => /^(https?:\/\/).+\..+/.test(v), 'Неверный формат');
-registerValidator('not-numbers', v => !/[0-9]/.test(v), 'Неверный формат');
+registerBuiltinValidator('email', v => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v), 'Неверный формат');
+registerBuiltinValidator('tel', v => /^\+7\d{10}$/.test(v), 'Неверный формат');
+registerBuiltinValidator('url', v => isUrlValid(v), 'Неверный формат');
+registerBuiltinValidator('not-numbers', v => !/[0-9]/.test(v), 'Неверный формат');
 
 var _a;
 // --- shared cross-file state (singleton via globalThis) ---
@@ -295,7 +423,7 @@ class Form {
      * @param {HTMLElement} $el - Элемент формы (тег form!).
      * @param {Object} options - Параметры формы.
      */
-    constructor($el, options) {
+    constructor($el, options = {}) {
         this.$submits = [];
         this.waitResponse = false;
         this.inputs = null;
@@ -360,20 +488,10 @@ class Form {
         this.defaultParams = Object.assign(Object.assign({}, this.defaultParams), params);
     }
     findSubmitElements() {
-        return Array.from(this.$el.querySelectorAll('input[type="submit"], button[type="submit"]'));
+        return Array.from(this.$el.querySelectorAll('input[type="submit"], input[type="image"], button[type="submit"], button:not([type])'));
     }
     initialization() {
         this.inputs = this.$el.querySelectorAll(this.config.inputSelector);
-        /* TODO: Добавить параметр с возможностью отключать/включать кнопку, в зависимости от валидности поля. */
-        // this.$licensesCheckbox = this.$el.querySelector('input[data-input-name="user-consent"]') as HTMLInputElement;
-        // if (this.$licensesCheckbox) {
-        // 	if (this.$licensesCheckbox.checked) this.enableSubmit();
-        // 	else this.disableSubmit();
-        // 	this.$licensesCheckbox.addEventListener('change', () => {
-        // 		if (this.$licensesCheckbox!.checked) this.enableSubmit();
-        // 		else this.disableSubmit();
-        // 	});
-        // }
         this._onSubmitHandler = (e) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
             e.preventDefault();
@@ -392,7 +510,26 @@ class Form {
      * @param {String} text - Текст ошибки.
      */
     showError($input, text) {
-        closest($input, this.config.inputWrapperSelector).showError(text);
+        const $inputWrapper = closest($input, this.config.inputWrapperSelector);
+        if (!$inputWrapper) {
+            console.warn(`Не найдена обёртка для поля с именем: ${$input.name || $input.type}`);
+            return;
+        }
+        const customShowError = $inputWrapper.showError;
+        if (typeof customShowError === 'function') {
+            customShowError.call($inputWrapper, text);
+            return;
+        }
+        $input.setAttribute('aria-invalid', 'true');
+        $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;
     }
     /** Показывает лоадер */
     showLoader() {
@@ -447,10 +584,13 @@ class Form {
      * @param {HTMLInputElement} $input - Поле ввода.
      */
     hideError($input) {
-        const $inputWrapper = $input.parentElement;
+        var _a;
+        const $inputWrapper = closest($input, this.config.inputWrapperSelector) || $input.parentElement;
+        $input.removeAttribute('aria-invalid');
+        (_a = $inputWrapper === null || $inputWrapper === void 0 ? void 0 : $inputWrapper.querySelector('[data-form-father-error]')) === null || _a === void 0 ? void 0 : _a.remove();
+        $inputWrapper === null || $inputWrapper === void 0 ? void 0 : $inputWrapper.classList.remove('input__wrapper--error');
         if ($inputWrapper && $inputWrapper.classList.contains('input__wrapper')) {
             $inputWrapper.getAttribute('data-type-error') || 'default';
-            $inputWrapper.classList.remove('input__wrapper--error');
         }
     }
     /**
@@ -517,7 +657,10 @@ class Form {
                     .split(',')
                     .map(s => s.trim())
                     .filter(Boolean);
-                list.push(...custom); // 3
+                list.push(...custom.map(ruleString => {
+                    const [rule, ...params] = ruleString.split(':').map(s => s.trim());
+                    return params.length > 0 ? { rule, params: params.length === 1 ? params[0] : params } : rule;
+                })); // 3
                 /* —–– предварительная фильтрация unknown ––– */
                 const filtered = [];
                 for (const r of list) {
@@ -533,7 +676,8 @@ class Form {
                 if ($input.hasAttribute('data-no-validate'))
                     return;
                 const empty = $input.type === 'checkbox' || $input.type === 'radio' ? !$input.checked : $input.value.trim().length === 0;
-                if (empty && !rules.includes('required')) {
+                const hasRequiredRule = rules.some(r => (typeof r === 'string' ? r === 'required' : r.rule === 'required'));
+                if (empty && !hasRequiredRule) {
                     this.hideError($input);
                     return;
                 }
@@ -567,6 +711,11 @@ class Form {
                 }
                 this.hideError($input);
             });
+            const getRadioGroup = ($input) => {
+                if ($input.type !== 'radio' || !$input.name)
+                    return [];
+                return Array.from($block.querySelectorAll('input[type="radio"]')).filter($radio => $radio.name === $input.name);
+            };
             /* ---------- 1. inputs из schema (config + defaults) ---------- */
             for (const [key, def] of Object.entries(schema)) {
                 const { selector, rules = [], messages = {} } = def;
@@ -576,6 +725,12 @@ class Form {
                 for (const $input of Array.from(nodeList)) {
                     if (processed.has($input))
                         continue;
+                    const radioGroup = getRadioGroup($input);
+                    if (radioGroup.length > 0) {
+                        radioGroup.forEach($radio => processed.add($radio));
+                        yield validateInput($input, collectRules($input, rules), messages);
+                        continue;
+                    }
                     processed.add($input);
                     yield validateInput($input, collectRules($input, rules), messages);
                 }
@@ -631,8 +786,8 @@ class Form {
     _cancelAnimations(el) {
         var _a;
         // Отменяем все активные WAAPI-анимации у элемента
-        // @ts-ignore
-        (_a = el === null || el === void 0 ? void 0 : el.getAnimations) === null || _a === void 0 ? void 0 : _a.call(el).forEach((a) => a.cancel());
+        const animatedEl = el;
+        (_a = animatedEl === null || animatedEl === void 0 ? void 0 : animatedEl.getAnimations) === null || _a === void 0 ? void 0 : _a.call(animatedEl).forEach(animation => animation.cancel());
     }
     /**
      * Показывает ошибку под полями ввода - ошибку, относящуюся ко всей форме.
@@ -644,7 +799,7 @@ class Form {
         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.nextElementSibling === $errorWrapper)) {
+        if (!$errorWrapper || ($lastInputWrapper && !($lastInputWrapper.nextElementSibling === $errorWrapper))) {
             $errorWrapper = document.createElement('div');
             $errorWrapper.className = 'error-block-under-input__wrapper';
             $errorWrapper.innerHTML = `
@@ -667,7 +822,12 @@ class Form {
                 paddingTop: '0px',
                 opacity: '0',
             });
-            $lastInputWrapper.insertAdjacentElement('afterend', $errorWrapper);
+            if ($lastInputWrapper) {
+                $lastInputWrapper.insertAdjacentElement('afterend', $errorWrapper);
+            }
+            else {
+                this.$el.appendChild($errorWrapper);
+            }
         }
         else {
             // убедимся, что нужные стартовые inline-стили есть
@@ -682,7 +842,6 @@ class Form {
         // Сброс success-класса, если он устанавливался где-то в другом коде
         (_a = $errorWrapper.querySelector('.error-block-under-input')) === null || _a === void 0 ? void 0 : _a.classList.remove('error-block-under-input--success');
         // Посчитать целевую высоту
-        $errorWrapper.querySelector('.error-block-under-input');
         // Чтобы корректно мерить, временно выставим auto
         const prevHeight = $errorWrapper.style.height;
         const prevPadding = $errorWrapper.style.paddingTop;
@@ -735,7 +894,7 @@ class Form {
     hideErrorForm() {
         const inputWrappersList = this.$el.querySelectorAll(this.config.inputWrapperSelector);
         const $lastInputWrapper = inputWrappersList[inputWrappersList.length - 1];
-        const $errorWrapper = $lastInputWrapper.nextElementSibling;
+        const $errorWrapper = (($lastInputWrapper === null || $lastInputWrapper === void 0 ? void 0 : $lastInputWrapper.nextElementSibling) || this.$el.querySelector('.error-block-under-input__wrapper'));
         if (!$errorWrapper || !$errorWrapper.classList.contains('error-block-under-input__wrapper'))
             return;
         // Текущая высота (если была auto) — измерим и зафиксируем
@@ -816,11 +975,8 @@ class Form {
                 btnLoader.remove();
         });
         // 4) Сбросить ошибки у инпутов (если разметка позволяет)
-        const inputs = this.$el.querySelectorAll('input, textarea');
-        inputs.forEach($i => {
-            if ($i instanceof HTMLInputElement)
-                this.hideError($i);
-        });
+        const inputs = this.$el.querySelectorAll('input, textarea, select');
+        inputs.forEach($i => this.hideError($i));
         // 5) Убрать возможный флаг скролла
         document.documentElement.removeAttribute('data-now-scrolling');
         // 6) Очистить ссылки на элементы, чтобы помочь GC
@@ -844,6 +1000,115 @@ class Form {
         }
         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 === undefined || 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;
+    }
+    parseResponseBody(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const responseBody = yield response.json();
+                return responseBody && typeof responseBody === 'object'
+                    ? responseBody
+                    : {
+                        success: false,
+                        error: true,
+                        'error-msg': 'Некорректный ответ сервера',
+                    };
+            }
+            catch (_a) {
+                return {
+                    success: false,
+                    error: true,
+                    'error-msg': 'Некорректный ответ сервера',
+                };
+            }
+        });
+    }
+    handleUnsuccessfulResponse(responseBody) {
+        if (responseBody.error !== true)
+            return;
+        if (responseBody['error-msg']) {
+            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.showError($field, error['error-msg']);
+                }
+                else {
+                    console.warn(`Не найдено поле с именем: ${error.name}, для вывода ошибки: ${error['error-msg']}`);
+                }
+            });
+            if (this.config.scrollToFirstErroredInput === true)
+                this.scrollToFirstErroredInput(fieldsList);
+        }
+    }
     sendData() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -854,31 +1119,34 @@ class Form {
             let headers = {};
             // Сбор данных из формы
             const formData = serializeToFormData(this.$el);
-            let data = {};
-            formData.forEach((value, key) => {
-                data[key] = value;
-            });
+            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 = new URLSearchParams(serializeToFormData(this.$el)).toString();
+                    body = this.formDataToUrlSearchParams(requestFormData).toString();
                     headers['Content-Type'] = 'application/x-www-form-urlencoded';
                     break;
                 case 'multipart/form-data':
-                    body = serializeToFormData(this.$el);
+                    body = requestFormData;
                     // ВАЖНО: Не указываем Content-Type, т.к. браузер сам добавит с корректной границей!
                     break;
                 case 'text/plain':
-                    body = Array.from(serializeToFormData(this.$el))
-                        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-                        .join('\n');
+                    body = this.formDataToTextBody(requestFormData);
                     headers['Content-Type'] = 'text/plain';
                     break;
                 case 'application/json':
@@ -887,7 +1155,7 @@ class Form {
                     break;
                 default:
                     console.warn(`Неизвестный enctype: ${enctype}. Используется application/x-www-form-urlencoded.`);
-                    body = new URLSearchParams(serializeToFormData(this.$el)).toString();
+                    body = this.formDataToUrlSearchParams(requestFormData).toString();
                     headers['Content-Type'] = 'application/x-www-form-urlencoded';
             }
             return fetch(action, {
@@ -905,45 +1173,37 @@ class Form {
                     this.showLoader();
                 (_b = (_a = this.config).onSubmit) === null || _b === void 0 ? void 0 : _b.call(_a, this);
                 this.waitResponse = true;
-                const response = yield this.sendData();
-                const responseBody = yield response.json();
-                this.waitResponse = false;
-                if (this.config.showLoaderButton === true)
-                    this.hideLoader();
-                (_d = (_c = this.config).onResponse) === null || _d === void 0 ? void 0 : _d.call(_c, responseBody, this);
-                if (response.status === 200) {
-                    if (responseBody.success === true) {
+                let loadingFinished = false;
+                const finishLoading = () => {
+                    if (loadingFinished)
+                        return;
+                    this.waitResponse = false;
+                    if (this.config.showLoaderButton === true)
+                        this.hideLoader();
+                    loadingFinished = true;
+                };
+                try {
+                    const response = yield this.sendData();
+                    const responseBody = yield this.parseResponseBody(response);
+                    finishLoading();
+                    (_d = (_c = this.config).onResponse) === null || _d === void 0 ? void 0 : _d.call(_c, responseBody, this);
+                    if (response.ok && responseBody.success === true) {
                         (_f = (_e = this.config).onResponseSuccess) === null || _f === void 0 ? void 0 : _f.call(_e, responseBody, this);
                     }
                     else {
                         (_h = (_g = this.config).onResponseUnsuccess) === null || _h === void 0 ? void 0 : _h.call(_g, responseBody, this);
-                        if (responseBody.error === true) {
-                            if (responseBody['error-msg']) {
-                                this.showErrorForm(responseBody['error-msg']);
-                            }
-                            if (responseBody.errors) {
-                                const inputsList = [];
-                                responseBody.errors.forEach(error => {
-                                    const $input = this.$el.querySelector(`input[name="${error.name}"]`);
-                                    if ($input) {
-                                        inputsList.push($input);
-                                        this.showError($input, error['error-msg']);
-                                    }
-                                    else {
-                                        console.warn(`Не найдено поле с именем: ${error.name}, для вывода ошибки: ${error['error-msg']}`);
-                                    }
-                                });
-                                if (this.config.scrollToFirstErroredInput === true)
-                                    this.scrollToFirstErroredInput(inputsList);
-                            }
-                        }
+                        this.handleUnsuccessfulResponse(responseBody);
                     }
                     parseCommonResponseProperties(responseBody);
                 }
+                catch (error) {
+                    finishLoading();
+                    throw error;
+                }
             }
         });
     }
 }
 
-export { Form as default, getAllValidators, getValidator, registerValidator };
+export { blockScrollBody, closest, Form as default, getAllValidators, getValidator, isEmailValid, isPhoneValid, isUrlValid, parseCommonResponseProperties, registerValidator, serializeFormToJSON, serializeToFormData, unblockScrollBody };
 //# sourceMappingURL=index.js.map

package/{index.js.map → dist/index.js.map}

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}