intelicoreact 1.8.69 → 2.0.1

package/dist/hooks.cjs

@@ -0,0 +1,2646 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  DATETIME_FORMATS: () => DATETIME_FORMATS,
+  DATE_UNITS: () => DATE_UNITS,
+  Portal: () => Portal_default,
+  addEventListener: () => addEventListener,
+  addRangeDefault: () => addRangeDefault,
+  createTranslator: () => createTranslator,
+  customEventListener: () => customEventListener_default,
+  dispatchCustomEvent: () => dispatchCustomEvent,
+  filterFloat: () => filterFloat,
+  filterNumeric: () => filterNumeric,
+  formatAsPercentage: () => formatAsPercentage,
+  formatNumberValueToMask: () => formatNumberValueToMask,
+  formatOnlyNumbers: () => formatOnlyNumbers,
+  formatToAddBitDepthPoints: () => formatToAddBitDepthPoints,
+  formatToHex: () => formatToHex,
+  formatToHideValuePartially: () => formatToHideValuePartially,
+  formatToLimitLength: () => formatToLimitLength,
+  formatToOnlyASCIICodeText: () => formatToOnlyASCIICodeText,
+  formatToPriceWithCurrency: () => formatToPriceWithCurrency,
+  formatToPriceWithUSD: () => formatToPriceWithUSD,
+  formatToRemoveComa: () => formatToRemoveComa,
+  formatToReplaceAllWhiteSpace: () => formatToReplaceAllWhiteSpace,
+  getSafelyValue: () => getSafelyValue,
+  intlNumbersFormatter: () => intlNumbersFormatter,
+  isISuspendProcessing: () => isISuspendProcessing,
+  parseAndFormatDate: () => parseAndFormatDate,
+  removeEventListener: () => removeEventListener,
+  useBodyScrollLock: () => useBodyScrollLock_default,
+  useClickOutside: () => useClickOutside,
+  useDebounce: () => useDebounce,
+  useFieldsFocus: () => useFieldsFocus,
+  useFormFieldsChangesManager: () => useFormFieldsChangesManager_default,
+  useFormTools: () => useFormTools,
+  useInputHighlightError: () => useInputHighlightError_default,
+  useIsMobile: () => useIsMobile_default2,
+  useKeyPress: () => useKeyPress_default,
+  useLocalStorage: () => useLocalStorage_default,
+  useLocationParams: () => useLocationParams,
+  useMediaQuery: () => useMediaQuery_default,
+  useMetaInfo: () => useMetaInfo_default,
+  useMouseUpOutside: () => useMouseUpOutside,
+  useOnlineStatus: () => useOnlineStatus_default,
+  usePasswordChecker: () => usePasswordChecker,
+  usePrevious: () => usePrevious_default,
+  useResize: () => useResize,
+  useScrollTo: () => useScrollTo_default,
+  useToggle: () => useToggle_default
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/Functions/customEventListener.js
+(function() {
+  if (Element.prototype.__customEventListenerPatched) return;
+  Element.prototype.__customEventListenerPatched = true;
+  Element.prototype._addEventListener = Element.prototype.addEventListener;
+  Element.prototype.addEventListener = function(a, b, c) {
+    if (c == void 0) c = false;
+    this._addEventListener(a, b, c);
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+    this.eventListenerList[a].push({ listener: b, useCapture: c });
+  };
+  Element.prototype.getEventListeners = function(a) {
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (a == void 0) return this.eventListenerList;
+    return this.eventListenerList[a];
+  };
+  Element.prototype.clearEventListeners = function(a) {
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (a == void 0) {
+      for (const x in this.getEventListeners()) this.clearEventListeners(x);
+      return;
+    }
+    const el = this.getEventListeners(a);
+    if (el == void 0) return;
+    for (let i = el.length - 1; i >= 0; --i) {
+      const ev = el[i];
+      this.removeEventListener(a, ev.listener, ev.useCapture);
+    }
+  };
+  Element.prototype._removeEventListener = Element.prototype.removeEventListener;
+  Element.prototype.removeEventListener = function(a, b, c) {
+    if (c == void 0) c = false;
+    this._removeEventListener(a, b, c);
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+    for (let i = 0; i < this.eventListenerList[a].length; i++) {
+      if (this.eventListenerList[a][i].listener == b && this.eventListenerList[a][i].useCapture == c) {
+        this.eventListenerList[a].splice(i, 1);
+        break;
+      }
+    }
+    if (this.eventListenerList[a].length == 0) delete this.eventListenerList[a];
+  };
+})();
+function addEventListener(element, eventName, handler) {
+  if (element && element.addEventListener) {
+    element.addEventListener(eventName, handler);
+  }
+}
+function removeEventListener(element, eventName, handler) {
+  if (element && element.removeEventListener) {
+    element.removeEventListener(eventName, handler);
+  }
+}
+function dispatchCustomEvent(element, eventName, detail = {}) {
+  if (element) {
+    const event = new CustomEvent(eventName, { detail });
+    element.dispatchEvent(event);
+  }
+}
+var customEventListener_default = {
+  addEventListener,
+  removeEventListener,
+  dispatchCustomEvent
+};
+
+// src/Functions/dateTime.js
+var import_moment = __toESM(require("moment"), 1);
+var DATETIME_FORMATS = Object.freeze({
+  // Основные форматы
+  DATE_FORMAT: "YYYY-MM-DD",
+  // Стандартный формат даты
+  DATE_WITHOUT_SEPARATORS: "MMDDYYYY",
+  // Без разделителей
+  VALIDATION_DATE_FORMAT: "MM/DD/YYYY",
+  // Для валидации
+  INPUT_DATE_FORMAT: "MM.DD.YYYY",
+  // Формат для ввода
+  INPUT_TIME_FORMAT: "YYYY-MM-DD HH:mm:SS",
+  // Ввод времени
+  TIME_FORMAT_WSPACE: "YYYY-MM-DD HH:mm:SS",
+  // Время с пробелом
+  TIME_FORMAT: "YYYY-MM-DDTHH:mm:SS",
+  // Время с T (ISO формат)
+  DATE_FORMAT_WITH_SLASH: "MM/DD/YYYY",
+  // Дата с разделителем /
+  // Дополнительные форматы
+  DATE_WITH_DASHES: "MM-DD-YYYY",
+  // Дата с дефисами
+  DATE_WITH_DOTS: "DD.MM.YYYY",
+  // Дата с точками
+  DATE_WITH_COMMA: "DD,MM,YYYY",
+  // Дата с запятыми
+  FULL_DATE_TIME: "YYYY-MM-DD HH:mm:ss",
+  // Полная дата и время
+  ISO_DATE_TIME: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+  // ISO стандарт с миллисекундами
+  LOCALIZED_DATE: "MMMM DD, YYYY",
+  // Локализованный формат с полным названием месяца
+  SHORT_DATE: "MM/DD/YY",
+  // Краткая дата
+  SHORT_DATE_WITH_TIME: "MM/DD/YY HH:mm",
+  // Краткая дата с временем
+  TIME_24H: "HH:mm",
+  // Время в 24-часовом формате
+  TIME_12H: "hh:mm A",
+  // Время в 12-часовом формате
+  TIME_12H_WITH_SECONDS: "hh:mm:ss A",
+  // Время в 12-часовом формате с секундами
+  TIME_24H_WITH_SECONDS: "HH:mm:ss",
+  // Время в 24-часовом формате с секундами
+  MONTH_DAY: "MM/DD",
+  // Только месяц и день
+  YEAR_MONTH_DAY: "YYYY/MM/DD"
+  // Год/Месяц/День
+});
+var formatMap = Object.freeze({
+  [DATETIME_FORMATS.DATE_FORMAT]: "YYYY-MM-DD",
+  // Стандартный формат даты
+  [DATETIME_FORMATS.DATE_WITHOUT_SEPARATORS]: "MMDDYYYY",
+  // Без разделителей
+  [DATETIME_FORMATS.VALIDATION_DATE_FORMAT]: "MM/DD/YYYY",
+  // Для валидации
+  [DATETIME_FORMATS.INPUT_DATE_FORMAT]: "MM.DD.YYYY",
+  // Формат для ввода
+  [DATETIME_FORMATS.INPUT_TIME_FORMAT]: "YYYY-MM-DD HH:mm:SS",
+  // Ввод времени
+  [DATETIME_FORMATS.TIME_FORMAT_WSPACE]: "YYYY-MM-DD HH:mm:SS",
+  // Время с пробелом
+  [DATETIME_FORMATS.TIME_FORMAT]: "YYYY-MM-DDTHH:mm:SS",
+  // Время с T (ISO формат)
+  [DATETIME_FORMATS.DATE_FORMAT_WITH_SLASH]: "MM/DD/YYYY",
+  // Дата с разделителем /
+  [DATETIME_FORMATS.DATE_WITH_DASHES]: "MM-DD-YYYY",
+  // Дата с дефисами
+  [DATETIME_FORMATS.DATE_WITH_DOTS]: "DD.MM.YYYY",
+  // Дата с точками
+  [DATETIME_FORMATS.DATE_WITH_COMMA]: "DD,MM,YYYY",
+  // Дата с запятыми
+  [DATETIME_FORMATS.FULL_DATE_TIME]: "YYYY-MM-DD HH:mm:ss",
+  // Полная дата и время
+  [DATETIME_FORMATS.ISO_DATE_TIME]: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+  // ISO стандарт с миллисекундами
+  [DATETIME_FORMATS.LOCALIZED_DATE]: "MMMM DD, YYYY",
+  // Локализованный формат с полным названием месяца
+  [DATETIME_FORMATS.SHORT_DATE]: "MM/DD/YY",
+  // Краткая дата
+  [DATETIME_FORMATS.SHORT_DATE_WITH_TIME]: "MM/DD/YY HH:mm",
+  // Краткая дата с временем
+  [DATETIME_FORMATS.TIME_24H]: "HH:mm",
+  // Время в 24-часовом формате
+  [DATETIME_FORMATS.TIME_12H]: "hh:mm A",
+  // Время в 12-часовом формате
+  [DATETIME_FORMATS.TIME_12H_WITH_SECONDS]: "hh:mm:ss A",
+  // Время в 12-часовом формате с секундами
+  [DATETIME_FORMATS.TIME_24H_WITH_SECONDS]: "HH:mm:ss",
+  // Время в 24-часовом формате с секундами
+  [DATETIME_FORMATS.MONTH_DAY]: "MM/DD",
+  // Только месяц и день
+  [DATETIME_FORMATS.YEAR_MONTH_DAY]: "YYYY/MM/DD"
+  // Год/Месяц/День
+});
+var DATE_UNITS = Object.freeze({
+  YEARS: Object.freeze({
+    YEARS: "years",
+    YEAR: "year",
+    Y: "y",
+    TEMPLATE: "YYYY"
+  }),
+  MONTHS: Object.freeze({
+    MONTHS: "months",
+    MONTH: "month",
+    MON: "M",
+    TEMPLATE: "MM"
+  }),
+  DAYS: Object.freeze({
+    DAYS: "days",
+    DAY: "day",
+    D: "d",
+    TEMPLATE: "DD"
+  }),
+  HOURS: Object.freeze({
+    HOURS: "hours",
+    HOUR: "hour",
+    H: "h",
+    TEMPLATE: "HH"
+  }),
+  WEEKS: Object.freeze({
+    WEEKS: "weeks",
+    WEEK: "week",
+    W: "w"
+  }),
+  QUARTERS: Object.freeze({
+    QUARTERS: "quarters",
+    QUARTER: "quarter",
+    Q: "Q"
+  }),
+  MINUTES: Object.freeze({
+    MINUTES: "minutes",
+    MINUTE: "minute",
+    MIN: "m"
+  }),
+  SECONDS: Object.freeze({
+    SECONDS: "seconds",
+    SECOND: "second",
+    S: "s"
+  }),
+  MILLISECONDS: Object.freeze({
+    MILLISECONDS: "milliseconds",
+    MILLISECOND: "millisecond",
+    MS: "ms"
+  })
+});
+function parseAndFormatDate(value, outputFormat = DATETIME_FORMATS.INPUT_DATE_FORMAT) {
+  if (!value || typeof value !== "string") return value;
+  for (let format in formatMap) {
+    const parsedDate = (0, import_moment.default)(value, formatMap[format], true);
+    if (parsedDate.isValid()) {
+      return parsedDate.format(outputFormat);
+    }
+  }
+  return value;
+}
+
+// src/Constants/index.constants.js
+var KEYBOARD_SERVICE_KEYS = [
+  "Escape",
+  "F1",
+  "F2",
+  "F3",
+  "F4",
+  "F5",
+  "F6",
+  "F7",
+  "F8",
+  "F9",
+  "F10",
+  "F11",
+  "F12",
+  "Tab",
+  "CapsLock",
+  "Shift",
+  "Control",
+  "Meta",
+  "Option",
+  "Alt",
+  "ContextMenu",
+  "ArrowLeft",
+  "ArrowRight",
+  "ArrowUp",
+  "ArrowDown",
+  "NumLock",
+  "Backspace",
+  "Delete",
+  "Enter",
+  "Return",
+  "Insert",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "PrintScreen",
+  "ScrollLock",
+  "Pause"
+];
+var MAX_PHONE_LENGTH = 10;
+var MAX_NAME_LENGTH = 128;
+var DEFAULT_DATE_MASK_NO_VALUE_SYMBOL = "_";
+var DEFAULT_COLORS = [
+  "#D9C1FF",
+  "#FFBAF0",
+  "#FFB8CE",
+  "#FFC3A2",
+  "#FFDB7C",
+  "#F9F871",
+  "#C3FCF1",
+  "#F6F2CB",
+  "#E0F8D1",
+  "#B1DFFB",
+  "#8DECFE",
+  "#76F7ED",
+  "#8AFEC8"
+];
+var KEYBOARD_KEY_CODES = {
+  Backspace: 8,
+  Delete: 46,
+  ARROW_LEFT: 37,
+  ARROW_RIGHT: 39
+};
+var OS = {
+  iOS: "iOS",
+  Android: "Android",
+  WP: "Windows Phone",
+  Linux: "Linux",
+  Windows: "Windows",
+  MacOS: "MacOS",
+  Unknown: "unknown"
+};
+
+// src/Functions/utils.js
+var import_react = require("react");
+var import_moment_timezone = __toESM(require("moment-timezone"), 1);
+var uuid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
+var getIsOnlyAnObject = (input) => {
+  return typeof input === "object" && // "отбивает" примитивы и функции
+  input instanceof Object && // "отбивает" null
+  !Array.isArray(input) && // "отбивает" массивы
+  !(input instanceof Set) && // "отбивает" сеты
+  !(input instanceof Map);
+};
+var handleObjectChange = (updateObject, updateFunction) => (data, prop = "", isNumber) => {
+  let value;
+  if (data?.target) {
+    value = data.target.type === "checkbox" ? data.target.checked : data.target.value;
+  } else value = data;
+  value = isNumber ? Number(value) : value;
+  const props = prop.split(".");
+  const currentObject = props.reduce((res, chapter, index) => {
+    if (props.length !== index + 1) res = res[chapter];
+    return res;
+  }, updateObject);
+  currentObject[props.pop()] = value;
+  updateFunction();
+};
+var useOutsideToggle = (ref, setOut, open) => {
+  function handleClickOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    document.addEventListener("mouseup", handleClickOutside);
+    return () => {
+      document.removeEventListener("mouseup", handleClickOutside);
+    };
+  }, [ref]);
+};
+var clone = (input) => {
+  if (input === null || typeof input !== "object") return input;
+  const data = input instanceof Array ? [] : {};
+  for (const i in input) data[i] = clone(input[i]);
+  return data;
+};
+var getResponseClone = async (res) => await (typeof res?.clone === "function" ? res.clone() : clone(res));
+function transformUTCTimeToLocal(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  const utcDate = import_moment_timezone.default.utc(date).toDate();
+  return (0, import_moment_timezone.default)(utcDate, format).local().format(format);
+}
+function transformLocalTimeToUTC(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  return (0, import_moment_timezone.default)(date, format).utc().format(format);
+}
+function transformUTCHoursToLocal(time, format = "HH:mm:ss") {
+  if (!time) return;
+  const splitedTime = time.split(":");
+  const offset = (0, import_moment_timezone.default)().utcOffset();
+  let HH = Number(splitedTime[0]);
+  let mm = Number(splitedTime[1]);
+  const ss = splitedTime[2];
+  mm = mm + offset;
+  while (mm > 59) {
+    mm -= 60;
+    HH += 1;
+  }
+  if (HH > 23) HH -= 24;
+  while (mm < 0) {
+    mm += 60;
+    HH -= 1;
+  }
+  if (HH < 0) HH += 24;
+  return `${HH}:${mm}:${ss}`;
+}
+function transformDateOrTimeOrTogetherToFormat(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  const { parseFormat, isReturnAsMomentInstance } = getIsOnlyAnObject(
+    additional
+  ) ? additional : {};
+  if (typeof data !== "string" && typeof data !== "number") {
+    return isReturnAsMomentInstance ? (0, import_moment_timezone.default)("error") : ERROR_MESSGE;
+  }
+  const momentArgs = [
+    data,
+    ...!Number.isNaN(Number(data)) || typeof parseFormat === "string" ? [] : [parseFormat]
+  ];
+  const momentInstance = (() => {
+    let instance = (0, import_moment_timezone.default)(...momentArgs);
+    if (instance.format(outputFormat) !== ERROR_VALUE) return instance;
+    else if (/^\d\d.\d\d/.test(data)) {
+      instance = (0, import_moment_timezone.default)();
+      const symbols = data.split("");
+      const timeArr = symbols.reduce(
+        (acc, symbol, idx) => {
+          if (Number.isNaN(Number(symbol))) {
+            if (acc.group) acc.result.push(acc.group);
+            acc.group = "";
+          } else acc.group = `${acc.group}${symbol}`;
+          if (idx === symbols.length - 1 && acc.group)
+            acc.result.push(acc.group);
+          return acc;
+        },
+        { result: [], group: "" }
+      ).result.reverse();
+      instance.hours(Number(timeArr.pop()));
+      instance.minutes(Number(timeArr.pop()));
+      instance.seconds(timeArr.length ? Number(timeArr.pop()) : 0);
+      instance.milliseconds(timeArr.length ? Number(timeArr.pop()) : 0);
+    } else instance = (0, import_moment_timezone.default)("error");
+    return instance;
+  })();
+  if (isReturnAsMomentInstance) return momentInstance;
+  const output = momentInstance.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+function transformDateOrTimeOrTogetherToFormattedLocal(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  if (additional && !getIsOnlyAnObject(additional)) {
+    throw new Error(
+      "Bad additional [transformDateOrTimeOrTogetherToFormattedLocal]"
+    );
+  }
+  const compositeAdditional = {
+    ...additional || {},
+    isReturnAsMomentInstance: true
+  };
+  const date = transformDateOrTimeOrTogetherToFormat(
+    data,
+    outputFormat,
+    compositeAdditional
+  );
+  const dateWithLocale = date.add((0, import_moment_timezone.default)().utcOffset(), "minutes");
+  const output = dateWithLocale.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+var omitKeys = (obj = {}, keys = []) => keys.reduce((acc, key) => {
+  const { [key]: omit, ...rest } = acc;
+  return rest;
+}, obj);
+var logout = () => {
+  window.localStorage.removeItem("accessToken");
+  window.localStorage.removeItem("tokenExpires");
+  window.location.reload();
+};
+var getStyles = (el, prop) => {
+  if (!el) return null;
+  if (!prop) return window.getComputedStyle(el);
+  return window.getComputedStyle(el).getPropertyValue(prop);
+};
+var getColorById = (id, colors) => {
+  if (!id) return "#FF7D00";
+  const idToArr = Array.from(id);
+  const colorsArr = colors && colors.length > 0 ? colors : DEFAULT_COLORS;
+  let number = idToArr.reduce((acc, item) => {
+    if (Number(item)) {
+      return acc + Number(item);
+    }
+    return acc;
+  }, 0);
+  while (number >= colorsArr.length) {
+    number -= colorsArr.length;
+  }
+  return colorsArr[number];
+};
+var debounce = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    clearTimeout(id);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      fn(...args);
+    }, ms);
+  };
+};
+var throttle = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    if (id) return;
+    fn(...args);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      id = null;
+    }, ms);
+  };
+};
+var addBitDepthPoints = (value, step = 3) => {
+  const isFraction = value?.includes(".");
+  const valueBeforeDot = isFraction ? value?.slice(0, value?.indexOf(".")) : value;
+  const intPart = valueBeforeDot.split("").reverse().reduce(
+    (acc, item, idx) => idx % step === 0 && idx !== 0 ? [...acc, ",", item] : [...acc, item],
+    []
+  ).reverse().join("");
+  return isFraction ? intPart + value?.slice(value?.indexOf(".")) : intPart;
+};
+var changeMeta = (key, items = []) => {
+  const defaultMeta = items.find((i) => i.key === "default");
+  if (key) {
+    const item = items.find((i) => i.key === key);
+    document.title = item?.title ?? defaultMeta?.title;
+    document.querySelector('meta[name="description"]').setAttribute("content", item?.description ?? defaultMeta?.description);
+  }
+};
+var firstLetterCapital = (str) => typeof str === "string" ? `${str.charAt(0).toUpperCase()}${str.slice(1)}` : str;
+var capitalized = firstLetterCapital;
+var checkedRef = (ref) => ref ? typeof ref === "function" ? (node) => ref(node) : ref : null;
+function downloadEmulation(data, filename, type = "image/*") {
+  const file = new Blob([data], { type });
+  if (window.navigator.msSaveOrOpenBlob)
+    window.navigator.msSaveOrOpenBlob(file, filename);
+  else {
+    const a = document.createElement("a"), url = URL.createObjectURL(file);
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    }, 0);
+  }
+}
+var downloadFile = async ({ url, name, type = null }) => {
+  const response = await fetch(url).then(async (res) => ({
+    data: await res.blob(),
+    type: type ?? res.headers.get("content-type")
+  }));
+  downloadEmulation(response.data, name, response.type);
+};
+var compare = (first, second, keys = []) => {
+  if (typeof first !== typeof second) return false;
+  if (Array.isArray(first) !== Array.isArray(second)) return false;
+  if (!(first instanceof Object)) return first === second;
+  const getComparationStructure = (data) => {
+    if (typeof data === "function") return data.toString();
+    if (!(data instanceof Object)) return data;
+    return Object.entries(data).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => [key, getComparationStructure(data[key])]);
+  };
+  const structureForComparingOfFirst = getComparationStructure(first);
+  const structureForComparingOfSecond = getComparationStructure(second);
+  return JSON.stringify(structureForComparingOfFirst) === JSON.stringify(structureForComparingOfSecond);
+};
+var setCarretToEnd = (input) => {
+  setTimeout(() => {
+    const tmp = input.value;
+    input.value = "";
+    input.value = tmp;
+  }, 10);
+};
+var compareAlphabetical = (a, b, key = "label") => {
+  let item1 = a?.[key];
+  let item2 = b?.[key];
+  if (typeof item1 !== "string" || typeof item2 !== "string") return 0;
+  item1 = item1?.toLowerCase();
+  item2 = item2?.toLowerCase();
+  if (item1 < item2) {
+    return -1;
+  }
+  if (item1 > item2) {
+    return 1;
+  }
+  return 0;
+};
+var getBase64 = (file) => {
+  if (file) {
+    return new Promise(function(resolve, reject) {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = (error) => reject("Error: ", error);
+    });
+  }
+};
+var renderFileSize = (bytes, decimals = 2) => {
+  if (!Number(bytes)) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var getUniqueFileExtensions = (extListString) => {
+  const extArray = extListString?.split(",").map((ext) => ext.trim().toUpperCase());
+  const uniqueExts = [...new Set(extArray)];
+  return uniqueExts.join(", ");
+};
+var getOS = () => {
+  let userAgent = window.navigator.userAgent, platform = window.navigator?.userAgentData?.platform || window.navigator.platform, macosPlatforms = ["Macintosh", "MacIntel", "MacPPC", "Mac68K"], windowsPlatforms = ["Win32", "Win64", "Windows", "WinCE"], iosPlatforms = ["iPhone", "iPad", "iPod"], os = OS.Unknown;
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = OS.MacOS;
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = OS.iOS;
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = OS.Windows;
+  } else if (/Android/.test(userAgent)) {
+    os = OS.Android;
+  } else if (/Linux/.test(platform)) {
+    os = OS.Linux;
+  }
+  return os;
+};
+String.prototype.longerThan = function(compareWith) {
+  return this?.length > compareWith?.length;
+};
+String.prototype.lastIndexEqualsTo = function(index) {
+  return this?.length - 1 === index;
+};
+var getCorrectTestId = ({ testId = "", withTier = true }) => testId && testId !== void 0 ? `${withTier ? "-" : ""}${testId}` : "";
+
+// src/Functions/fieldValueFormatters.js
+var getSafelyValue = (value) => value !== void 0 && value !== null ? value?.toString?.() || "" : "";
+var intlNumbersFormatter = (inputValue, settings = {}) => {
+  const safelyInputValue = getSafelyValue(inputValue);
+  const previousValue = safelyInputValue.slice(0, -1);
+  const lastSym = safelyInputValue.slice(-1);
+  const value = lastSym === "." ? previousValue : safelyInputValue;
+  if (Number.isNaN(Number(value)) || !getSafelyValue(value)) return "";
+  const {
+    // локаль, даже региональная, влияет на отображение знаков и формата.
+    locale = "en-US",
+    // percent || currency(default case) || decimal(просто число) влияет на ТИП обработки.
+    withSymbol,
+    //группировка запятыми поразрядно.
+    useGrouping = true,
+    //!!работает только при withSymbol: 'currency' !! влияет на то, как именно будет выглядет формат валюты.
+    currency = {},
+    //сколько знаков после точки, и всегда ли они будут.
+    // !!если поставить  isAlwaysRender: true, но не дать центов, то будет 100.00
+    fractionDigits = {}
+  } = settings;
+  const { currencyType = "USD", currencyDisplay: inputCurrencyDisplay } = currency;
+  let currencyDisplay;
+  switch (inputCurrencyDisplay) {
+    case "name":
+      currencyDisplay = "name";
+      break;
+    case "code":
+      currencyDisplay = "code";
+      break;
+    case "narrowSymbol":
+      currencyDisplay = "narrowSymbol";
+      break;
+    default:
+      currencyDisplay = "symbol";
+  }
+  let numberStyle;
+  switch (withSymbol) {
+    case "percent":
+      numberStyle = "percent";
+      break;
+    case "currency":
+      numberStyle = "currency";
+      break;
+    default:
+      numberStyle = "decimal";
+      break;
+  }
+  const {
+    quantity,
+    isRenderAlways = false,
+    minimumFractionDigits: inputMinimumFractionDigits,
+    maximumFractionDigits: inputMaximumFractionDigits,
+    conditionallyMinimumFractionDigits
+  } = fractionDigits;
+  const dotIndex = safelyInputValue?.indexOf(".");
+  const afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : "";
+  const minimumFractionDigits = (() => {
+    if (typeof inputMinimumFractionDigits === "number")
+      return inputMinimumFractionDigits;
+    if (typeof conditionallyMinimumFractionDigits === "number") {
+      return afterDot && lastSym !== "." ? conditionallyMinimumFractionDigits : 0;
+    }
+    return afterDot && lastSym !== "." ? safelyInputValue.slice(dotIndex).length - 1 : isRenderAlways ? quantity : 0;
+  })();
+  const priceSettings = {
+    useGrouping,
+    //группировка разрядов
+    style: numberStyle,
+    //тип форматирования (валюта или число). decimal - без знака валюты
+    currency: currencyType,
+    //валюта
+    currencyDisplay,
+    //валюта в виде символа
+    //минимально не надо отображать центы, если их нет, иначе всегда будет .00
+    minimumFractionDigits,
+    //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+    //! чем указано в (inputMaximumFractionDigits ?? quantity) - округлит по правилам округления
+    //максимально отображать 2 цифры после запятой, если центы всё же есть
+    maximumFractionDigits: inputMaximumFractionDigits ?? quantity
+  };
+  let output;
+  try {
+    output = new Intl.NumberFormat(locale, priceSettings).format(value);
+  } catch (e) {
+    output = value;
+    console.warn("Intl.NumberFormat error", e);
+  }
+  return lastSym === "." ? output + lastSym : output;
+};
+var formatOnlyNumbers = (value) => getSafelyValue(value).replace(/\D/g, "");
+var formatToRemoveComa = (value) => getSafelyValue(value).replace(/,/g, "");
+var formatToAddBitDepthPoints = (value, settings) => intlNumbersFormatter(getSafelyValue(value), {
+  fractionDigits: {
+    quantity: settings?.type === "int" ? 0 : settings?.decimalPlaces
+  }
+});
+var formatToPriceWithUSD = (value) => {
+  if (isNaN(Number(value))) return value;
+  return intlNumbersFormatter(getSafelyValue(value), {
+    withSymbol: "currency",
+    currency: { currencyType: "USD" },
+    fractionDigits: { quantity: 2, conditionallyMinimumFractionDigits: 2 }
+  });
+};
+var formatToPriceWithCurrency = (value, currencyCode, symbolPosition = "before") => {
+  if (isNaN(Number(value))) return value;
+  return intlNumbersFormatter(getSafelyValue(value), {
+    withSymbol: "currency",
+    currency: { currencyType: currencyCode },
+    fractionDigits: { quantity: 2, conditionallyMinimumFractionDigits: 2 }
+  });
+};
+var formatAsPercentage = (value, settings) => {
+  const {
+    isCommonPercentageSymbol = true,
+    decimalPlaces = 2,
+    beforeValueSymbol = "",
+    afterValueSymbol = "",
+    isGlueSameRangesTogether = false,
+    // ? Тут удобный ф-л, поэтому иной раз удобно обработать обычный диапазан (НЕ проценты).
+    // ? Добавил возможность выпиливать значек процентов.
+    // todo(VL) - вообще правильно заренеймить (formatAsDiapason), а добавление процентов сделать как опцию,
+    // todo(VL) - но как обычно нет времени, нужно будет перечекать по всем проектам где тянется со старым неймингом
+    isUseAsSimpleDiapason = false
+  } = getIsOnlyAnObject(settings) ? settings : {};
+  let safelyInputValue;
+  const checkValue = (value2) => getSafelyValue(value2) || "0";
+  const transform = (valueAsSting) => {
+    const processedValue = valueAsSting.replace(/,/g, ".");
+    if (Number.isNaN(Number(processedValue))) return processedValue;
+    return `${intlNumbersFormatter(getSafelyValue(Number(processedValue)), {
+      fractionDigits: {
+        quantity: decimalPlaces,
+        minimumFractionDigits: decimalPlaces
+      }
+    })}`;
+  };
+  if (getIsOnlyAnObject(value)) {
+    safelyInputValue = {
+      from: checkValue(value.from),
+      to: checkValue(value.to)
+    };
+  } else {
+    safelyInputValue = checkValue(value);
+    if (safelyInputValue.includes(" - ")) {
+      const valuesArr = safelyInputValue.split(" - ").map((partOfValue) => partOfValue.trim());
+      safelyInputValue = {
+        from: checkValue(valuesArr[0]),
+        to: checkValue(valuesArr[1])
+      };
+    } else {
+      return `${beforeValueSymbol}${transform(safelyInputValue)}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+    }
+  }
+  if (safelyInputValue.from === safelyInputValue.to && !!isGlueSameRangesTogether) {
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+  }
+  if (isCommonPercentageSymbol)
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)} - ${transform(
+      safelyInputValue.to
+    )}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+  else
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)}${isUseAsSimpleDiapason ? "" : "%"} - ${transform(
+      safelyInputValue.to
+    )}${isUseAsSimpleDiapason ? "" : "%"}${afterValueSymbol}`;
+};
+var formatToOnlyASCIICodeText = (text) => getSafelyValue(text).replace(/[^\x00-\x7F]+/g, "");
+var formatNumberValueToMask = (inputValue, settings) => {
+  const safelyInputValue = getSafelyValue(inputValue);
+  const {
+    mask = "XXX-XXX-XXXX",
+    valueSymbol = "X",
+    isReturnAdvanced = false
+  } = settings || {};
+  const processing = mask.split("").reduce(
+    (acc, item) => {
+      if (acc.value.length) ++acc.cursorPosition;
+      acc.newValue.push(
+        item === valueSymbol && acc.value.length ? acc.value.shift() : item
+      );
+      return acc;
+    },
+    {
+      value: safelyInputValue.split("").filter((sym) => /[0-9]/g.test(sym)),
+      newValue: [],
+      cursorPosition: 0
+    }
+  );
+  return isReturnAdvanced ? {
+    value: processing.newValue.join(""),
+    cursorPosition: processing.cursorPosition
+  } : processing.newValue.join("");
+};
+var formatToLimitLength = (inputValue, limit) => {
+  const value = getSafelyValue(inputValue);
+  return limit && typeof limit === "number" && !Number.isNaN(limit) && value?.length > limit ? value.substr(0, limit) : value;
+};
+var formatToHex = ({ inputValue, withSharp }) => {
+  const value = getSafelyValue(inputValue);
+  if (withSharp) return `#${value.replace(/[^a-f0-9]/gi, "")}`;
+  return `${value.replace(/[^#a-f0-9]/gi, "")}`;
+};
+function formatToReplaceAllWhiteSpace(str) {
+  const value = getSafelyValue(str);
+  return value.replace(/\s+/g, "");
+}
+var filterFloat = (inputValue, decimalPlaces) => {
+  const replaser = (input) => ("" + input).replace(/[^\.\d]/g, "");
+  const value = getSafelyValue(inputValue);
+  const safelyDecimalPlaces = (() => {
+    if (decimalPlaces === null) return decimalPlaces;
+    const DEFAULT_VALUE = 2;
+    const isNumber = typeof decimalPlaces === "number" || typeof decimalPlaces === "string" && !Number.isNaN(+decimalPlaces);
+    return isNumber ? Number((+decimalPlaces).toFixed()) : DEFAULT_VALUE;
+  })();
+  if (value.length === 1 && (value[0] === "." || value[0] === ",")) return "0.";
+  let output = ("" + value)?.replace(/,/g, ".");
+  if (value.length > 1 && value[0] === "0" && value[1] !== "." && value[0] !== ",") output = value.slice(1);
+  const previousValue = "" + output.slice(0, -1);
+  const lastSym = "" + output.slice(-1);
+  if (lastSym === "." && previousValue.includes(".")) output = previousValue;
+  if (typeof safelyDecimalPlaces === "number") {
+    if (!safelyDecimalPlaces && lastSym === ".") return replaser(previousValue);
+    if (previousValue.includes(".") && previousValue.indexOf(".") + 1 + safelyDecimalPlaces === previousValue?.length) {
+      return replaser(previousValue);
+    }
+  }
+  return replaser(output);
+};
+var filterNumeric = (value, settings) => {
+  value = getSafelyValue(value)?.replace(/,/g, "");
+  const { type = "float", decimalPlaces } = settings || {};
+  const executor = type === "float" ? filterFloat : formatOnlyNumbers;
+  return executor(getSafelyValue(value), decimalPlaces);
+};
+var formatToHideValuePartially = (value, settings) => {
+  const {
+    showSymbolsCount = 4,
+    isVisibleFromFront = false,
+    isCutOutWhiteSpaces = true
+  } = settings || {};
+  const safelyValue = getSafelyValue(value);
+  const newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, "") : safelyValue;
+  if (newValue.length <= showSymbolsCount) return newValue;
+  const hide = (val) => val.split("").map(() => "*").join("");
+  const visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
+  const hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
+  return isVisibleFromFront ? `${visiblePart}${hide(hiddenPart)}` : `${hide(hiddenPart)}${visiblePart}`;
+};
+
+// src/Functions/hooks/useFormFieldsChangesManager.js
+var import_react2 = __toESM(require("react"), 1);
+var timeouts = { timeoutId: null };
+var formChanges = [];
+var DELAY_TIME = 1;
+function useFormFieldsChangesManager({ form, setForm, callback, validateField, settings }) {
+  const { isNotSetForm, isUseValidation = false } = settings || {};
+  const [isFormMustBeChanget, setIsFormMustBeChanget] = (0, import_react2.useState)(false);
+  const startChangesProcessing = () => {
+    if (isFormMustBeChanget) return;
+    setIsFormMustBeChanget(true);
+  };
+  const assignChangesToField = /* @__PURE__ */ (() => {
+    return (data, key, settings2) => {
+      clearTimeout(timeouts.timeoutId);
+      if (getIsOnlyAnObject(data) || typeof data === "function") {
+        formChanges.push({ key, data, settings: settings2 });
+      }
+      setIsFormMustBeChanget(false);
+      timeouts.timeoutId = setTimeout(() => setIsFormMustBeChanget(true), DELAY_TIME);
+      return clone(formChanges);
+    };
+  })();
+  const addChangesToField = (field, data, currentForm, currentChangesSettings) => {
+    const changesDataSafely = (() => {
+      if (typeof data === "function") return data(field, currentForm, currentChangesSettings);
+      return getIsOnlyAnObject(data) ? data : {};
+    })();
+    const { error } = changesDataSafely;
+    return { newField: { ...field, ...changesDataSafely }, ...error !== void 0 ? { error } : {} };
+  };
+  const changeForm = async () => {
+    let modifiedFormFromOutside;
+    const errorsFromChanges = {};
+    const newForm = formChanges.reduce((acc, changesItem) => {
+      const { data, key, settings: settings2 } = changesItem;
+      const field = acc.find((field2) => field2.key === key);
+      if (field) {
+        acc = acc.map((field2) => {
+          if (field2.key !== key) return field2;
+          const { newField, error } = addChangesToField(field2, data, acc, settings2);
+          if (error || error !== void 0) errorsFromChanges[key] = error;
+          return newField;
+        });
+      }
+      return acc;
+    }, form);
+    const validatedForm = isUseValidation && typeof validateField === "function" ? newForm.map((field) => ({
+      ...field,
+      error: (() => {
+        let output = "";
+        const validateFieldResult = validateField({ ...field }, newForm);
+        if (validateFieldResult?.field?.error !== void 0) output = validateFieldResult.field.error;
+        else if (errorsFromChanges[field.key] !== void 0) output = errorsFromChanges[field.key];
+        return output;
+      })()
+    })) : newForm;
+    if (callback && typeof callback === "function") modifiedFormFromOutside = await callback(validatedForm);
+    if (!isNotSetForm) await setForm(modifiedFormFromOutside ?? validatedForm);
+    formChanges.length = 0;
+    setIsFormMustBeChanget(false);
+  };
+  (0, import_react2.useEffect)(() => {
+    if (isFormMustBeChanget) changeForm();
+  }, [isFormMustBeChanget]);
+  return {
+    assignChangesToField,
+    // метод установки отложенных изменений
+    isFormMustBeChanget,
+    // флаг сработки непосредственных мутаций формы
+    // метод принудительной установки флага сработки непосредственных мутаций формы
+    // работает только на включения, НЕ включает, если уже отрабатывает применение
+    startChangesProcessing,
+    // todo(vl) - deprecated, но пока не выпиливаю, не проверил используется ли на проектах
+    setIsFormMustBeChanget: startChangesProcessing,
+    // метод принудительной установки флага сработки непосредственных мутаций формы
+    changesArray: clone(formChanges),
+    // теккущее состояние массива изменений
+    // Константа (на чтение) задержки, которая выжидается между назначениями,
+    // после которой отрабатывает установка накопившихся изменений в форму
+    DELAY_TIME
+  };
+}
+var useFormFieldsChangesManager_default = useFormFieldsChangesManager;
+
+// src/Functions/locale/createTranslator.js
+var DEFAULT_CODE = "en";
+function createTranslator({ ...langCatalogs }) {
+  const loc = {
+    ...langCatalogs
+  };
+  let code = window.localStorage.getItem("lng");
+  if (!code)
+    code = window.navigator ? window.navigator.language.split("-")[0] : DEFAULT_CODE;
+  if (!loc[code]) code = DEFAULT_CODE;
+  return function(text, values) {
+    const safelyValues = values ?? {};
+    const safelyText = getSafelyValue(text);
+    let translatedText = loc[code] && loc[code][safelyText] ? loc[code][safelyText] : safelyText;
+    if (Object?.keys(safelyValues)?.length) {
+      for (const key in values) {
+        const regex = new RegExp(`%${key}%`, "g");
+        translatedText = translatedText?.replace(regex, values[key]);
+      }
+    }
+    return translatedText;
+  };
+}
+
+// src/Functions/operations.js
+(function() {
+  function decimalAdjust(type, value, exp) {
+    if (typeof exp === "undefined" || Number(exp) === 0) {
+      return Math[type](value);
+    }
+    value = Number(value);
+    exp = Number(exp);
+    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
+      return NaN;
+    }
+    value = value.toString().split("e");
+    value = Math[type](
+      Number(value[0] + "e" + (value[1] ? Number(value[1]) - exp : -exp))
+    );
+    value = value.toString().split("e");
+    return Number(value[0] + "e" + (value[1] ? Number(value[1]) + exp : exp));
+  }
+  if (!Math.round10) {
+    Math.round10 = function(value, exp) {
+      return decimalAdjust("round", value, exp);
+    };
+  }
+  if (!Math.floor10) {
+    Math.floor10 = function(value, exp) {
+      return decimalAdjust("floor", value, exp);
+    };
+  }
+  if (!Math.ceil10) {
+    Math.ceil10 = function(value, exp) {
+      return decimalAdjust("ceil", value, exp);
+    };
+  }
+})();
+var addRangeDefault = (from, to, currentValues, decimalPlaces) => {
+  if (!currentValues?.length) return [{ from, to }];
+  const step = decimalPlaces ? Math.pow(10, -1 * decimalPlaces) : 1;
+  const resultOfProcessAddingRange = currentValues.reduce(
+    (acc, range) => {
+      const isIncludesFrom = Boolean(acc.from) && range.from < acc.from && range.to >= acc.from;
+      const isIncludesTo = Boolean(acc.to) && range.from <= acc.to && range.to > acc.to;
+      const isRangeMustBeIncludet = Boolean(acc.from) && Boolean(acc.to) && acc.from <= range.from && acc.to >= range.to;
+      const processTo = () => {
+        const lastAccRange = acc.result[acc.result.length - 1];
+        if (acc.to < range.from) {
+          lastAccRange.to = acc.to;
+          acc.to = null;
+          acc.result = [...acc.result, range];
+        } else if (isIncludesTo) {
+          lastAccRange.to = acc.to;
+          acc.result = [
+            ...acc.result,
+            {
+              from: Math.round10(acc.to + step, -1 * decimalPlaces),
+              to: range.to
+            }
+          ];
+          acc.to = null;
+        } else if (acc.to === range.to) {
+          lastAccRange.to = acc.to;
+          acc.to = null;
+        }
+      };
+      if (!acc.from && !acc.to) acc.result = [...acc.result, range];
+      else if (!acc.from && acc.to) processTo();
+      else if (acc.from && acc.to) {
+        if (acc.from <= range.from) {
+          acc.result = [...acc.result, { from: acc.from }];
+          acc.from = null;
+          processTo();
+        } else if (isIncludesFrom) {
+          acc.result = [
+            ...acc.result,
+            {
+              from: range.from,
+              to: Math.round10(acc.from - step, -1 * decimalPlaces)
+            },
+            { from: acc.from }
+          ];
+          acc.from = null;
+          processTo();
+        } else {
+          acc.result = [
+            ...acc.result,
+            ...!isRangeMustBeIncludet ? [range] : [],
+            {
+              from: Math.round10(acc.from, -1 * decimalPlaces),
+              to: Math.round10(acc.to, -1 * decimalPlaces)
+            }
+          ];
+        }
+      }
+      return acc;
+    },
+    { from, to, result: [] }
+  );
+  const result = resultOfProcessAddingRange.result;
+  if (!result[result.length - 1].to) result[result.length - 1].to = to;
+  return result;
+};
+
+// src/Functions/Portal.js
+var import_react3 = __toESM(require("react"), 1);
+var import_react_dom = __toESM(require("react-dom"), 1);
+var Portal = ({ children, parentSelector }) => {
+  const [container] = (0, import_react3.useState)(() => document.createElement("div"));
+  (0, import_react3.useEffect)(() => {
+    let parent;
+    if (parentSelector) parent = document.querySelector(parentSelector);
+    else parent = document.body;
+    parent?.appendChild(container);
+    return () => {
+      parent?.removeChild(container);
+    };
+  }, []);
+  return import_react_dom.default.createPortal(children, container);
+};
+var Portal_default = import_react3.default.memo(Portal);
+
+// src/Functions/useBodyScrollLock.js
+var import_react4 = require("react");
+var useBodyScrollLock = (isScrollBodyLocked) => {
+  (0, import_react4.useEffect)(() => {
+    if (isScrollBodyLocked) {
+      document.body.style.overflow = "hidden";
+    } else {
+      document.body.style.overflow = "auto";
+    }
+    return () => {
+      document.body.style.overflow = "auto";
+    };
+  }, [isScrollBodyLocked]);
+};
+var useBodyScrollLock_default = useBodyScrollLock;
+
+// src/Functions/useClickOutside.js
+var import_react5 = require("react");
+var useClickOutside = (ref, setOut, open) => {
+  function handleClickOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  (0, import_react5.useEffect)(() => {
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [ref]);
+};
+
+// src/Functions/useDebounce.js
+var import_react6 = __toESM(require("react"), 1);
+var useDebounce = ({ searchValue, delay }) => {
+  const [debouncedValue, setDebouncedValue] = (0, import_react6.useState)(searchValue);
+  (0, import_react6.useEffect)(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(searchValue);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [searchValue, delay]);
+  return debouncedValue;
+};
+
+// src/Functions/useFieldFocus.js
+var import_react7 = require("react");
+function useFieldsFocus({ form, setForm }) {
+  const isFormAsObject = Boolean(
+    typeof form === "object" && !Array.isArray(form)
+  );
+  const getField = (key) => {
+    if (isFormAsObject) {
+      return form?.[key] ?? Object.values(form)?.find((field) => field.key === key);
+    } else {
+      return form?.find((field) => field.key === key);
+    }
+  };
+  const getErroredFields = () => {
+    if (isFormAsObject) {
+      return Object.values(form)?.filter((field) => field.error);
+    } else {
+      return form?.filter((f) => f?.error);
+    }
+  };
+  const addRefsToFields = () => {
+    if (isFormAsObject) {
+      setForm((form2) => {
+        return Object.keys(form2)?.reduce((result, key) => {
+          const field = form2[key];
+          return {
+            ...result,
+            [key]: {
+              ...field,
+              ref: (0, import_react7.createRef)(),
+              wrapperRef: (0, import_react7.createRef)()
+            }
+          };
+        }, {});
+      });
+    } else {
+      setForm((form2) => {
+        return form2?.map((field) => {
+          field.ref = (0, import_react7.createRef)();
+          field.wrapperRef = (0, import_react7.createRef)();
+          return field;
+        });
+      });
+    }
+  };
+  const toggleFieldFocus = ({ field, action = "focus" }) => {
+    if (!field || !field?.ref) return null;
+    setTimeout(() => {
+      field.ref.current?.querySelector(field?.focusSelector || "input")?.[action]();
+    }, 50);
+  };
+  const setFocusTo = (key) => {
+    const field = getField(key);
+    if (!field) return false;
+    toggleFieldFocus({ field });
+  };
+  const setFocusToErroredField = () => {
+    const field = getErroredFields()?.[0];
+    if (!field) return false;
+    toggleFieldFocus({ field });
+  };
+  (0, import_react7.useEffect)(() => {
+    addRefsToFields();
+  }, [form?.length]);
+  return {
+    setFocusTo,
+    setFocusToErroredField
+  };
+}
+
+// src/Functions/useFormTools/functions/General.js
+function General({ form, FormFields = [] } = {}) {
+  const joinData = (...args) => {
+    const [mainArg] = args;
+    const MainArgProto = Array.isArray(mainArg) ? "Array" : typeof mainArg === "object" ? "Object" : void 0;
+    const template = Array.isArray(mainArg) ? [] : typeof mainArg === "object" ? {} : null;
+    if (!template) return void 0;
+    return args.reduce((result, item) => {
+      if (MainArgProto === "Array") {
+        if (Array.isArray(item)) {
+          return [...result, ...item];
+        } else {
+          return [...result, item];
+        }
+      } else if (MainArgProto === "Object") {
+        return { ...result, ...item };
+      } else {
+        return template;
+      }
+    }, template);
+  };
+  const getFieldData = (key) => {
+    if (Array.isArray(FormFields)) {
+      if (FormFields[key]) {
+        return { ...FormFields[key] };
+      } else {
+        return { ...FormFields.find((f) => f.key === key) };
+      }
+    } else if (typeof FormFields === "object") {
+      return { ...FormFields[key] };
+    } else {
+      return void 0;
+    }
+  };
+  const getFormFields = (argForm = form) => {
+    return argForm?.fields || argForm;
+  };
+  const getFormFieldsAsArray = (fields) => {
+    if (Array.isArray(fields)) return fields;
+    if (typeof fields === "object") {
+      return Object.values(fields);
+    }
+    return fields;
+  };
+  const getFormFieldsKeys = (fields = getFormFields()) => {
+    if (Array.isArray(fields)) return fields.map(({ key }) => key);
+    if (typeof fields === "object") {
+      return Object.values(fields).map(({ key }) => key);
+    }
+    return fields;
+  };
+  const popFormField = (fields, key) => {
+    const result = { item: void 0, itemIndex: void 0 };
+    if (Array.isArray(fields)) {
+      result.item = fields?.find((f) => f.key === key);
+      result.itemIndex = result.item ? fields.findIndex((f) => f.key === key) : fields.length;
+    } else if (typeof fields === "object") {
+      result.item = fields[key] || Object.values(fields).find((f) => f.key === key);
+      result.itemIndex = result.item ? fields[key] ? key : Object.values(fields).findIndex((f) => f.key === key) : key;
+    }
+    return result;
+  };
+  const updateFormField = (fields, data, key) => {
+    const isFunction = typeof data === "function";
+    if (!key) {
+      return data.key ? Object.values(fields).reduce((result, field2, i) => {
+        const index = fields[field2.key] ? field2.key : i;
+        return {
+          ...result,
+          [index]: data.key === field2.key ? isFunction ? data(field2) : data : field2
+        };
+      }, {}) : {
+        ...fields,
+        [fields.length || 0]: isFunction ? data({}) : data
+      };
+    }
+    const { item: field = data, itemIndex } = popFormField(fields, key);
+    fields[itemIndex] = isFunction ? data(field || {}) : { ...field, ...data };
+    return fields;
+  };
+  const getFieldClassName = (key, type) => {
+    return `form-${type}_field-${key}`;
+  };
+  return {
+    joinData,
+    getFieldData,
+    popFormField,
+    updateFormField,
+    getFormFields,
+    getFormFieldsAsArray,
+    getFieldClassName,
+    getFormFieldsKeys
+  };
+}
+
+// src/Functions/useFormTools/form-drivers/ArrayWithObjects.js
+function ArrayWithObjects({ form, setForm, FormFields }) {
+  const {
+    joinData,
+    getFieldData,
+    updateFormField,
+    getFormFields,
+    getFormFieldsAsArray,
+    getFormFieldsKeys
+  } = General({
+    FormFields
+  });
+  const getFormField = (key, argForm = form) => {
+    return getFormFields(argForm)?.find((f) => f.key === key);
+  };
+  const setFormFields = (data) => {
+    const isFunction = typeof data === "function";
+    setForm((state) => isFunction ? data(state) : data);
+  };
+  const setFormField = (data, key = null) => setFormFields((fields) => updateFormField(fields, data, key));
+  const removeAllFormFields = () => setFormFields([]);
+  return {
+    joinData,
+    getFieldData,
+    getFormFields,
+    getFormField,
+    setFormFields,
+    setFormField,
+    getFormFieldsAsArray: (fields) => getFormFieldsAsArray(fields || getFormFields()),
+    getFormFieldsKeys: (fields) => getFormFieldsKeys(fields || getFormFields()),
+    removeAllFormFields
+  };
+}
+
+// src/Functions/useFormTools/form-drivers/ObjectWithIterableObjects.js
+function ObjectWithIterableObjects({
+  form,
+  setForm,
+  FormFields
+}) {
+  const joinData = (...args) => {
+    const [mainArg] = args;
+    const MainArgProto = Array.isArray(mainArg) ? "Array" : typeof mainArg === "object" ? "Object" : void 0;
+    const template = Array.isArray(mainArg) ? [] : typeof mainArg === "object" ? {} : null;
+    if (!template) return void 0;
+    return args.reduce((result, item) => {
+      if (MainArgProto === "Array") {
+        if (Array.isArray(item)) {
+          return [...result, ...item];
+        } else {
+          return [...result, item];
+        }
+      } else if (MainArgProto === "Object") {
+        return { ...result, ...item };
+      } else {
+        return template;
+      }
+    }, template);
+  };
+  const getFieldData = (key) => {
+    if (Array.isArray(FormFields)) {
+      return FormFields[key] || FormFields.find((f) => f.key === key);
+    } else if (typeof FormFields === "object") {
+      return FormFields[key] || Object.values(FormFields).find((f) => f.key === key);
+    } else {
+      return void 0;
+    }
+  };
+  const getFormFields = () => {
+    return form.fields || form;
+  };
+  const getFormField = (key) => {
+    if (FormProto === "Array") {
+      return getFormFields().find((field) => field.key === key);
+    } else if (FormProto === "Object") {
+      return Object.values(getFormFields()).find((field) => field.key === key) || Object.keys(getFormFields()).reduce((result, field) => {
+        if (field === key) result = getFormFields()[field];
+        return result;
+      }, {});
+    } else {
+      return void 0;
+    }
+  };
+  const setFormFields = (data) => {
+    const isFunction = typeof data === "function";
+    setForm((state) => {
+      if (state.fields) {
+        return {
+          ...state,
+          fields: isFunction ? data(state.fields) : data
+        };
+      } else {
+        return isFunction ? data(state) : data;
+      }
+    });
+  };
+  const setFormField = (data, key = null) => {
+    const isFunction = typeof data === "function";
+    setFormFields((fields) => {
+      const pop = (fields2, key2) => {
+        const result = { fields: fields2, item: void 0 };
+        result.item = fields2[key2] || fields2.find((f) => f.key === key2);
+        if (!result.item) return result;
+        if (Array.isArray(fields2)) {
+          const index = parseInt(key2, 10);
+          if (!isNaN(index)) {
+            result.fields.splice(key2, 1);
+          } else {
+            result.fields = result.fields.filter((f) => f.key !== key2);
+          }
+        } else if (typeof fields2 === "object") {
+          result.fields = Object.values(fields2).reduce(
+            (object, { key: fKey }) => {
+              if (key2 !== fKey) {
+                object[key2] = fields2[key2];
+              }
+              return object;
+            },
+            {}
+          );
+        }
+        return result;
+      };
+      const update = (fields2) => {
+        if (!key) {
+          return data.key ? Object.values(fields2).reduce((result, field2, i) => {
+            const index = fields2[field2.key] ? field2.key : i;
+            return {
+              ...result,
+              [index]: data.key === field2.key ? isFunction ? data(field2) : data : field2
+            };
+          }, {}) : {
+            ...fields2,
+            [fields2.length || 0]: isFunction ? data({}) : data
+          };
+        }
+        const { fields: filtered, item: field } = pop(fields2, key);
+        const updatedField = isFunction ? data(field || {}) : { ...field, ...data };
+        return joinData(
+          filtered,
+          fields2[key] ? { [key]: updatedField } : updatedField
+        );
+      };
+      return update(fields);
+    });
+  };
+  return {
+    joinData,
+    getFieldData,
+    getFormFields,
+    getFormField,
+    setFormFields,
+    setFormField
+  };
+}
+
+// src/Functions/useFormTools/form-drivers/ObjectWithNamedKeyObjects.js
+var noop = () => {
+};
+function ObjectWithNamedKeyObjects({
+  form,
+  setForm = noop,
+  FormFields
+} = {}) {
+  const {
+    joinData,
+    getFieldData,
+    updateFormField,
+    getFormFields,
+    getFormFieldsAsArray,
+    getFormFieldsKeys
+  } = General({
+    FormFields
+  });
+  const getFormField = (key, argForm = form) => {
+    return Object.values(getFormFields(argForm))?.find(
+      (field) => field?.key === key
+    ) || Object.keys(getFormFields(argForm))?.reduce((result, field) => {
+      if (field === key) result = getFormFields(argForm)[field];
+      return result;
+    }, null);
+  };
+  const setFormFields = (data) => {
+    const isFunction = typeof data === "function";
+    setForm((state) => {
+      if (state.fields) {
+        return {
+          ...state,
+          fields: isFunction ? data(state.fields) : data
+        };
+      } else {
+        return isFunction ? data(state) : data;
+      }
+    });
+  };
+  const setFormField = (data, key = null) => setFormFields((fields) => updateFormField(fields, data, key));
+  const removeAllFormFields = () => setFormFields({});
+  const removeFormField = (key) => setFormFields(
+    (state) => Object.keys(state).filter((fKey) => fKey !== key).reduce((obj, key2) => ({ ...obj, [key2]: state[key2] }), {})
+  );
+  const removeFormFields = ([...keys]) => setFormFields(
+    (state) => Object.keys(state).filter((fKey) => !keys.includes(fKey)).reduce((obj, key) => ({ ...obj, [key]: state[key] }), {})
+  );
+  return {
+    joinData,
+    getFieldData,
+    getFormField,
+    setFormFields,
+    setFormField,
+    getFormFields: () => getFormFields(form),
+    getFormFieldsAsArray: () => getFormFieldsAsArray(getFormFields(form)),
+    getFormFieldsKeys: () => getFormFieldsKeys(getFormFields(form)),
+    removeAllFormFields,
+    removeFormField,
+    removeFormFields
+  };
+}
+
+// src/Functions/useFormTools/functions/RenderFields.js
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultRenderFieldComponent = () => {
+  console.error("RenderFields: RenderFieldComponent Property is not recieved!");
+  return null;
+};
+var defaultFormDataDriver = () => {
+  console.error("RenderFields: FormDataDriver Property is not recieved!");
+  return null;
+};
+var defaultOnFieldChange = () => {
+  console.warn(
+    "RenderFields: Be careful, onFieldChange handler is not recieved!"
+  );
+  return null;
+};
+var defaultOnFieldBlur = () => {
+  console.warn(
+    "RenderFields: Be careful, defaultOnFieldBlur handler is not recieved!"
+  );
+  return null;
+};
+function RenderFields({
+  form,
+  fields,
+  cols = 1,
+  FormDataDriver = defaultFormDataDriver,
+  RenderFieldComponent = defaultRenderFieldComponent,
+  onFieldChange = defaultOnFieldChange,
+  onFieldBlur = defaultOnFieldBlur
+} = {}) {
+  const maxColumns = 6;
+  const maxWidth = 12;
+  const { getFormField } = FormDataDriver({ form });
+  const getColumnsQty = () => {
+    return cols > maxColumns ? maxColumns : cols;
+  };
+  const renderFormField = (key) => {
+    try {
+      const field = { ...getFormField(key), key };
+      const { wrapperRef } = field;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "div",
+        {
+          id: `render-field-wrapper-${key}`,
+          ref: wrapperRef ? typeof wrapperRef === "function" ? (node) => wrapperRef(node, key) : wrapperRef : null,
+          children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            RenderFieldComponent,
+            {
+              field,
+              onChange: (value) => onFieldChange(key, value),
+              onBlur: (...args) => onFieldBlur(...args)
+            },
+            key
+          )
+        },
+        `render-field-wrapper-${key}`
+      );
+    } catch (e) {
+      return null;
+    }
+  };
+  const renderSingleColumn = () => {
+    return fields.map(renderFormField);
+  };
+  const renderSplitColumns = () => {
+    const fieldsLen = fields?.length || 0;
+    const columnsQty = getColumnsQty() > fieldsLen ? fieldsLen : getColumnsQty();
+    if (!columnsQty) return null;
+    const parts = new Array(columnsQty).fill([]).map((v, i) => {
+      const startIndex = fieldsLen / columnsQty * i;
+      const endIndex = startIndex + fieldsLen / columnsQty;
+      return fields.slice(startIndex, endIndex);
+    });
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "row", children: parts.map((part, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        className: `col-12 col-lg-${parseInt(maxWidth / columnsQty, 10)}`,
+        children: part.map(renderFormField)
+      },
+      `render-fields-row-${i}`
+    )) });
+  };
+  const render = cols === 1 ? renderSingleColumn : renderSplitColumns;
+  return render();
+}
+
+// src/Functions/useFormTools/index.js
+var import_react8 = require("react");
+var DefaultFocusControllerProps = {
+  setAutoFocus: true,
+  onlyEmptyFieldAutoFocus: false
+};
+function useFormTools({
+  form,
+  setForm,
+  FormType,
+  FormFields,
+  FormDataDriverName = "ArrayWithObjects",
+  FormDataDriver = null,
+  FocusControllerProps = DefaultFocusControllerProps,
+  goToNextFieldOnEnterPressed = true
+} = {}) {
+  FocusControllerProps = {
+    ...DefaultFocusControllerProps,
+    ...FocusControllerProps
+  };
+  const FormDataDrivers = {
+    ArrayWithObjects: {
+      handlers: ArrayWithObjects,
+      default: true
+    },
+    ObjectWithIterableObjects: {
+      handlers: ObjectWithIterableObjects
+    },
+    ObjectWithNamedKeyObjects: {
+      handlers: ObjectWithNamedKeyObjects
+    }
+  };
+  const getFormDataDriver = (name) => {
+    return FormDataDriver || FormDataDrivers[name]?.handlers || Object.values(FormDataDrivers).find((df) => df.default === true)?.handlers || (() => ({}));
+  };
+  const getFormDataDriverInstance = (name, ...args) => {
+    return getFormDataDriver(name)(...args);
+  };
+  const { getFieldClassName, updateFormField } = General();
+  const {
+    getFieldData,
+    getFormField,
+    setFormFields,
+    setFormField,
+    getFormFieldsAsArray,
+    getFormFieldsKeys,
+    removeAllFormFields,
+    removeFormField,
+    removeFormFields
+  } = getFormDataDriverInstance(FormDataDriverName, {
+    form,
+    setForm,
+    FormFields
+  });
+  const [onChangeObservers, setOnChangeObservers] = (0, import_react8.useState)({});
+  const addOnChangeObserver = (key, cb) => {
+    let observerId = null;
+    setOnChangeObservers((state) => {
+      if (!state[key]) state[key] = {};
+      observerId = state[key].length;
+      state[key][observerId] = cb;
+      return state;
+    });
+    return observerId;
+  };
+  const removeOnChangeObserver = (key, id) => {
+    setOnChangeObservers((state) => {
+      if (!state[key]) return state;
+      state[key] = Object.keys(state).filter((cbId) => cbId !== id).map((cbId) => state[key][cbId]);
+      return state;
+    });
+  };
+  const onChangeObserver = (key, value) => {
+    if (!onChangeObservers[key] || typeof onChangeObservers[key] !== "object")
+      return;
+    const Observers = onChangeObservers[key];
+    Object.values(Observers).map((cb) => {
+      cb({ value, form });
+      return null;
+    });
+  };
+  const onFieldChange = (key, value) => {
+    if (value === getFormField(key)?.value) return false;
+    onChangeObserver(key, value);
+    setFormField(
+      (field) => ({
+        ...field,
+        error: "",
+        value
+      }),
+      key
+    );
+  };
+  const [formSubmitBlockers, setFormSubmitBlockers] = (0, import_react8.useState)([]);
+  const toggleFormSubmitBlock = (key, value) => {
+    setFormSubmitBlockers(
+      (state) => state.includes(key) || !value ? [...state.filter((k) => k !== key)] : [...state, key]
+    );
+  };
+  const clearFormSubmitBlockers = () => setFormSubmitBlockers([]);
+  const [isFormFieldsAdded, setIsFormFieldsAdded] = (0, import_react8.useState)(false);
+  const [renderFormFields, setRenderFormFieldsState] = (0, import_react8.useState)([]);
+  const setRenderFormFields = (data) => {
+    setIsFormFieldsAdded(true);
+    removeRenderFields(renderFormFields);
+    resetIsInitFocused();
+    setRenderFormFieldsState(data);
+  };
+  const addRenderFields = (fields) => {
+    setRenderFormFieldsState((state) => [...state, ...fields]);
+  };
+  const removeRenderFields = (fields) => {
+    setRenderFormFieldsState(
+      (state) => state.filter((field) => !fields.includes(field))
+    );
+  };
+  const [isFormRendered, setIsFormRendered] = (0, import_react8.useState)(false);
+  const submitIsFormRendered = () => setIsFormRendered(true);
+  const resetIsFormRendered = () => setIsFormRendered(false);
+  const onEnterDown = async (e) => {
+    if (!goToNextFieldOnEnterPressed) return false;
+    const focusable = document.querySelectorAll(
+      'a, button, input, [tabindex]:not([tabindex="-1"])'
+    );
+    const currentIndex = await new Promise((resolve) => {
+      focusable.forEach((node, i) => {
+        if (node === e.target) resolve(i);
+      });
+    });
+    if (!currentIndex) return false;
+    const nextIndex = currentIndex + 1;
+    if (nextIndex >= focusable.length) return false;
+    const nextItem = focusable[nextIndex];
+    nextItem.focus();
+  };
+  const onKeyDown = (...args) => {
+    const event = args.reduce((e, item) => {
+      if (item?.nativeEvent instanceof KeyboardEvent) return item;
+      return e;
+    }, null);
+    if (!event) return false;
+    const { keyCode } = event;
+    switch (keyCode) {
+      //OnEnterDown
+      case 13:
+        onEnterDown(event);
+        break;
+      default:
+        break;
+    }
+  };
+  (0, import_react8.useEffect)(() => {
+    resetIsFormRendered();
+  }, [FormType]);
+  (0, import_react8.useEffect)(() => {
+    if (isFormFieldsAdded) resetIsFormRendered(false);
+    if (renderFormFields.length !== 0) {
+      setFormFields((fields) => {
+        return renderFormFields.reduce((result, key) => {
+          const fieldData = getFieldData(key);
+          const field = getFormField(key) ? getFormField(key) : fieldData;
+          if (!field?.className || field?.className?.indexOf(getFieldClassName(key, FormType)) === -1) {
+            field.className = `${field?.className} ${getFieldClassName(key, FormType)}`;
+          }
+          if (typeof fieldData?.label === "object") {
+            field.label = fieldData.label[FormType] || fieldData.label.default;
+          }
+          field.ref = (0, import_react8.createRef)();
+          field.wrapperRef = (0, import_react8.createRef)();
+          field.isValueChangedByUser = false;
+          if (goToNextFieldOnEnterPressed) {
+            const onKeyDownProp = field.onKeyDown || (() => {
+            });
+            field.onKeyDown = (...args) => {
+              onKeyDown(...args);
+              onKeyDownProp(...args);
+            };
+          }
+          addOnFieldRenderedObserver(
+            key,
+            () => {
+              const element = getFormField(key)?.ref?.current?.querySelector(
+                field?.focusSelector || "input"
+              );
+              const handler = () => setFormField({ isValueChangedByUser: true }, key);
+              element?.addEventListener("paste", handler, { once: true });
+              element?.addEventListener("keypress", handler, { once: true });
+            },
+            true
+          );
+          return updateFormField(result, field, key);
+        }, fields);
+      });
+    }
+  }, [renderFormFields]);
+  const [onFormRenderObservers, setOnFormRenderObservers] = (0, import_react8.useState)([]);
+  const addOnFormRenderObserver = (cb, { once = false } = {}) => {
+    setOnFormRenderObservers((state) => [
+      ...state,
+      { cb, once, isWorkedOut: false }
+    ]);
+  };
+  const updateOnFormRenderObserver = (key, data) => {
+    setOnFormRenderObservers((state) => {
+      const copy = [...state];
+      copy[key] = { ...state[key], ...data };
+      return copy;
+    });
+  };
+  const removeOnFormRenderObserver = (key) => {
+    setOnFormRenderObservers(
+      (state) => state.slice().filter((v, i) => i !== key)
+    );
+  };
+  const onFormRenderWorker = () => {
+    onFormRenderObservers.map(
+      ({ once, isWorkedOut, cb = () => {
+      } } = {}, key) => {
+        if (once && isWorkedOut) return null;
+        cb(form);
+        if (once) removeOnFormRenderObserver(key);
+        else updateOnFormRenderObserver(key, { isWorkedOut: true });
+        return null;
+      }
+    );
+  };
+  (0, import_react8.useEffect)(() => {
+    if (!isFormRendered && onFormRenderObservers.length) {
+      const formFieldsKeys = getFormFieldsKeys(form);
+      const isAllFieldsRendered = renderFormFields.reduce((result, key) => {
+        if (!formFieldsKeys.includes(key)) result = false;
+        return result;
+      }, true);
+      if (isAllFieldsRendered) {
+        submitIsFormRendered(true);
+        onFormRenderWorker();
+      }
+    }
+  }, [form, renderFormFields, onFormRenderObservers]);
+  const hightliteErrorLabels = () => {
+    const fields = getFormFieldsAsArray();
+    const filtered = fields?.reduce((result, field) => {
+      if (field?.errorLabelHightlite) {
+        result.push({
+          ...field,
+          className: getFieldClassName(field?.key, FormType)
+        });
+      }
+      return result;
+    }, []);
+    filtered?.map((field) => {
+      const formField = document.querySelector(`.${field?.className}`);
+      if (!formField) return null;
+      formField.classList.remove("errorLabelHightlite");
+      if (field?.error) {
+        formField.classList.add("errorLabelHightlite");
+      }
+      return null;
+    });
+  };
+  (0, import_react8.useEffect)(() => {
+    hightliteErrorLabels();
+  }, [form]);
+  const [isInitFocused, setIsInitFocused] = (0, import_react8.useState)(false);
+  const [autoFocusedField, setAutoFocusedField] = (0, import_react8.useState)(null);
+  const setFirstFieldInitFocused = () => setIsInitFocused(true);
+  const resetIsInitFocused = () => setIsInitFocused(false);
+  const toggleFieldFocus = ({ key, cb = () => {
+  }, form: argForm, field }, action = "focus") => {
+    if (!key && !field) return null;
+    if (!argForm) argForm = form;
+    const formField = field || getFormField(key, argForm);
+    if (!formField || !formField.ref) {
+      return false;
+    }
+    if (action === "focus" && FocusControllerProps.onlyEmptyFieldAutoFocus && Boolean(formField?.value))
+      return null;
+    setTimeout(() => {
+      formField.ref.current?.querySelector(formField?.focusSelector || "input")?.[action]();
+      cb();
+    }, 50);
+  };
+  const setFieldFocus = ({ key, cb = () => {
+  }, form: argForm, field }) => toggleFieldFocus({ key, cb, form: argForm, field }, "focus");
+  const setFieldBlur = ({ key, cb = () => {
+  }, form: argForm, field }) => toggleFieldFocus({ key, cb, form: argForm, field }, "blur");
+  const setFirstFieldFocus = () => {
+    let field = null;
+    for (let i = 0; i < renderFormFields.length && !field; ++i) {
+      const key = renderFormFields[i];
+      const tmpField = getFormField(key);
+      if (tmpField && !tmpField?.disabled) field = tmpField;
+    }
+    if (!field) return false;
+    if (FocusControllerProps.onlyEmptyFieldAutoFocus && Boolean(field?.value)) {
+      setFirstFieldInitFocused();
+      return false;
+    }
+    setAutoFocusedField(field.key);
+    const callback = () => {
+      setFormField({ value: field.value }, field.key);
+      setFirstFieldInitFocused();
+    };
+    setTimeout(() => setFieldFocus({ key: field.key, cb: callback, form }), 50);
+  };
+  const [onFieldFocusCallbacks, setOnFieldFocusCallbacks] = (0, import_react8.useState)({});
+  const addOnFieldFocusCallback = (key, cb) => {
+    setOnFieldFocusCallbacks((state) => {
+      const stateCopy = { ...state };
+      if (!state[key]) stateCopy[key] = [];
+      stateCopy[key].push(cb);
+      return stateCopy;
+    });
+  };
+  const callOnFieldFocusCallbacks = (key) => {
+    if (!Array.isArray(onFieldFocusCallbacks[key])) return null;
+    onFieldFocusCallbacks[key]?.map((cb) => cb());
+  };
+  const [focusOnRenderFields, setFocusOnRenderFields] = (0, import_react8.useState)([]);
+  const addFocusFieldOnRender = (key, cb) => {
+    setFocusOnRenderFields((state) => [...state, key]);
+    if (cb) addOnFieldFocusCallback(key, cb);
+  };
+  const removeFocusFieldOnRender = (key) => {
+    setFocusOnRenderFields((state) => state.filter((field) => field !== key));
+  };
+  (0, import_react8.useEffect)(() => {
+    if (FocusControllerProps.setAutoFocus && !isInitFocused && !autoFocusedField && isFormRendered)
+      setFirstFieldFocus();
+    if (focusOnRenderFields.length) {
+      getFormFieldsKeys(form)?.map((key) => {
+        if (focusOnRenderFields.includes(key) && getFormField(key)?.value?.length === 0) {
+          const cb = () => {
+            removeFocusFieldOnRender(key);
+            callOnFieldFocusCallbacks(key);
+          };
+          setFieldFocus({ key, form, cb });
+        }
+        return null;
+      });
+    }
+  }, [form, focusOnRenderFields, isInitFocused, isFormRendered]);
+  (0, import_react8.useEffect)(() => {
+    setAutoFocusedField(null);
+  }, [isInitFocused]);
+  (0, import_react8.useEffect)(() => {
+    resetIsInitFocused();
+  }, [FormType]);
+  const [onFieldRenderedObservers, setOnFieldRenderedObservers] = (0, import_react8.useState)({});
+  const [isFieldObserversReset, setIsFieldObserversReset] = (0, import_react8.useState)(false);
+  const resetOnFieldRenderObserversWorkedOut = () => {
+    if (!isFieldObserversReset && renderFormFields.length) {
+      renderFormFields.map((key) => {
+        setFormField({ isOnRenderObserversWorkedOut: false }, key);
+        return key;
+      });
+      setIsFieldObserversReset(true);
+    }
+  };
+  const addOnFieldRenderedObserver = (key, cb, isOnceCallable = true) => {
+    let observerId = null;
+    setOnFieldRenderedObservers((state) => {
+      if (!state[key]) state[key] = {};
+      observerId = Object.keys(state[key]).length || 0;
+      state[key][observerId] = {
+        f: cb,
+        isOnceCallable
+      };
+      return state;
+    });
+    return observerId;
+  };
+  const updateOnFieldRenderedObserver = (key, id, data) => {
+    setOnFieldRenderedObservers((state) => {
+      if (!state[key]) return state;
+      state[key][id] = {
+        ...state[key][id],
+        ...data
+      };
+      return state;
+    });
+  };
+  const removeOnFieldRenderedObserver = (key, id) => {
+    setOnFieldRenderedObservers((state) => {
+      if (!state[key]) return state;
+      state[key] = Object.keys(state).filter((cbId) => cbId !== id).map((cbId) => state[key][cbId]);
+      return state;
+    });
+  };
+  const onFieldRenderedObserver = (key, data) => {
+    if (!onFieldRenderedObservers[key] || typeof onFieldRenderedObservers[key] !== "object")
+      return;
+    const Observers = onFieldRenderedObservers[key];
+    const FilteredObservers = Object.values(Observers).filter(
+      (observer) => !observer?.isObserverWorkedOut
+    );
+    if (FilteredObservers.length === 0) return null;
+    setFormField({ isOnRenderObserversWorkedOut: true }, key);
+    FilteredObservers.map(({ f, isOnceCallable }, id) => {
+      f(data);
+      if (isOnceCallable)
+        updateOnFieldRenderedObserver(key, id, { isObserverWorkedOut: true });
+      return null;
+    });
+  };
+  const onRenderObserverWorker = () => {
+    return getFormFieldsKeys(form)?.map((key) => {
+      const fieldData = getFormField(key);
+      if (!fieldData?.isOnRenderObserversWorkedOut) {
+        onFieldRenderedObserver(key, fieldData);
+        return { key, isWorkedOut: true };
+      }
+      return { key, isWorkedOut: false };
+    });
+  };
+  (0, import_react8.useEffect)(() => {
+    resetOnFieldRenderObserversWorkedOut();
+    onRenderObserverWorker();
+  }, [form]);
+  (0, import_react8.useEffect)(() => {
+    setIsFieldObserversReset(false);
+  }, [FormType]);
+  const scrollToField = ({ key = null, field = null, form: argForm }) => {
+    if (!key && !field) return false;
+    if (!argForm) argForm = form;
+    if (!field) field = getFormField(key, argForm);
+    const wrapperRef = field?.wrapperRef || field?.ref;
+    const { top: topOffset } = wrapperRef?.current?.getBoundingClientRect();
+    const scrollTop = Math.abs(Math.abs(topOffset) - Math.abs(window.scrollY)) - 16;
+    window.scrollTo({ top: scrollTop });
+  };
+  const addErrorsToForm = (errors, argForm = form) => {
+    if (!argForm) argForm = form;
+    setFormFields((fields) => {
+      return errors.reduce(
+        (fields2, { message: error, propertyPath: errKey }) => {
+          return updateFormField(fields2, { error }, errKey);
+        },
+        fields
+      );
+    });
+  };
+  return {
+    FormDataDrivers,
+    //OnChangeObserver
+    addOnChangeObserver,
+    removeOnChangeObserver,
+    onChangeObservers,
+    //OnChangeHandler
+    onFieldChange,
+    //Form Submit Blocker
+    toggleFormSubmitBlock,
+    clearFormSubmitBlockers,
+    isFormSubmitBlocked: Boolean(formSubmitBlockers.length),
+    //Property Observers
+    // addPropertyObserver,
+    //Render Fields
+    renderFormFields,
+    setRenderFormFields,
+    addRenderFields,
+    removeRenderFields,
+    getFieldClassName,
+    //Field Focus Controller
+    isInitFocused,
+    setFirstFieldInitFocused,
+    resetIsInitFocused,
+    setFieldFocus,
+    setFieldBlur,
+    setFirstFieldFocus,
+    autoFocusedField,
+    addFocusFieldOnRender,
+    removeFocusFieldOnRender,
+    //Field Render Controller
+    addOnFieldRenderedObserver,
+    removeOnFieldRenderedObserver,
+    onFieldRenderedObservers,
+    updateFormField,
+    addOnFormRenderObserver,
+    submitIsFormRendered,
+    resetIsFormRendered,
+    renderFields: ({
+      form: argForm = form,
+      fields: argFields = renderFormFields,
+      cols: argCols = 1,
+      RenderFieldComponent
+    }) => RenderFields({
+      form: argForm,
+      fields: argFields,
+      cols: argCols,
+      RenderFieldComponent,
+      onFieldChange,
+      FormDataDriver: getFormDataDriver(FormDataDriverName)
+    }),
+    scrollToField,
+    getFieldData,
+    getFormField,
+    setFormFields,
+    setFormField: (data, key) => setFormField(data, key),
+    getFormFieldsAsArray,
+    getFormFieldsKeys,
+    removeAllFormFields,
+    removeFormField,
+    removeFormFields,
+    addErrorsToForm
+  };
+}
+
+// src/Functions/useInputHighlightError.js
+var import_react9 = __toESM(require("react"), 1);
+var useInputHighlightError = ({
+  value,
+  blinkTime,
+  isUseErrorsBlink
+}) => {
+  const DEFAULT_BLINK_TIME = 100;
+  const [isToHighlightError, setIsToHighlightError] = (0, import_react9.useState)(false);
+  const [isAttemptToChange, setIsAttemptToChange] = (0, import_react9.useState)(false);
+  const [prevValue, setPreviousValue] = (0, import_react9.useState)(value);
+  function hasHighlightError(e) {
+    const changedValue = `${value ?? ""}`;
+    const previousValue = `${prevValue ?? ""}`;
+    const short = previousValue.length <= changedValue.length ? previousValue : changedValue;
+    const long = previousValue.length > changedValue.length ? previousValue : changedValue;
+    const infoAboutDifferencesSameness = short.split("").reduce(
+      (acc, symbol, idx) => {
+        if (acc.countOn && symbol === long[idx]) acc.same.push(symbol);
+        else {
+          acc.countOn = false;
+          acc.differences.push([idx, symbol]);
+        }
+        return acc;
+      },
+      { same: [], countOn: true, differences: [] }
+    );
+    const samePart = infoAboutDifferencesSameness.same.join("");
+    const differencesLength = infoAboutDifferencesSameness.differences.length;
+    const currentSet = changedValue?.replace(samePart, "");
+    if (!KEYBOARD_SERVICE_KEYS.includes(e.key) && changedValue === previousValue)
+      setIsAttemptToChange(!(!differencesLength && e.key === currentSet));
+  }
+  (0, import_react9.useEffect)(() => {
+    if (isUseErrorsBlink && isAttemptToChange) {
+      setIsAttemptToChange(null);
+      setIsToHighlightError(true);
+      setTimeout(() => {
+        setIsToHighlightError(false);
+      }, blinkTime || DEFAULT_BLINK_TIME);
+    }
+  }, [isAttemptToChange]);
+  return {
+    isToHighlightError,
+    setPreviousValue,
+    setIsToHighlightError,
+    hasHighlightError
+  };
+};
+var useInputHighlightError_default = useInputHighlightError;
+
+// src/Functions/useIsMobile/useIsMobile.ts
+var import_react10 = require("react");
+function useIsMobile({ isWithoutWidthCheck = false } = {}) {
+  const isIPad = () => {
+    const ua = navigator.userAgent || navigator.vendor || window.opera;
+    const isMac = /Macintosh/.test(ua);
+    const hasTouch = navigator.maxTouchPoints && navigator.maxTouchPoints > 2;
+    return isMac && !!hasTouch;
+  };
+  const getIsMobile = () => {
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || isIPad();
+  };
+  const [isMobile, setIsMobile] = (0, import_react10.useState)(getIsMobile());
+  (0, import_react10.useEffect)(() => {
+    if (getIsMobile()) {
+      setIsMobile(true);
+    }
+  }, [navigator.userAgent]);
+  return {
+    isMobile: isMobile && (isWithoutWidthCheck || window.screen.width <= 768 || window.screen.width <= 1024 && window.matchMedia("(orientation: landscape)").matches),
+    isMobilePortrait: isMobile && window.screen.width <= 768 && window.matchMedia("(orientation: portait)").matches,
+    isMobileLandscape: isMobile && window.screen.width <= 1024 && window.matchMedia("(orientation: landscape)").matches
+  };
+}
+var useIsMobile_default = useIsMobile;
+
+// src/Functions/useIsMobile/index.ts
+var useIsMobile_default2 = useIsMobile_default;
+
+// src/Functions/useKeyPress/useKeyPress.ts
+var import_react11 = require("react");
+function isISuspendProcessing(x) {
+  return getIsOnlyAnObject(x) && Object.values(x).every((v) => typeof v === "function");
+}
+function useKeyPress(targetKey, clamping = true, isForbidden, suspendProcessing) {
+  const [keyPressed, setKeyPressed] = (0, import_react11.useState)(false);
+  const safelySuspendProcessing = isISuspendProcessing(suspendProcessing) ? suspendProcessing : {};
+  const downHandler = (0, import_react11.useCallback)(
+    (event) => {
+      const { key, repeat, altKey, ctrlKey, shiftKey, metaKey } = event;
+      const isPressingWithoutAuxiliaryKeys = !altKey && !ctrlKey && !shiftKey && !metaKey;
+      if (key === targetKey && isPressingWithoutAuxiliaryKeys && !safelySuspendProcessing[key]?.(event)) {
+        if (!clamping && repeat) return;
+        setKeyPressed(true);
+      }
+    },
+    // ? Намерянно в зависимостях используем именно входной suspendProcessing,
+    // ? хоть в коде используем "безопасный"
+    [clamping, targetKey, suspendProcessing]
+  );
+  const upHandler = (0, import_react11.useCallback)(
+    (event) => {
+      const { key, repeat, altKey, ctrlKey, shiftKey, metaKey } = event;
+      const isPressingWithoutAuxiliaryKeys = !altKey && !ctrlKey && !shiftKey && !metaKey;
+      if (key === targetKey && isPressingWithoutAuxiliaryKeys && !safelySuspendProcessing[key]?.(event)) {
+        if (!clamping && repeat) return;
+        setKeyPressed(false);
+      }
+    },
+    // ? Намерянно в зависимостях используем именно входной suspendProcessing,
+    // ? хоть в коде используем "безопасный"
+    [clamping, targetKey, suspendProcessing]
+  );
+  (0, import_react11.useEffect)(
+    () => {
+      const handleDown = (event) => downHandler(event);
+      const handleUp = (event) => upHandler(event);
+      if (!isForbidden) {
+        window.addEventListener("keydown", handleDown);
+        window.addEventListener("keyup", handleUp);
+      }
+      return () => {
+        window.removeEventListener("keydown", handleDown);
+        window.removeEventListener("keyup", handleUp);
+      };
+    },
+    // ? Намерянно в зависимостях используем именно входной suspendProcessing,
+    // ? хоть в коде используем "безопасный"
+    [downHandler, upHandler, isForbidden, suspendProcessing]
+  );
+  return keyPressed;
+}
+var useKeyPress_default = useKeyPress;
+
+// src/Functions/useLocalStorage.js
+var import_react12 = require("react");
+var useLocalStorage = (key, initialValue) => {
+  const [storedValue, setStoredValue] = (0, import_react12.useState)(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.log(error);
+      return initialValue;
+    }
+  });
+  const setValue = (value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+      if (typeof window !== "undefined") {
+        window.localStorage.setItem(key, JSON.stringify(valueToStore));
+      }
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  return [storedValue, setValue];
+};
+var useLocalStorage_default = useLocalStorage;
+
+// src/Functions/useLocationParams.js
+var import_react13 = require("react");
+function useLocationParams() {
+  const [params, setParams] = (0, import_react13.useState)({});
+  (0, import_react13.useEffect)(() => {
+    setParams((state) => {
+      const arr = window.location.search?.replace("?", "").split("&");
+      return {
+        ...state,
+        ...arr.reduce((obj, item) => {
+          const keyVal = item.split("=");
+          const key = keyVal[0];
+          const value = decodeURIComponent(keyVal[1]);
+          return {
+            ...obj,
+            [key]: value
+          };
+        }, {})
+      };
+    });
+  }, [window.location.search]);
+  return params;
+}
+
+// src/Functions/useMediaQuery.js
+var import_react14 = require("react");
+function subscribe(callback) {
+  const observer = new ResizeObserver(() => callback());
+  observer.observe(document.documentElement);
+  return () => observer.disconnect();
+}
+var useMediaQuery = (query) => {
+  return (0, import_react14.useSyncExternalStore)(
+    subscribe,
+    () => window.matchMedia(query).matches,
+    () => false
+  );
+};
+var useMediaQuery_default = useMediaQuery;
+
+// src/Functions/useMetaInfo.js
+var import_react15 = require("react");
+var useMetaInfo = () => {
+  const [browser, setBrowser] = (0, import_react15.useState)("Other");
+  const [device, setDevice] = (0, import_react15.useState)("desktop");
+  const [isiOS, setIsiOS] = (0, import_react15.useState)(false);
+  const [chromeVersion, setChromeVersion] = (0, import_react15.useState)(null);
+  const [iOSVersion, setiOSVersion] = (0, import_react15.useState)(null);
+  (0, import_react15.useEffect)(() => {
+    const userAgent = navigator.userAgent;
+    if (userAgent.indexOf("Chrome") !== -1) {
+      setBrowser("Chrome");
+      const version = userAgent.match(/Chrom(e|ium)\/([0-9\.]+)/)[2];
+      setChromeVersion(version);
+    } else if (userAgent.indexOf("Safari") !== -1) setBrowser("Safari");
+    const iOSV = ((userAgent.match(/(CPU|iPhone).*OS (\d+_?\d*)|CPU like Mac OS X/i) || [])[2] || "0").replace("_", ".");
+    const iOSVersion2 = parseFloat(iOSV);
+    setIsiOS(!isNaN(iOSVersion2));
+    if (!isNaN(iOSVersion2)) {
+      setiOSVersion(iOSV);
+    }
+    if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+      userAgent
+    ))
+      setDevice("mobile");
+  }, []);
+  return { browser, device, isiOS, chromeVersion, iOSVersion };
+};
+var useMetaInfo_default = useMetaInfo;
+
+// src/Functions/useMouseUpOutside.js
+var import_react16 = require("react");
+function useMouseUpOutside(ref, setOut, open) {
+  function handleMouseUpOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  (0, import_react16.useEffect)(() => {
+    document.addEventListener("mouseup", handleMouseUpOutside);
+    return () => {
+      document.removeEventListener("mouseup", handleMouseUpOutside);
+    };
+  }, [ref]);
+}
+
+// src/Functions/useOnlineStatus.js
+var import_react17 = require("react");
+var useOnlineStatus = () => {
+  function getOnlineStatus() {
+    return typeof navigator !== "undefined" && typeof navigator.onLine === "boolean" ? navigator.onLine : true;
+  }
+  const [onlineStatus, setOnlineStatus] = (0, import_react17.useState)(getOnlineStatus());
+  const goOnline = () => setOnlineStatus(true);
+  const goOffline = () => setOnlineStatus(false);
+  (0, import_react17.useEffect)(() => {
+    window.addEventListener("online", goOnline);
+    window.addEventListener("offline", goOffline);
+    return () => {
+      window.removeEventListener("online", goOnline);
+      window.removeEventListener("offline", goOffline);
+    };
+  }, []);
+  return onlineStatus;
+};
+var useOnlineStatus_default = useOnlineStatus;
+
+// src/Functions/usePasswordChecker.js
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_react18 = __toESM(require("react"), 1);
+var import_classnames = __toESM(require("classnames"), 1);
+function usePasswordChecker({ label = "Password must:" } = {}) {
+  const [checkRules, setCheckRules] = (0, import_react18.useState)([]);
+  const addCheckRule = (data) => setCheckRules((state) => [...state, data]);
+  const handleCheckRule = (type, props = {}, value = "") => {
+    const { min, max } = props;
+    switch (type) {
+      case "len":
+        if (min && value.length < min) return false;
+        if (max && value.length > max) return false;
+        return true;
+      case "lowerCaseContains": {
+        const toUpperCase = value.slice().toUpperCase().split("");
+        const original = value.slice().split("");
+        return original.reduce((isMatch, char, i) => {
+          if (char !== toUpperCase[i]) isMatch = true;
+          return isMatch;
+        }, false);
+      }
+      case "upperCaseContains": {
+        const toLowerCase = value.slice().toLowerCase().split("");
+        const original = value.slice().split("");
+        return original.reduce((isMatch, char, i) => {
+          if (char !== toLowerCase[i]) isMatch = true;
+          return isMatch;
+        }, false);
+      }
+      case "numberContains": {
+        const original = value.slice().split("");
+        return original.reduce((isMatch, char) => {
+          if (Number.isInteger(parseInt(char, 10))) isMatch = true;
+          return isMatch;
+        }, false);
+      }
+      case "specialContains": {
+        const original = value.slice().split("");
+        return original.reduce((isMatch, char) => {
+          if (!Number.isInteger(parseInt(char, 10)) && !char.match(/[a-z]/i))
+            isMatch = true;
+          return isMatch;
+        }, false);
+      }
+      default:
+        return false;
+    }
+  };
+  const testCheckRules = (value) => {
+    let result = true;
+    setCheckRules((state) => {
+      const rules = [...state];
+      return rules.map((rule) => {
+        const isMatch = handleCheckRule(rule.type, rule.props, value);
+        if (!isMatch) result = false;
+        return { ...rule, isMatch };
+      });
+    });
+    return result;
+  };
+  const renderPasswordChecker = () => {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "password-checker", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "password-checker__header", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("label", { className: "password-checker__header-label", children: [
+          " ",
+          label,
+          " "
+        ] }),
+        " "
+      ] }),
+      " ",
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "password-checker__body", children: [
+        " ",
+        checkRules.map(({ icon, text, isMatch, key }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+          "div",
+          {
+            className: (0, import_classnames.default)("password-checker__body-item", {
+              "password-checker__body-item--match": isMatch && isMatch !== null,
+              "password-checker__body-item--dont-match": !isMatch && isMatch !== null
+            }),
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "password-checker__body-item__icon", children: [
+                " ",
+                icon,
+                " "
+              ] }),
+              " ",
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "password-checker__body-item__text", children: [
+                " ",
+                text,
+                " "
+              ] }),
+              " "
+            ]
+          },
+          key
+        )),
+        " "
+      ] }),
+      " "
+    ] });
+  };
+  return {
+    addCheckRule,
+    testCheckRules,
+    renderPasswordChecker
+  };
+}
+
+// src/Functions/usePrevious.js
+var import_react19 = require("react");
+function usePrevious(value) {
+  const ref = (0, import_react19.useRef)();
+  (0, import_react19.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+var usePrevious_default = usePrevious;
+
+// src/Functions/useResize.js
+var import_react20 = require("react");
+var useResize = (element) => {
+  const [elemPosition, setElemPosition] = (0, import_react20.useState)("");
+  const onResize = (elemRightPosition) => {
+    if (elemRightPosition > document.documentElement.clientWidth) {
+      return setElemPosition("left");
+    } else setElemPosition("");
+  };
+  (0, import_react20.useEffect)(() => {
+    const elemRightPosition = element?.current?.getBoundingClientRect().right + 20;
+    window.addEventListener("resize", () => onResize(elemRightPosition));
+    return () => {
+      window.removeEventListener("resize", () => setElemPosition(""));
+    };
+  }, []);
+  (0, import_react20.useLayoutEffect)(() => {
+    const elemRightPosition = element?.current?.getBoundingClientRect().right + 20;
+    if (elemRightPosition > document.documentElement.clientWidth) {
+      return setElemPosition("left");
+    }
+  }, []);
+  return { elemPosition };
+};
+
+// src/Functions/useScrollTo.js
+var import_react21 = require("react");
+var useScrollTo = (reference) => {
+  const ref = (0, import_react21.useRef)(reference);
+  const [shouldScrollTo, setShouldScrollTo] = (0, import_react21.useState)(false);
+  (0, import_react21.useEffect)(() => {
+    if (ref?.current && shouldScrollTo) {
+      ref?.current?.scrollIntoView?.({ behavior: "smooth" });
+      setShouldScrollTo(false);
+    }
+  }, [shouldScrollTo]);
+  return [ref, setShouldScrollTo];
+};
+var useScrollTo_default = useScrollTo;
+
+// src/Functions/useToggle.js
+var import_react22 = require("react");
+var useToggle = (initialState) => {
+  const [isToggled, setToggle] = (0, import_react22.useState)(Boolean(initialState));
+  const toggle = (0, import_react22.useCallback)(() => setToggle((isOn) => !isOn), []);
+  const toggleOn = (0, import_react22.useCallback)(() => setToggle(true), []);
+  const toggleOff = (0, import_react22.useCallback)(() => setToggle(false), []);
+  return {
+    isToggled,
+    toggle,
+    toggleOn,
+    toggleOff
+  };
+};
+var useToggle_default = useToggle;
+//! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+//! чем указано в quantity - округлит по правилам округления
+//! чем указано в decimalPlaces - округлит по правилам округления
+//# sourceMappingURL=hooks.cjs.map