react-util-tools 1.0.0

package/dist/index.js

@@ -0,0 +1,852 @@
+// 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
+import {
+  format as dateFnsFormat,
+  parse,
+  parseISO,
+  isValid,
+  differenceInDays,
+  differenceInHours,
+  differenceInMinutes,
+  addDays,
+  addMonths,
+  subDays,
+  subMonths,
+  startOfDay,
+  endOfDay,
+  startOfWeek,
+  endOfWeek,
+  startOfMonth,
+  endOfMonth,
+  startOfYear,
+  endOfYear,
+  isBefore,
+  isAfter,
+  isSameDay,
+  formatDistanceToNow
+} from "date-fns";
+import { zhCN } from "date-fns/locale";
+function formatDate(date, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return isValid(dateObj) ? dateFnsFormat(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" ? parseISO(date) : new Date(date);
+  if (!isValid(dateObj)) return "";
+  return formatDistanceToNow(dateObj, {
+    addSuffix: true,
+    locale: locale === "zh" ? zhCN : void 0
+  });
+}
+function parseDate(dateStr, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  return parse(dateStr, formatStr, /* @__PURE__ */ new Date());
+}
+function isValidDate(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return isValid(dateObj);
+}
+function getDaysDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO(dateRight) : new Date(dateRight);
+  return differenceInDays(left, right);
+}
+function getHoursDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO(dateRight) : new Date(dateRight);
+  return differenceInHours(left, right);
+}
+function getMinutesDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO(dateRight) : new Date(dateRight);
+  return differenceInMinutes(left, right);
+}
+function addDaysToDate(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return addDays(dateObj, amount);
+}
+function subDaysFromDate(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return subDays(dateObj, amount);
+}
+function addMonthsToDate(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return addMonths(dateObj, amount);
+}
+function subMonthsFromDate(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return subMonths(dateObj, amount);
+}
+function getStartOfDay(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return startOfDay(dateObj);
+}
+function getEndOfDay(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return endOfDay(dateObj);
+}
+function getStartOfWeek(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return startOfWeek(dateObj, { weekStartsOn: 1 });
+}
+function getEndOfWeek(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return endOfWeek(dateObj, { weekStartsOn: 1 });
+}
+function getStartOfMonth(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return startOfMonth(dateObj);
+}
+function getEndOfMonth(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return endOfMonth(dateObj);
+}
+function getStartOfYear(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return startOfYear(dateObj);
+}
+function getEndOfYear(date) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  return endOfYear(dateObj);
+}
+function isBeforeDate(date, dateToCompare) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  const compareObj = typeof dateToCompare === "string" ? parseISO(dateToCompare) : new Date(dateToCompare);
+  return isBefore(dateObj, compareObj);
+}
+function isAfterDate(date, dateToCompare) {
+  const dateObj = typeof date === "string" ? parseISO(date) : new Date(date);
+  const compareObj = typeof dateToCompare === "string" ? parseISO(dateToCompare) : new Date(dateToCompare);
+  return isAfter(dateObj, compareObj);
+}
+function isSameDayDate(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO(dateRight) : new Date(dateRight);
+  return isSameDay(left, right);
+}
+function getTimestamp() {
+  return Date.now();
+}
+function getTimestampInSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/date/utc/index.ts
+import {
+  parseISO as parseISO2,
+  isValid as isValid2,
+  addDays as addDays2,
+  addMonths as addMonths2,
+  subDays as subDays2,
+  subMonths as subMonths2,
+  startOfDay as startOfDay2,
+  endOfDay as endOfDay2,
+  startOfMonth as startOfMonth2,
+  endOfMonth as endOfMonth2,
+  startOfWeek as startOfWeek2,
+  endOfWeek as endOfWeek2,
+  differenceInDays as differenceInDays2,
+  differenceInHours as differenceInHours2,
+  differenceInMinutes as differenceInMinutes2,
+  getISOWeek,
+  getISOWeeksInYear,
+  setISOWeek
+} from "date-fns";
+import { formatInTimeZone, toZonedTime, fromZonedTime } from "date-fns-tz";
+var UTC_TIMEZONE = "UTC";
+function toUTC(date) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  return fromZonedTime(dateObj, Intl.DateTimeFormat().resolvedOptions().timeZone);
+}
+function fromUTC(utcDate) {
+  const dateObj = typeof utcDate === "string" ? parseISO2(utcDate) : new Date(utcDate);
+  return toZonedTime(dateObj, Intl.DateTimeFormat().resolvedOptions().timeZone);
+}
+function formatUTC(date, formatStr = "yyyy-MM-dd HH:mm:ss") {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  if (!isValid2(dateObj)) return "";
+  return 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" ? parseISO2(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" ? parseISO2(date) : new Date(date);
+  const utcDate = toZonedTime(dateObj, UTC_TIMEZONE);
+  return startOfDay2(utcDate);
+}
+function getUTCEndOfDay(date) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  const utcDate = toZonedTime(dateObj, UTC_TIMEZONE);
+  return endOfDay2(utcDate);
+}
+function getUTCStartOfMonth(date) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  const utcDate = toZonedTime(dateObj, UTC_TIMEZONE);
+  return startOfMonth2(utcDate);
+}
+function getUTCEndOfMonth(date) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  const utcDate = toZonedTime(dateObj, UTC_TIMEZONE);
+  return endOfMonth2(utcDate);
+}
+function addDaysUTC(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  return addDays2(dateObj, amount);
+}
+function subDaysUTC(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  return subDays2(dateObj, amount);
+}
+function addMonthsUTC(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  return addMonths2(dateObj, amount);
+}
+function subMonthsUTC(date, amount) {
+  const dateObj = typeof date === "string" ? parseISO2(date) : new Date(date);
+  return subMonths2(dateObj, amount);
+}
+function getUTCDaysDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO2(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO2(dateRight) : new Date(dateRight);
+  return differenceInDays2(left, right);
+}
+function getUTCHoursDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO2(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO2(dateRight) : new Date(dateRight);
+  return differenceInHours2(left, right);
+}
+function getUTCMinutesDiff(dateLeft, dateRight) {
+  const left = typeof dateLeft === "string" ? parseISO2(dateLeft) : new Date(dateLeft);
+  const right = typeof dateRight === "string" ? parseISO2(dateRight) : new Date(dateRight);
+  return differenceInMinutes2(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 getISOWeeksInYear(date);
+}
+function getUTCWeekStart(year, week) {
+  const date = new Date(Date.UTC(year, 0, 4));
+  const weekDate = setISOWeek(date, week);
+  return startOfWeek2(weekDate, { weekStartsOn: 1 });
+}
+function getUTCWeekEnd(year, week) {
+  const date = new Date(Date.UTC(year, 0, 4));
+  const weekDate = setISOWeek(date, week);
+  return endOfWeek2(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" ? parseISO2(date) : new Date(date);
+  return getISOWeek(dateObj);
+}
+
+// src/decimal/index.ts
+import { default as default2 } from "decimal.js";
+
+// src/decimal/utils/index.ts
+import Decimal from "decimal.js";
+function safeDecimal(value) {
+  try {
+    if (value instanceof Decimal) {
+      return value;
+    }
+    const decimal = new Decimal(value);
+    if (decimal.isNaN()) {
+      return new Decimal(0);
+    }
+    return decimal;
+  } catch {
+    return new Decimal(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, Decimal.ROUND_CEIL).toNumber();
+  } catch {
+    return 0;
+  }
+}
+function floor(value, decimalPlaces = 2) {
+  try {
+    const decimal = safeDecimal(value);
+    return decimal.toDecimalPlaces(decimalPlaces, Decimal.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;
+  }
+}
+export {
+  default2 as Decimal,
+  abs,
+  add,
+  addDaysToDate,
+  addDaysUTC,
+  addMonthsToDate,
+  addMonthsUTC,
+  ceil,
+  debounceFn as 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,
+  throttleFn as throttle,
+  toISOString,
+  toUTC
+};