all-you-need 0.1.0

package/dist/chunk-SEJ5J4LY.cjs

@@ -0,0 +1,924 @@
+'use strict';
+
+// src/utils/string/capitalize.ts
+function capitalize(str) {
+  if (str.length === 0) {
+    return str;
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/utils/string/escapeHtml.ts
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/utils/string/escapeRegExp.ts
+function escapeRegExp(str) {
+  return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+// src/utils/string/maskString.ts
+function maskString(str, visibleStart = 0, visibleEnd = 0, maskChar = "*") {
+  if (str.length <= visibleStart + visibleEnd) {
+    return str;
+  }
+  const start = str.slice(0, visibleStart);
+  const end = visibleEnd > 0 ? str.slice(-visibleEnd) : "";
+  const masked = maskChar.repeat(str.length - visibleStart - visibleEnd);
+  return start + masked + end;
+}
+
+// src/utils/string/pluralize.ts
+function pluralize(count, one, few, many) {
+  const abs = Math.abs(count);
+  const mod10 = abs % 10;
+  const mod100 = abs % 100;
+  if (mod10 === 1 && mod100 !== 11) {
+    return `${count} ${one}`;
+  }
+  if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) {
+    return `${count} ${few}`;
+  }
+  return `${count} ${many}`;
+}
+
+// src/utils/string/slugify.ts
+function slugify(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/utils/string/template.ts
+function template(str, data) {
+  return str.replace(/\{(\w+)\}/g, (match, key) => {
+    if (key in data) {
+      return String(data[key]);
+    }
+    return match;
+  });
+}
+
+// src/utils/string/toCamelCase.ts
+function toCamelCase(str) {
+  return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()).replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+
+// src/utils/string/toKebabCase.ts
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").toLowerCase();
+}
+
+// src/utils/string/toPascalCase.ts
+function toPascalCase(str) {
+  return str.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+
+// src/utils/string/toSnakeCase.ts
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toLowerCase();
+}
+
+// src/utils/string/truncate.ts
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+
+// src/utils/string/unescapeHtml.ts
+function unescapeHtml(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+
+// src/utils/array/chunk.ts
+function chunk(arr, size) {
+  if (size <= 0) {
+    throw new RangeError("chunk size must be greater than 0");
+  }
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+
+// src/utils/array/compact.ts
+function compact(arr) {
+  return arr.filter(Boolean);
+}
+
+// src/utils/array/difference.ts
+function difference(a, b) {
+  const set = new Set(b);
+  return a.filter((item) => !set.has(item));
+}
+
+// src/utils/array/first.ts
+function first(arr) {
+  return arr[0];
+}
+
+// src/utils/array/flatten.ts
+function flatten(arr) {
+  return arr.flat(Infinity);
+}
+
+// src/utils/array/groupBy.ts
+function groupBy(arr, keyFn) {
+  return arr.reduce(
+    (acc, item) => {
+      const key = keyFn(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+
+// src/utils/array/intersection.ts
+function intersection(a, b) {
+  const set = new Set(b);
+  return a.filter((item) => set.has(item));
+}
+
+// src/utils/array/last.ts
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+// src/utils/array/range.ts
+function range(start, end, step = 1) {
+  if (step === 0) {
+    throw new RangeError("step must not be 0");
+  }
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+
+// src/utils/array/shuffle.ts
+function shuffle(arr) {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+
+// src/utils/array/sortBy.ts
+function sortBy(arr, keyFn) {
+  return [...arr].sort((a, b) => {
+    const ka = keyFn(a);
+    const kb = keyFn(b);
+    if (ka < kb) {
+      return -1;
+    }
+    if (ka > kb) {
+      return 1;
+    }
+    return 0;
+  });
+}
+
+// src/utils/array/unique.ts
+function unique(arr) {
+  return [...new Set(arr)];
+}
+
+// src/utils/array/uniqueBy.ts
+function uniqueBy(arr, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/utils/array/zip.ts
+function zip(a, b) {
+  const length = Math.min(a.length, b.length);
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    result.push([a[i], b[i]]);
+  }
+  return result;
+}
+
+// src/utils/object/deepClone.ts
+function deepClone(value) {
+  return structuredClone(value);
+}
+
+// src/utils/object/deepEqual.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(
+      a[key],
+      b[key]
+    )
+  );
+}
+
+// src/utils/object/deepMerge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const targetVal = result[key];
+    const sourceVal = source[key];
+    if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+// src/utils/object/diff.ts
+function diff(original, changed) {
+  const result = {};
+  for (const key of Object.keys(changed)) {
+    if (changed[key] !== original[key]) {
+      result[key] = changed[key];
+    }
+  }
+  return result;
+}
+
+// src/utils/object/flattenObject.ts
+function flattenObject(obj, prefix = "", separator = ".") {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const fullKey = prefix ? `${prefix}${separator}${key}` : key;
+    const value = obj[key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+      Object.assign(
+        result,
+        flattenObject(value, fullKey, separator)
+      );
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
+
+// src/utils/object/isEmpty.ts
+function isEmpty(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+
+// src/utils/object/mapKeys.ts
+function mapKeys(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[fn(key)] = obj[key];
+  }
+  return result;
+}
+
+// src/utils/object/mapValues.ts
+function mapValues(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = fn(obj[key], key);
+  }
+  return result;
+}
+
+// src/utils/object/omit.ts
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+
+// src/utils/object/pick.ts
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// src/utils/number/average.ts
+function average(arr) {
+  if (arr.length === 0) {
+    return 0;
+  }
+  return arr.reduce((acc, val) => acc + val, 0) / arr.length;
+}
+
+// src/utils/number/clamp.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/utils/number/formatBytes.ts
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const k = 1024;
+  const units = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  return `${parseFloat(value.toFixed(decimals))} ${units[i]}`;
+}
+
+// src/utils/number/formatCurrency.ts
+function formatCurrency(value, currency = "RUB", locale = "ru-RU") {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(value);
+}
+
+// src/utils/number/formatNumber.ts
+function formatNumber(value, locale = "ru-RU") {
+  return new Intl.NumberFormat(locale).format(value);
+}
+
+// src/utils/number/median.ts
+function median(arr) {
+  if (arr.length === 0) {
+    return 0;
+  }
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+}
+
+// src/utils/number/percentage.ts
+function percentage(value, total) {
+  if (total === 0) {
+    return 0;
+  }
+  return value / total * 100;
+}
+
+// src/utils/number/randomInt.ts
+function randomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// src/utils/number/round.ts
+function round(value, decimals = 0) {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+
+// src/utils/number/sum.ts
+function sum(arr) {
+  return arr.reduce((acc, val) => acc + val, 0);
+}
+
+// src/utils/date/formatDate.ts
+function formatDate(date, options = {
+  day: "2-digit",
+  month: "2-digit",
+  year: "numeric"
+}, locale = "ru-RU") {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+
+// src/utils/date/daysBetween.ts
+function daysBetween(a, b) {
+  const MS_PER_DAY = 864e5;
+  const utcA = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
+  const utcB = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());
+  return Math.abs(Math.floor((utcB - utcA) / MS_PER_DAY));
+}
+
+// src/utils/date/isToday.ts
+function isToday(date) {
+  const now = /* @__PURE__ */ new Date();
+  return date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+}
+
+// src/utils/date/isYesterday.ts
+function isYesterday(date) {
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return date.getFullYear() === yesterday.getFullYear() && date.getMonth() === yesterday.getMonth() && date.getDate() === yesterday.getDate();
+}
+
+// src/utils/date/addDays.ts
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+
+// src/utils/date/addMonths.ts
+function addMonths(date, months) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + months);
+  return result;
+}
+
+// src/utils/date/relativeTime.ts
+function relativeTime(date, locale = "ru-RU") {
+  const now = Date.now();
+  const diffMs = date.getTime() - now;
+  const absDiffMs = Math.abs(diffMs);
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  const SECOND = 1e3;
+  const MINUTE = 60 * SECOND;
+  const HOUR = 60 * MINUTE;
+  const DAY = 24 * HOUR;
+  const MONTH = 30 * DAY;
+  const YEAR = 365 * DAY;
+  if (absDiffMs < MINUTE) {
+    return rtf.format(Math.round(diffMs / SECOND), "second");
+  }
+  if (absDiffMs < HOUR) {
+    return rtf.format(Math.round(diffMs / MINUTE), "minute");
+  }
+  if (absDiffMs < DAY) {
+    return rtf.format(Math.round(diffMs / HOUR), "hour");
+  }
+  if (absDiffMs < MONTH) {
+    return rtf.format(Math.round(diffMs / DAY), "day");
+  }
+  if (absDiffMs < YEAR) {
+    return rtf.format(Math.round(diffMs / MONTH), "month");
+  }
+  return rtf.format(Math.round(diffMs / YEAR), "year");
+}
+
+// src/utils/async/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/async/retry.ts
+async function retry(fn, options = {}) {
+  const { attempts = 3, delay = 1e3, factor = 2 } = options;
+  let lastError;
+  let currentDelay = delay;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (i < attempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, currentDelay));
+        currentDelay *= factor;
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/async/debounce.ts
+function debounce(fn, ms) {
+  let timeoutId;
+  return (...args) => {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => fn(...args), ms);
+  };
+}
+
+// src/utils/async/throttle.ts
+function throttle(fn, ms) {
+  let lastCall = 0;
+  let timeoutId;
+  return (...args) => {
+    const now = Date.now();
+    const remaining = ms - (now - lastCall);
+    if (remaining <= 0) {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      lastCall = now;
+      fn(...args);
+    } else if (timeoutId === void 0) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = void 0;
+        fn(...args);
+      }, remaining);
+    }
+  };
+}
+
+// src/utils/async/timeout.ts
+function timeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`Timed out after ${ms}ms`)),
+      ms
+    );
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/utils/async/tryCatch.ts
+async function tryCatch(fn) {
+  try {
+    const value = await fn();
+    return [null, value];
+  } catch (error) {
+    if (error instanceof Error) {
+      return [error, null];
+    }
+    return [new Error(String(error)), null];
+  }
+}
+function tryCatchSync(fn) {
+  try {
+    const value = fn();
+    return [null, value];
+  } catch (error) {
+    if (error instanceof Error) {
+      return [error, null];
+    }
+    return [new Error(String(error)), null];
+  }
+}
+
+// src/utils/async/pLimit.ts
+function pLimit(concurrency) {
+  let activeCount = 0;
+  const queue = [];
+  function next() {
+    if (queue.length > 0 && activeCount < concurrency) {
+      activeCount++;
+      const run = queue.shift();
+      run();
+    }
+  }
+  return (fn) => {
+    return new Promise((resolve, reject) => {
+      const run = () => {
+        fn().then(
+          (value) => {
+            resolve(value);
+            activeCount--;
+            next();
+          },
+          (error) => {
+            reject(error);
+            activeCount--;
+            next();
+          }
+        );
+      };
+      if (activeCount < concurrency) {
+        activeCount++;
+        run();
+      } else {
+        queue.push(run);
+      }
+    });
+  };
+}
+
+// src/utils/async/pSettle.ts
+function pSettle(promises) {
+  return Promise.all(
+    promises.map(
+      (promise) => promise.then(
+        (value) => ({ status: "fulfilled", value }),
+        (reason) => ({ status: "rejected", reason })
+      )
+    )
+  );
+}
+
+// src/utils/validation/isEmail.ts
+var EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function isEmail(str) {
+  return EMAIL_RE.test(str);
+}
+
+// src/utils/validation/isURL.ts
+function isURL(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/validation/isPhone.ts
+var PHONE_RE = /^\+?[0-9\s\-().]{7,20}$/;
+function isPhone(str) {
+  const digits = str.replace(/\D/g, "");
+  return PHONE_RE.test(str) && digits.length >= 7 && digits.length <= 15;
+}
+
+// src/utils/validation/isINN.ts
+function isINN(str) {
+  if (!/^\d{10}$|^\d{12}$/.test(str)) {
+    return false;
+  }
+  const digits = str.split("").map(Number);
+  if (digits.length === 10) {
+    const weights = [2, 4, 10, 3, 5, 9, 4, 6, 8];
+    const sum2 = weights.reduce((acc, w, i) => acc + w * digits[i], 0);
+    return sum2 % 11 % 10 === digits[9];
+  }
+  const weights11 = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8];
+  const weights12 = [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8];
+  const sum11 = weights11.reduce((acc, w, i) => acc + w * digits[i], 0);
+  const sum12 = weights12.reduce((acc, w, i) => acc + w * digits[i], 0);
+  return sum11 % 11 % 10 === digits[10] && sum12 % 11 % 10 === digits[11];
+}
+
+// src/utils/validation/isStrongPassword.ts
+function isStrongPassword(str, options = {}) {
+  const {
+    minLength = 8,
+    lowercase = true,
+    uppercase = true,
+    digits = true,
+    special = true
+  } = options;
+  if (str.length < minLength) {
+    return false;
+  }
+  if (lowercase && !/[a-z]/.test(str)) {
+    return false;
+  }
+  if (uppercase && !/[A-Z]/.test(str)) {
+    return false;
+  }
+  if (digits && !/\d/.test(str)) {
+    return false;
+  }
+  if (special && !/[^a-zA-Z0-9]/.test(str)) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/guards/isString.ts
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/utils/guards/isNumber.ts
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/utils/guards/isBoolean.ts
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+// src/utils/guards/isNonNullable.ts
+function isNonNullable(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/utils/guards/isArray.ts
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+// src/utils/guards/isObject.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/utils/guards/isFunction.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/utils/guards/isDefined.ts
+function isDefined(value) {
+  return value !== void 0;
+}
+
+// src/utils/guards/hasProperty.ts
+function hasProperty(obj, key) {
+  return typeof obj === "object" && obj !== null && key in obj;
+}
+
+// src/utils/env/isBrowser.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+
+// src/utils/env/isNode.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+
+// src/utils/env/isSSR.ts
+function isSSR() {
+  return isNode() && !isBrowser();
+}
+
+// src/utils/id/nanoid.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+function nanoid(size = 21) {
+  let id = "";
+  const bytes = new Uint8Array(size);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < size; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    id += ALPHABET[bytes[i] & 63];
+  }
+  return id;
+}
+
+// src/utils/id/uuid.ts
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+
+exports.addDays = addDays;
+exports.addMonths = addMonths;
+exports.average = average;
+exports.capitalize = capitalize;
+exports.chunk = chunk;
+exports.clamp = clamp;
+exports.compact = compact;
+exports.daysBetween = daysBetween;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.deepMerge = deepMerge;
+exports.diff = diff;
+exports.difference = difference;
+exports.escapeHtml = escapeHtml;
+exports.escapeRegExp = escapeRegExp;
+exports.first = first;
+exports.flatten = flatten;
+exports.flattenObject = flattenObject;
+exports.formatBytes = formatBytes;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatNumber = formatNumber;
+exports.groupBy = groupBy;
+exports.hasProperty = hasProperty;
+exports.intersection = intersection;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isBrowser = isBrowser;
+exports.isDefined = isDefined;
+exports.isEmail = isEmail;
+exports.isEmpty = isEmpty;
+exports.isFunction = isFunction;
+exports.isINN = isINN;
+exports.isNode = isNode;
+exports.isNonNullable = isNonNullable;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPhone = isPhone;
+exports.isSSR = isSSR;
+exports.isString = isString;
+exports.isStrongPassword = isStrongPassword;
+exports.isToday = isToday;
+exports.isURL = isURL;
+exports.isYesterday = isYesterday;
+exports.last = last;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.maskString = maskString;
+exports.median = median;
+exports.nanoid = nanoid;
+exports.omit = omit;
+exports.pLimit = pLimit;
+exports.pSettle = pSettle;
+exports.percentage = percentage;
+exports.pick = pick;
+exports.pluralize = pluralize;
+exports.randomInt = randomInt;
+exports.range = range;
+exports.relativeTime = relativeTime;
+exports.retry = retry;
+exports.round = round;
+exports.shuffle = shuffle;
+exports.sleep = sleep;
+exports.slugify = slugify;
+exports.sortBy = sortBy;
+exports.sum = sum;
+exports.template = template;
+exports.throttle = throttle;
+exports.timeout = timeout;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.truncate = truncate;
+exports.tryCatch = tryCatch;
+exports.tryCatchSync = tryCatchSync;
+exports.unescapeHtml = unescapeHtml;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;
+exports.uuid = uuid;
+exports.zip = zip;
+//# sourceMappingURL=chunk-SEJ5J4LY.cjs.map
+//# sourceMappingURL=chunk-SEJ5J4LY.cjs.map