react-util-tools 1.0.0

package/dist/index.cjs

@@ -0,0 +1,943 @@
+"use strict";
+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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Decimal: () => import_decimal.default,
+  abs: () => abs,
+  add: () => add,
+  addDaysToDate: () => addDaysToDate,
+  addDaysUTC: () => addDaysUTC,
+  addMonthsToDate: () => addMonthsToDate,
+  addMonthsUTC: () => addMonthsUTC,
+  ceil: () => ceil,
+  debounce: () => debounceFn,
+  divide: () => divide,
+  equals: () => equals,
+  floor: () => floor,
+  formatDate: () => formatDate,
+  formatDateOnly: () => formatDateOnly,
+  formatMoney: () => formatMoney,
+  formatMoneyToChinese: () => formatMoneyToChinese,
+  formatNumber: () => formatNumber,
+  formatPercent: () => formatPercent,
+  formatRelativeTime: () => formatRelativeTime,
+  formatTimeOnly: () => formatTimeOnly,
+  formatUTC: () => formatUTC,
+  formatUTCDateOnly: () => formatUTCDateOnly,
+  formatUTCTimeOnly: () => formatUTCTimeOnly,
+  fromUTC: () => fromUTC,
+  getAllQueryParams: () => getAllQueryParams,
+  getBrowser: () => getBrowser,
+  getBrowserEngine: () => getBrowserEngine,
+  getBrowserVersion: () => getBrowserVersion,
+  getDaysDiff: () => getDaysDiff,
+  getDeviceInfo: () => getDeviceInfo,
+  getDevicePixelRatio: () => getDevicePixelRatio,
+  getDeviceType: () => getDeviceType,
+  getEndOfDay: () => getEndOfDay,
+  getEndOfMonth: () => getEndOfMonth,
+  getEndOfWeek: () => getEndOfWeek,
+  getEndOfYear: () => getEndOfYear,
+  getHoursDiff: () => getHoursDiff,
+  getMinutesDiff: () => getMinutesDiff,
+  getOS: () => getOS,
+  getQueryParam: () => getQueryParam,
+  getQueryParamAll: () => getQueryParamAll,
+  getScreenResolution: () => getScreenResolution,
+  getStartOfDay: () => getStartOfDay,
+  getStartOfMonth: () => getStartOfMonth,
+  getStartOfWeek: () => getStartOfWeek,
+  getStartOfYear: () => getStartOfYear,
+  getTimestamp: () => getTimestamp,
+  getTimestampInSeconds: () => getTimestampInSeconds,
+  getTimezoneOffset: () => getTimezoneOffset,
+  getTimezoneOffsetHours: () => getTimezoneOffsetHours,
+  getUTCAllWeeksInYear: () => getUTCAllWeeksInYear,
+  getUTCDaysDiff: () => getUTCDaysDiff,
+  getUTCEndOfDay: () => getUTCEndOfDay,
+  getUTCEndOfMonth: () => getUTCEndOfMonth,
+  getUTCHoursDiff: () => getUTCHoursDiff,
+  getUTCMinutesDiff: () => getUTCMinutesDiff,
+  getUTCNow: () => getUTCNow,
+  getUTCStartOfDay: () => getUTCStartOfDay,
+  getUTCStartOfMonth: () => getUTCStartOfMonth,
+  getUTCTimestamp: () => getUTCTimestamp,
+  getUTCTimestampInSeconds: () => getUTCTimestampInSeconds,
+  getUTCWeekEnd: () => getUTCWeekEnd,
+  getUTCWeekNumber: () => getUTCWeekNumber,
+  getUTCWeekStart: () => getUTCWeekStart,
+  getUTCWeeksInYear: () => getUTCWeeksInYear,
+  getUTCYearEnd: () => getUTCYearEnd,
+  getUTCYearEndTimestamp: () => getUTCYearEndTimestamp,
+  getUTCYearStart: () => getUTCYearStart,
+  getUTCYearStartTimestamp: () => getUTCYearStartTimestamp,
+  getViewportSize: () => getViewportSize,
+  greaterThan: () => greaterThan,
+  greaterThanOrEqual: () => greaterThanOrEqual,
+  isAfterDate: () => isAfterDate,
+  isAndroid: () => isAndroid,
+  isBeforeDate: () => isBeforeDate,
+  isDesktop: () => isDesktop,
+  isIOS: () => isIOS,
+  isMobile: () => isMobile,
+  isSameDayDate: () => isSameDayDate,
+  isTablet: () => isTablet,
+  isTouchDevice: () => isTouchDevice,
+  isValidDate: () => isValidDate,
+  isWeChat: () => isWeChat,
+  lessThan: () => lessThan,
+  lessThanOrEqual: () => lessThanOrEqual,
+  multiply: () => multiply,
+  negate: () => negate,
+  parseDate: () => parseDate,
+  parseMoney: () => parseMoney,
+  round: () => round,
+  subDaysFromDate: () => subDaysFromDate,
+  subDaysUTC: () => subDaysUTC,
+  subMonthsFromDate: () => subMonthsFromDate,
+  subMonthsUTC: () => subMonthsUTC,
+  subtract: () => subtract,
+  throttle: () => throttleFn,
+  toISOString: () => toISOString,
+  toUTC: () => toUTC
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/throttle/index.ts
+function throttleFn(fn, wait = 3e3, options = {}) {
+  let timeout = null;
+  let lastCallTime = null;
+  let lastArgs = null;
+  const { leading = true, trailing = true } = options;
+  const invoke = (time) => {
+    fn(...lastArgs);
+    lastCallTime = time;
+    lastArgs = null;
+  };
+  return function(...args) {
+    const now = Date.now();
+    if (lastCallTime === null && !leading) {
+      lastCallTime = now;
+    }
+    const remaining = wait - (now - (lastCallTime ?? 0));
+    lastArgs = args;
+    if (remaining <= 0) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      invoke(now);
+    } else if (!timeout && trailing) {
+      timeout = setTimeout(() => {
+        timeout = null;
+        if (trailing && lastArgs) {
+          invoke(Date.now());
+        }
+      }, remaining);
+    }
+  };
+}
+function debounceFn(fn, wait = 500, immediate = false) {
+  let timeout = null;
+  return function(...args) {
+    const callNow = immediate && !timeout;
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (!immediate) {
+        fn(...args);
+      }
+    }, wait);
+    if (callNow) {
+      fn(...args);
+    }
+  };
+}
+
+// src/address/index.ts
+function getQueryParam(key, url) {
+  const searchParams = new URLSearchParams(
+    url ? new URL(url).search : window.location.search
+  );
+  return searchParams.get(key);
+}
+function getAllQueryParams(url) {
+  const searchParams = new URLSearchParams(
+    url ? new URL(url).search : window.location.search
+  );
+  const params = {};
+  searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+function getQueryParamAll(key, url) {
+  const searchParams = new URLSearchParams(
+    url ? new URL(url).search : window.location.search
+  );
+  return searchParams.getAll(key);
+}
+
+// src/device/index.ts
+function getUserAgent() {
+  return navigator.userAgent.toLowerCase();
+}
+function getOS() {
+  const ua = getUserAgent();
+  if (ua.includes("win")) return "Windows";
+  if (ua.includes("mac")) return "MacOS";
+  if (ua.includes("linux")) return "Linux";
+  if (ua.includes("android")) return "Android";
+  if (ua.includes("iphone") || ua.includes("ipad") || ua.includes("ipod")) return "iOS";
+  return "Unknown";
+}
+function getBrowser() {
+  const ua = getUserAgent();
+  if (ua.includes("edg")) return "Edge";
+  if (ua.includes("chrome")) return "Chrome";
+  if (ua.includes("safari") && !ua.includes("chrome")) return "Safari";
+  if (ua.includes("firefox")) return "Firefox";
+  if (ua.includes("opera") || ua.includes("opr")) return "Opera";
+  if (ua.includes("trident") || ua.includes("msie")) return "IE";
+  return "Unknown";
+}
+function getBrowserEngine() {
+  const ua = getUserAgent();
+  if (ua.includes("trident")) return "Trident";
+  if (ua.includes("gecko") && !ua.includes("webkit")) return "Gecko";
+  if (ua.includes("webkit")) return "WebKit";
+  if (ua.includes("presto")) return "Presto";
+  return "Unknown";
+}
+function isMobile() {
+  const ua = getUserAgent();
+  return /mobile|android|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(ua);
+}
+function isTablet() {
+  const ua = getUserAgent();
+  return /ipad|android(?!.*mobile)|tablet/i.test(ua);
+}
+function isDesktop() {
+  return !isMobile() && !isTablet();
+}
+function getDeviceType() {
+  if (isMobile()) return "mobile";
+  if (isTablet()) return "tablet";
+  return "desktop";
+}
+function isWeChat() {
+  const ua = getUserAgent();
+  return /micromessenger/i.test(ua);
+}
+function isIOS() {
+  const ua = getUserAgent();
+  return /iphone|ipad|ipod/i.test(ua);
+}
+function isAndroid() {
+  const ua = getUserAgent();
+  return /android/i.test(ua);
+}
+function getBrowserVersion() {
+  const ua = navigator.userAgent;
+  const browser = getBrowser();
+  let match = null;
+  switch (browser) {
+    case "Chrome":
+      match = ua.match(/chrome\/([\d.]+)/i);
+      break;
+    case "Safari":
+      match = ua.match(/version\/([\d.]+)/i);
+      break;
+    case "Firefox":
+      match = ua.match(/firefox\/([\d.]+)/i);
+      break;
+    case "Edge":
+      match = ua.match(/edg\/([\d.]+)/i);
+      break;
+    case "Opera":
+      match = ua.match(/(?:opera|opr)\/([\d.]+)/i);
+      break;
+    case "IE":
+      match = ua.match(/(?:msie |rv:)([\d.]+)/i);
+      break;
+  }
+  return match ? match[1] : "Unknown";
+}
+function getDevicePixelRatio() {
+  return window.devicePixelRatio || 1;
+}
+function getScreenResolution() {
+  return {
+    width: window.screen.width,
+    height: window.screen.height
+  };
+}
+function getViewportSize() {
+  return {
+    width: window.innerWidth || document.documentElement.clientWidth,
+    height: window.innerHeight || document.documentElement.clientHeight
+  };
+}
+function isTouchDevice() {
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function getDeviceInfo() {
+  return {
+    os: getOS(),
+    browser: getBrowser(),
+    browserVersion: getBrowserVersion(),
+    browserEngine: getBrowserEngine(),
+    deviceType: getDeviceType(),
+    isMobile: isMobile(),
+    isTablet: isTablet(),
+    isDesktop: isDesktop(),
+    isIOS: isIOS(),
+    isAndroid: isAndroid(),
+    isWeChat: isWeChat(),
+    isTouchDevice: isTouchDevice(),
+    devicePixelRatio: getDevicePixelRatio(),
+    screenResolution: getScreenResolution(),
+    viewportSize: getViewportSize(),
+    userAgent: navigator.userAgent
+  };
+}
+
+// src/format/index.ts
+function formatMoney(amount, options = {}) {
+  const {
+    decimals = 2,
+    symbol = "\xA5",
+    separator = ",",
+    decimalPoint = "."
+  } = options;
+  const num = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(num)) {
+    return `${symbol}0${decimalPoint}${"0".repeat(decimals)}`;
+  }
+  const isNegative = num < 0;
+  const absNum = Math.abs(num);
+  const fixed = absNum.toFixed(decimals);
+  const [integerPart, decimalPart] = fixed.split(".");
+  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  let result = symbol + formattedInteger;
+  if (decimals > 0 && decimalPart) {
+    result += decimalPoint + decimalPart;
+  }
+  return isNegative ? `-${result}` : result;
+}
+function parseMoney(formattedAmount) {
+  if (!formattedAmount || typeof formattedAmount !== "string") {
+    return 0;
+  }
+  const cleaned = formattedAmount.replace(/[^\d.-]/g, "");
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? 0 : num;
+}
+function formatNumber(amount, decimals = 2) {
+  const num = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(num)) {
+    return "0." + "0".repeat(decimals);
+  }
+  const fixed = num.toFixed(decimals);
+  const [integerPart, decimalPart] = fixed.split(".");
+  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return decimals > 0 && decimalPart ? `${formattedInteger}.${decimalPart}` : formattedInteger;
+}
+function formatMoneyToChinese(amount) {
+  const num = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(num) || num < 0) {
+    return "\u96F6\u5143\u6574";
+  }
+  const digits = ["\u96F6", "\u58F9", "\u8D30", "\u53C1", "\u8086", "\u4F0D", "\u9646", "\u67D2", "\u634C", "\u7396"];
+  const units = ["", "\u62FE", "\u4F70", "\u4EDF"];
+  const bigUnits = ["", "\u4E07", "\u4EBF", "\u5146"];
+  const decimalUnits = ["\u89D2", "\u5206"];
+  const [integerPart, decimalPart] = num.toFixed(2).split(".");
+  let result = "";
+  if (integerPart === "0") {
+    result = "\u96F6\u5143";
+  } else {
+    const integerStr = integerPart;
+    const len = integerStr.length;
+    let zeroCount = 0;
+    for (let i = 0; i < len; i++) {
+      const digit = parseInt(integerStr[i]);
+      const unitIndex = (len - i - 1) % 4;
+      const bigUnitIndex = Math.floor((len - i - 1) / 4);
+      if (digit === 0) {
+        zeroCount++;
+      } else {
+        if (zeroCount > 0) {
+          result += "\u96F6";
+        }
+        result += digits[digit] + units[unitIndex];
+        zeroCount = 0;
+      }
+      if (unitIndex === 0 && bigUnitIndex > 0) {
+        if (result[result.length - 1] !== bigUnits[bigUnitIndex]) {
+          result += bigUnits[bigUnitIndex];
+        }
+      }
+    }
+    result += "\u5143";
+  }
+  if (decimalPart && decimalPart !== "00") {
+    const jiao = parseInt(decimalPart[0]);
+    const fen = parseInt(decimalPart[1]);
+    if (jiao > 0) {
+      result += digits[jiao] + decimalUnits[0];
+    } else if (fen > 0) {
+      result += "\u96F6";
+    }
+    if (fen > 0) {
+      result += digits[fen] + decimalUnits[1];
+    }
+  } else {
+    result += "\u6574";
+  }
+  return result;
+}
+function formatPercent(value, options = {}) {
+  const { decimals = 2, multiply: multiply2 = true } = options;
+  if (isNaN(value)) {
+    return "0%";
+  }
+  const num = multiply2 ? value * 100 : value;
+  return num.toFixed(decimals) + "%";
+}
+
+// src/date/index.ts
+var import_date_fns = require("date-fns");
+var import_locale = require("date-fns/locale");
+function formatDate(date, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.isValid)(dateObj) ? (0, import_date_fns.format)(dateObj, formatStr) : "";
+}
+function formatDateOnly(date) {
+  return formatDate(date, "yyyy-MM-dd");
+}
+function formatTimeOnly(date) {
+  return formatDate(date, "HH:mm:ss");
+}
+function formatRelativeTime(date, locale = "zh") {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  if (!(0, import_date_fns.isValid)(dateObj)) return "";
+  return (0, import_date_fns.formatDistanceToNow)(dateObj, {
+    addSuffix: true,
+    locale: locale === "zh" ? import_locale.zhCN : void 0
+  });
+}
+function parseDate(dateStr, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  return (0, import_date_fns.parse)(dateStr, formatStr, /* @__PURE__ */ new Date());
+}
+function isValidDate(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.isValid)(dateObj);
+}
+function getDaysDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns.differenceInDays)(left, right);
+}
+function getHoursDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns.differenceInHours)(left, right);
+}
+function getMinutesDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns.differenceInMinutes)(left, right);
+}
+function addDaysToDate(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.addDays)(dateObj, amount);
+}
+function subDaysFromDate(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.subDays)(dateObj, amount);
+}
+function addMonthsToDate(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.addMonths)(dateObj, amount);
+}
+function subMonthsFromDate(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.subMonths)(dateObj, amount);
+}
+function getStartOfDay(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.startOfDay)(dateObj);
+}
+function getEndOfDay(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.endOfDay)(dateObj);
+}
+function getStartOfWeek(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.startOfWeek)(dateObj, { weekStartsOn: 1 });
+}
+function getEndOfWeek(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.endOfWeek)(dateObj, { weekStartsOn: 1 });
+}
+function getStartOfMonth(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.startOfMonth)(dateObj);
+}
+function getEndOfMonth(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.endOfMonth)(dateObj);
+}
+function getStartOfYear(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.startOfYear)(dateObj);
+}
+function getEndOfYear(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  return (0, import_date_fns.endOfYear)(dateObj);
+}
+function isBeforeDate(date, dateToCompare) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  const compareObj = typeof dateToCompare === "string" ? (0, import_date_fns.parseISO)(dateToCompare) : new Date(dateToCompare);
+  return (0, import_date_fns.isBefore)(dateObj, compareObj);
+}
+function isAfterDate(date, dateToCompare) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns.parseISO)(date) : new Date(date);
+  const compareObj = typeof dateToCompare === "string" ? (0, import_date_fns.parseISO)(dateToCompare) : new Date(dateToCompare);
+  return (0, import_date_fns.isAfter)(dateObj, compareObj);
+}
+function isSameDayDate(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns.isSameDay)(left, right);
+}
+function getTimestamp() {
+  return Date.now();
+}
+function getTimestampInSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/date/utc/index.ts
+var import_date_fns2 = require("date-fns");
+var import_date_fns_tz = require("date-fns-tz");
+var UTC_TIMEZONE = "UTC";
+function toUTC(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns_tz.fromZonedTime)(dateObj, Intl.DateTimeFormat().resolvedOptions().timeZone);
+}
+function fromUTC(utcDate) {
+  const dateObj = typeof utcDate === "string" ? (0, import_date_fns2.parseISO)(utcDate) : new Date(utcDate);
+  return (0, import_date_fns_tz.toZonedTime)(dateObj, Intl.DateTimeFormat().resolvedOptions().timeZone);
+}
+function formatUTC(date, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  if (!(0, import_date_fns2.isValid)(dateObj)) return "";
+  return (0, import_date_fns_tz.formatInTimeZone)(dateObj, UTC_TIMEZONE, formatStr);
+}
+function formatUTCDateOnly(date) {
+  return formatUTC(date, "yyyy-MM-dd");
+}
+function formatUTCTimeOnly(date) {
+  return formatUTC(date, "HH:mm:ss");
+}
+function toISOString(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return dateObj.toISOString();
+}
+function getUTCNow() {
+  return /* @__PURE__ */ new Date();
+}
+function getUTCTimestamp() {
+  return Date.now();
+}
+function getUTCTimestampInSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function getUTCStartOfDay(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  const utcDate = (0, import_date_fns_tz.toZonedTime)(dateObj, UTC_TIMEZONE);
+  return (0, import_date_fns2.startOfDay)(utcDate);
+}
+function getUTCEndOfDay(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  const utcDate = (0, import_date_fns_tz.toZonedTime)(dateObj, UTC_TIMEZONE);
+  return (0, import_date_fns2.endOfDay)(utcDate);
+}
+function getUTCStartOfMonth(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  const utcDate = (0, import_date_fns_tz.toZonedTime)(dateObj, UTC_TIMEZONE);
+  return (0, import_date_fns2.startOfMonth)(utcDate);
+}
+function getUTCEndOfMonth(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  const utcDate = (0, import_date_fns_tz.toZonedTime)(dateObj, UTC_TIMEZONE);
+  return (0, import_date_fns2.endOfMonth)(utcDate);
+}
+function addDaysUTC(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns2.addDays)(dateObj, amount);
+}
+function subDaysUTC(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns2.subDays)(dateObj, amount);
+}
+function addMonthsUTC(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns2.addMonths)(dateObj, amount);
+}
+function subMonthsUTC(date, amount) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns2.subMonths)(dateObj, amount);
+}
+function getUTCDaysDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns2.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns2.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns2.differenceInDays)(left, right);
+}
+function getUTCHoursDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns2.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns2.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns2.differenceInHours)(left, right);
+}
+function getUTCMinutesDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? (0, import_date_fns2.parseISO)(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? (0, import_date_fns2.parseISO)(dateRight) : new Date(dateRight);
+  return (0, import_date_fns2.differenceInMinutes)(left, right);
+}
+function getTimezoneOffset() {
+  return (/* @__PURE__ */ new Date()).getTimezoneOffset();
+}
+function getTimezoneOffsetHours() {
+  return -(/* @__PURE__ */ new Date()).getTimezoneOffset() / 60;
+}
+function getUTCYearStartTimestamp(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const date = new Date(Date.UTC(targetYear, 0, 1, 0, 0, 0, 0));
+  return date.getTime();
+}
+function getUTCYearEndTimestamp(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const date = new Date(Date.UTC(targetYear, 11, 31, 23, 59, 59, 999));
+  return date.getTime();
+}
+function getUTCYearStart(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  return new Date(Date.UTC(targetYear, 0, 1, 0, 0, 0, 0));
+}
+function getUTCYearEnd(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  return new Date(Date.UTC(targetYear, 11, 31, 23, 59, 59, 999));
+}
+function getUTCWeeksInYear(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const date = new Date(Date.UTC(targetYear, 0, 1));
+  return (0, import_date_fns2.getISOWeeksInYear)(date);
+}
+function getUTCWeekStart(year, week) {
+  const date = new Date(Date.UTC(year, 0, 4));
+  const weekDate = (0, import_date_fns2.setISOWeek)(date, week);
+  return (0, import_date_fns2.startOfWeek)(weekDate, { weekStartsOn: 1 });
+}
+function getUTCWeekEnd(year, week) {
+  const date = new Date(Date.UTC(year, 0, 4));
+  const weekDate = (0, import_date_fns2.setISOWeek)(date, week);
+  return (0, import_date_fns2.endOfWeek)(weekDate, { weekStartsOn: 1 });
+}
+function getUTCAllWeeksInYear(year) {
+  const targetYear = year ?? (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const weeksCount = getUTCWeeksInYear(targetYear);
+  const weeks = [];
+  for (let week = 1; week <= weeksCount; week++) {
+    const start = getUTCWeekStart(targetYear, week);
+    const end = getUTCWeekEnd(targetYear, week);
+    weeks.push({
+      week,
+      start,
+      end,
+      startTimestamp: start.getTime(),
+      endTimestamp: end.getTime()
+    });
+  }
+  return weeks;
+}
+function getUTCWeekNumber(date) {
+  const dateObj = typeof date === "string" ? (0, import_date_fns2.parseISO)(date) : new Date(date);
+  return (0, import_date_fns2.getISOWeek)(dateObj);
+}
+
+// src/decimal/index.ts
+var import_decimal = __toESM(require("decimal.js"), 1);
+
+// src/decimal/utils/index.ts
+var import_decimal2 = __toESM(require("decimal.js"), 1);
+function safeDecimal(value) {
+  try {
+    if (value instanceof import_decimal2.default) {
+      return value;
+    }
+    const decimal = new import_decimal2.default(value);
+    if (decimal.isNaN()) {
+      return new import_decimal2.default(0);
+    }
+    return decimal;
+  } catch {
+    return new import_decimal2.default(0);
+  }
+}
+function add(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.plus(decimalB).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function subtract(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.minus(decimalB).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function multiply(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.times(decimalB).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function divide(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    if (decimalB.isZero()) {
+      return 0;
+    }
+    return decimalA.dividedBy(decimalB).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function equals(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.equals(decimalB);
+  } catch {
+    return false;
+  }
+}
+function greaterThan(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.greaterThan(decimalB);
+  } catch {
+    return false;
+  }
+}
+function lessThan(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.lessThan(decimalB);
+  } catch {
+    return false;
+  }
+}
+function greaterThanOrEqual(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.greaterThanOrEqualTo(decimalB);
+  } catch {
+    return false;
+  }
+}
+function lessThanOrEqual(a, b) {
+  try {
+    const decimalA = safeDecimal(a);
+    const decimalB = safeDecimal(b);
+    return decimalA.lessThanOrEqualTo(decimalB);
+  } catch {
+    return false;
+  }
+}
+function round(value, decimalPlaces = 2) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.toDecimalPlaces(decimalPlaces).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function ceil(value, decimalPlaces = 2) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.toDecimalPlaces(decimalPlaces, import_decimal2.default.ROUND_CEIL).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function floor(value, decimalPlaces = 2) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.toDecimalPlaces(decimalPlaces, import_decimal2.default.ROUND_FLOOR).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function abs(value) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.abs().toNumber();
+  } catch {
+    return 0;
+  }
+}
+function negate(value) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.negated().toNumber();
+  } catch {
+    return 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Decimal,
+  abs,
+  add,
+  addDaysToDate,
+  addDaysUTC,
+  addMonthsToDate,
+  addMonthsUTC,
+  ceil,
+  debounce,
+  divide,
+  equals,
+  floor,
+  formatDate,
+  formatDateOnly,
+  formatMoney,
+  formatMoneyToChinese,
+  formatNumber,
+  formatPercent,
+  formatRelativeTime,
+  formatTimeOnly,
+  formatUTC,
+  formatUTCDateOnly,
+  formatUTCTimeOnly,
+  fromUTC,
+  getAllQueryParams,
+  getBrowser,
+  getBrowserEngine,
+  getBrowserVersion,
+  getDaysDiff,
+  getDeviceInfo,
+  getDevicePixelRatio,
+  getDeviceType,
+  getEndOfDay,
+  getEndOfMonth,
+  getEndOfWeek,
+  getEndOfYear,
+  getHoursDiff,
+  getMinutesDiff,
+  getOS,
+  getQueryParam,
+  getQueryParamAll,
+  getScreenResolution,
+  getStartOfDay,
+  getStartOfMonth,
+  getStartOfWeek,
+  getStartOfYear,
+  getTimestamp,
+  getTimestampInSeconds,
+  getTimezoneOffset,
+  getTimezoneOffsetHours,
+  getUTCAllWeeksInYear,
+  getUTCDaysDiff,
+  getUTCEndOfDay,
+  getUTCEndOfMonth,
+  getUTCHoursDiff,
+  getUTCMinutesDiff,
+  getUTCNow,
+  getUTCStartOfDay,
+  getUTCStartOfMonth,
+  getUTCTimestamp,
+  getUTCTimestampInSeconds,
+  getUTCWeekEnd,
+  getUTCWeekNumber,
+  getUTCWeekStart,
+  getUTCWeeksInYear,
+  getUTCYearEnd,
+  getUTCYearEndTimestamp,
+  getUTCYearStart,
+  getUTCYearStartTimestamp,
+  getViewportSize,
+  greaterThan,
+  greaterThanOrEqual,
+  isAfterDate,
+  isAndroid,
+  isBeforeDate,
+  isDesktop,
+  isIOS,
+  isMobile,
+  isSameDayDate,
+  isTablet,
+  isTouchDevice,
+  isValidDate,
+  isWeChat,
+  lessThan,
+  lessThanOrEqual,
+  multiply,
+  negate,
+  parseDate,
+  parseMoney,
+  round,
+  subDaysFromDate,
+  subDaysUTC,
+  subMonthsFromDate,
+  subMonthsUTC,
+  subtract,
+  throttle,
+  toISOString,
+  toUTC
+});