ly-utils-lib 1.0.11 → 2.4.0

package/dist/index.js

@@ -0,0 +1,3294 @@
+import dayjs from 'dayjs';
+export { default as dayjs } from 'dayjs';
+import durationPlugin from 'dayjs/plugin/duration';
+import isBetweenPlugin from 'dayjs/plugin/isBetween';
+import isSameOrAfterPlugin from 'dayjs/plugin/isSameOrAfter';
+import isSameOrBeforePlugin from 'dayjs/plugin/isSameOrBefore';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import weekYear from 'dayjs/plugin/weekYear';
+import isLeapYearPlugin from 'dayjs/plugin/isLeapYear';
+import dayOfYear from 'dayjs/plugin/dayOfYear';
+import minMax from 'dayjs/plugin/minMax';
+import weekday from 'dayjs/plugin/weekday';
+import 'dayjs/locale/zh-cn';
+import { uniqBy, uniq, sum, sortBy, sample, omit, last, isEqual, intersection, head, groupBy, flattenDeep, flatten, difference, compact, chunk, upperFirst, trim, startCase, snakeCase, lowerFirst, kebabCase, capitalize, camelCase, pick, merge, isEmptyObject, invert, cloneDeep, throttle, debounce } from 'es-toolkit';
+import * as XLSX from 'xlsx';
+import html2canvas from 'html2canvas';
+import { jsPDF } from 'jspdf';
+import { Map as Map$1, View, Feature } from 'ol';
+import { defaults, ScaleLine, FullScreen } from 'ol/control';
+import { Point, LineString, Polygon } from 'ol/geom';
+import { Draw, Snap, Modify, Select } from 'ol/interaction';
+import Overlay from 'ol/Overlay';
+import TileLayer from 'ol/layer/Tile';
+import VectorLayer from 'ol/layer/Vector';
+import { fromLonLat, transform, toLonLat } from 'ol/proj';
+import OSM from 'ol/source/OSM';
+import VectorSource from 'ol/source/Vector';
+import XYZ from 'ol/source/XYZ';
+import GeoJSON from 'ol/format/GeoJSON';
+import { Style, Icon, Circle, Stroke, Fill } from 'ol/style';
+import { boundingExtent } from 'ol/extent';
+import Cookies from 'js-cookie';
+import * as CryptoJS from 'crypto-js';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/modules/date/index.ts
+var date_exports = {};
+__export(date_exports, {
+  add: () => add,
+  clone: () => clone,
+  compare: () => compare,
+  computeDate: () => computeDate,
+  dayjs: () => dayjs,
+  default: () => date_default,
+  diff: () => diff,
+  diffDays: () => diffDays,
+  diffHours: () => diffHours,
+  endDate: () => endDate,
+  endOf: () => endOf,
+  format: () => format,
+  formatDuration: () => formatDuration,
+  formatTimestamp: () => formatTimestamp,
+  fromNow: () => fromNow,
+  fromUTC: () => fromUTC,
+  fromUnix: () => fromUnix,
+  getAge: () => getAge,
+  getChineseYear: () => getChineseYear,
+  getDate: () => getDate,
+  getDateRange: () => getDateRange,
+  getDay: () => getDay,
+  getDayOfYear: () => getDayOfYear,
+  getDaysInMonth: () => getDaysInMonth,
+  getFirstDayOfMonth: () => getFirstDayOfMonth,
+  getFirstDayOfMonthDate: () => getFirstDayOfMonthDate,
+  getFirstDayOfWeek: () => getFirstDayOfWeek,
+  getFirstDayOfYear: () => getFirstDayOfYear,
+  getHolidayName: () => getHolidayName,
+  getHour: () => getHour,
+  getLastDayOfMonth: () => getLastDayOfMonth,
+  getLastDayOfMonthDate: () => getLastDayOfMonthDate,
+  getLastDayOfWeek: () => getLastDayOfWeek,
+  getLastDayOfYear: () => getLastDayOfYear,
+  getMinute: () => getMinute,
+  getMonth: () => getMonth,
+  getMonthRange: () => getMonthRange,
+  getQuarter: () => getQuarter,
+  getQuarterRange: () => getQuarterRange,
+  getRangeDate: () => getRangeDate,
+  getRecentDays: () => getRecentDays,
+  getRecentMonths: () => getRecentMonths,
+  getRecentWeeks: () => getRecentWeeks,
+  getRelativeTime: () => getRelativeTime,
+  getSecond: () => getSecond,
+  getTime: () => getTime,
+  getTimeOfDay: () => getTimeOfDay,
+  getTimeOfDayName: () => getTimeOfDayName,
+  getTimestamp: () => getTimestamp,
+  getTimezoneOffset: () => getTimezoneOffset,
+  getWeek: () => getWeek,
+  getWeekRange: () => getWeekRange,
+  getWeekday: () => getWeekday,
+  getWeekdayName: () => getWeekdayName,
+  getWorkdaysBetween: () => getWorkdaysBetween,
+  getYear: () => getYear,
+  getYearRange: () => getYearRange,
+  getZodiacSign: () => getZodiacSign,
+  isAfter: () => isAfter,
+  isBefore: () => isBefore,
+  isBetween: () => isBetween,
+  isHoliday: () => isHoliday,
+  isLeapYear: () => isLeapYear,
+  isSame: () => isSame,
+  isSameMonth: () => isSameMonth,
+  isSameOrAfter: () => isSameOrAfter,
+  isSameOrBefore: () => isSameOrBefore,
+  isSameYear: () => isSameYear,
+  isThisMonth: () => isThisMonth,
+  isThisWeek: () => isThisWeek,
+  isThisYear: () => isThisYear,
+  isToday: () => isToday,
+  isTomorrow: () => isTomorrow,
+  isValid: () => isValid,
+  isWeekend: () => isWeekend,
+  isWorkday: () => isWorkday,
+  isYesterday: () => isYesterday,
+  maxDate: () => maxDate,
+  minDate: () => minDate,
+  now: () => now,
+  parse: () => parse,
+  startDate: () => startDate,
+  startOf: () => startOf,
+  subtract: () => subtract,
+  toNow: () => toNow,
+  toTimezone: () => toTimezone,
+  toUTC: () => toUTC,
+  unix: () => unix,
+  valueOf: () => valueOf
+});
+dayjs.extend(relativeTime);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(durationPlugin);
+dayjs.extend(isBetweenPlugin);
+dayjs.extend(isSameOrBeforePlugin);
+dayjs.extend(isSameOrAfterPlugin);
+dayjs.extend(weekOfYear);
+dayjs.extend(weekYear);
+dayjs.extend(quarterOfYear);
+dayjs.extend(isLeapYearPlugin);
+dayjs.extend(dayOfYear);
+dayjs.extend(minMax);
+dayjs.extend(weekday);
+dayjs.locale("zh-cn");
+var now = () => dayjs();
+var format = (date, formatStr = "YYYY-MM-DD HH:mm:ss") => {
+  return dayjs(date).format(formatStr);
+};
+var getDate = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).format("YYYY-MM-DD");
+};
+var getTime = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).format("HH:mm:ss");
+};
+var getTimestamp = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).valueOf();
+};
+var add = (date, amount, unit = "day") => {
+  return dayjs(date).add(amount, unit);
+};
+var subtract = (date, amount, unit = "day") => {
+  return dayjs(date).subtract(amount, unit);
+};
+var startOf = (date, unit = "day") => {
+  return dayjs(date).startOf(unit);
+};
+var endOf = (date, unit = "day") => {
+  return dayjs(date).endOf(unit);
+};
+var diffDays = (date1, date2) => {
+  return dayjs(date1).diff(dayjs(date2), "day");
+};
+var diffHours = (date1, date2) => {
+  return dayjs(date1).diff(dayjs(date2), "hour");
+};
+var isToday = (date) => {
+  return dayjs(date).isSame(dayjs(), "day");
+};
+var isYesterday = (date) => {
+  return dayjs(date).isSame(dayjs().subtract(1, "day"), "day");
+};
+var isTomorrow = (date) => {
+  return dayjs(date).isSame(dayjs().add(1, "day"), "day");
+};
+var isBetween = (date, startDate2, endDate2) => {
+  return dayjs(date).isBetween(startDate2, endDate2, null, "[]");
+};
+var fromNow = (date) => {
+  return dayjs(date).fromNow();
+};
+var getWeek = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).week();
+};
+var computeDate = (compute, date = /* @__PURE__ */ new Date(), type = "day", num = 1, format2 = "YYYY-MM-DD") => {
+  const d = dayjs(date);
+  if (compute === "after") {
+    return d.add(num, type).format(format2);
+  }
+  if (compute === "before") {
+    return d.subtract(num, type).format(format2);
+  }
+  return d.format(format2);
+};
+var startDate = (type = "month", format2 = "YYYY-MM-DD") => {
+  return dayjs().startOf(type).format(format2);
+};
+var endDate = (type = "month", format2 = "YYYY-MM-DD") => {
+  return dayjs().endOf(type).format(format2);
+};
+var formatTimestamp = (timestamp = 0, format2 = "YYYY-MM-DD HH:mm:ss") => {
+  const ts = timestamp === 0 ? getTimestamp() / 1e3 : timestamp;
+  return dayjs.unix(ts).format(format2);
+};
+var diff = (type, startDate2, endDate2 = /* @__PURE__ */ new Date()) => {
+  return dayjs(endDate2).diff(dayjs(startDate2), type);
+};
+var getRangeDate = (startDate2, endDate2, format2 = "YYYY-MM-DD") => {
+  const diffDays2 = diff("day", startDate2, endDate2);
+  const range = [];
+  for (let i = 0; i <= diffDays2; i++) {
+    const day = computeDate("after", startDate2, "day", i, format2);
+    range.push({
+      day,
+      timestamp: getTimestamp(day) / 1e3
+    });
+  }
+  return range;
+};
+var getRelativeTime = (date) => {
+  const diffMinutes = diff("minute", date);
+  if (diffMinutes < 1) {
+    return "\u521A\u521A";
+  }
+  if (diffMinutes < 60) {
+    return `${diffMinutes}\u5206\u949F\u524D`;
+  }
+  if (diffMinutes < 1440) {
+    return `${Math.floor(diffMinutes / 60)}\u5C0F\u65F6\u524D`;
+  }
+  if (diffMinutes < 43200) {
+    return `${Math.floor(diffMinutes / 1440)}\u5929\u524D`;
+  }
+  return format(date, "YYYY-MM-DD");
+};
+var isValid = (date) => {
+  return dayjs(date).isValid();
+};
+var getFirstDayOfMonth = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).date() - dayjs(date).startOf("month").date() + 1;
+};
+var getLastDayOfMonth = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).endOf("month").date();
+};
+var getQuarter = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).quarter();
+};
+var getDaysInMonth = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).daysInMonth();
+};
+var getMonthRange = (date = /* @__PURE__ */ new Date()) => {
+  const d = dayjs(date);
+  return [d.startOf("month").format("YYYY-MM-DD"), d.endOf("month").format("YYYY-MM-DD")];
+};
+var getQuarterRange = (date = /* @__PURE__ */ new Date()) => {
+  const d = dayjs(date);
+  const quarter = d.quarter();
+  const start = d.month((quarter - 1) * 3).startOf("month").format("YYYY-MM-DD");
+  const end = d.month(quarter * 3 - 1).endOf("month").format("YYYY-MM-DD");
+  return [start, end];
+};
+var getYearRange = (date = /* @__PURE__ */ new Date()) => {
+  const d = dayjs(date);
+  return [d.startOf("year").format("YYYY-MM-DD"), d.endOf("year").format("YYYY-MM-DD")];
+};
+var getWeekRange = (date = /* @__PURE__ */ new Date(), startDay = 0) => {
+  const d = dayjs(date);
+  const day = d.day();
+  const diff3 = day < startDay ? 7 - startDay + day : day - startDay;
+  const start = d.subtract(diff3, "day").format("YYYY-MM-DD");
+  const end = d.subtract(diff3, "day").add(6, "day").format("YYYY-MM-DD");
+  return [start, end];
+};
+var isLeapYear = (year) => {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
+var getYear = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).year();
+};
+var getMonth = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).month() + 1;
+};
+var getDay = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).date();
+};
+var getHour = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).hour();
+};
+var getMinute = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).minute();
+};
+var getSecond = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).second();
+};
+var getWeekday = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).day();
+};
+var getWeekdayName = (date = /* @__PURE__ */ new Date()) => {
+  const weekdays = ["\u661F\u671F\u65E5", "\u661F\u671F\u4E00", "\u661F\u671F\u4E8C", "\u661F\u671F\u4E09", "\u661F\u671F\u56DB", "\u661F\u671F\u4E94", "\u661F\u671F\u516D"];
+  return weekdays[dayjs(date).day()];
+};
+var getDayOfYear = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).dayOfYear();
+};
+var getFirstDayOfWeek = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).weekday(0);
+};
+var getLastDayOfWeek = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).weekday(6);
+};
+var getFirstDayOfMonthDate = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).startOf("month");
+};
+var getLastDayOfMonthDate = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).endOf("month");
+};
+var getFirstDayOfYear = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).startOf("year");
+};
+var getLastDayOfYear = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).endOf("year");
+};
+var isSame = (date1, date2, unit = "day") => {
+  return dayjs(date1).isSame(date2, unit);
+};
+var compare = (date1, date2) => {
+  const d1 = dayjs(date1).valueOf();
+  const d2 = dayjs(date2).valueOf();
+  if (d1 > d2) return 1;
+  if (d1 < d2) return -1;
+  return 0;
+};
+var isSameOrBefore = (date1, date2) => {
+  return dayjs(date1).isSameOrBefore(date2);
+};
+var isSameOrAfter = (date1, date2) => {
+  return dayjs(date1).isSameOrAfter(date2);
+};
+var isBefore = (date1, date2) => {
+  return dayjs(date1).isBefore(date2);
+};
+var isAfter = (date1, date2) => {
+  return dayjs(date1).isAfter(date2);
+};
+var getAge = (birthday) => {
+  return dayjs().diff(birthday, "year");
+};
+var isWorkday = (date = /* @__PURE__ */ new Date()) => {
+  const day = dayjs(date).day();
+  return day !== 0 && day !== 6;
+};
+var isWeekend = (date = /* @__PURE__ */ new Date()) => {
+  const day = dayjs(date).day();
+  return day === 0 || day === 6;
+};
+var getTimeOfDay = (date = /* @__PURE__ */ new Date()) => {
+  const hour = dayjs(date).hour();
+  if (hour >= 5 && hour < 9) return "morning";
+  if (hour >= 9 && hour < 12) return "noon";
+  if (hour >= 12 && hour < 18) return "afternoon";
+  if (hour >= 18 && hour < 22) return "evening";
+  return "night";
+};
+var getTimeOfDayName = (date = /* @__PURE__ */ new Date()) => {
+  const timeOfDay = getTimeOfDay(date);
+  const names = {
+    morning: "\u6E05\u6668",
+    noon: "\u4E0A\u5348",
+    afternoon: "\u4E0B\u5348",
+    evening: "\u665A\u4E0A",
+    night: "\u6DF1\u591C"
+  };
+  return names[timeOfDay];
+};
+var getWorkdaysBetween = (startDate2, endDate2) => {
+  let count = 0;
+  const start = dayjs(startDate2);
+  const end = dayjs(endDate2);
+  const days = Math.abs(start.diff(end, "day"));
+  for (let i = 0; i <= days; i++) {
+    const current = start.add(i, "day");
+    if (isWorkday(current)) {
+      count++;
+    }
+  }
+  return count;
+};
+var getDateRange = (startDate2, endDate2, unit = "day") => {
+  const start = dayjs(startDate2);
+  const end = dayjs(endDate2);
+  const dates = [];
+  const diff3 = end.diff(start, unit);
+  for (let i = 0; i <= diff3; i++) {
+    dates.push(start.add(i, unit));
+  }
+  return dates;
+};
+var getRecentDays = (days) => {
+  const dates = [];
+  for (let i = 0; i < days; i++) {
+    dates.push(dayjs().subtract(i, "day"));
+  }
+  return dates.reverse();
+};
+var getRecentMonths = (months) => {
+  const dates = [];
+  for (let i = 0; i < months; i++) {
+    dates.push(dayjs().subtract(i, "month"));
+  }
+  return dates.reverse();
+};
+var getRecentWeeks = (weeks) => {
+  const dates = [];
+  for (let i = 0; i < weeks; i++) {
+    dates.push(dayjs().subtract(i, "week"));
+  }
+  return dates.reverse();
+};
+var toUTC = (date) => {
+  return dayjs(date).utc();
+};
+var fromUTC = (date) => {
+  return dayjs.utc(date).local();
+};
+var toTimezone = (date, timezone2) => {
+  return dayjs(date).tz(timezone2);
+};
+var getTimezoneOffset = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).utcOffset();
+};
+var formatDuration = (milliseconds) => {
+  const d = dayjs.duration(milliseconds);
+  const hours = Math.floor(d.asHours());
+  const minutes = d.minutes();
+  const seconds = d.seconds();
+  if (hours > 0) {
+    return `${hours}\u5C0F\u65F6${minutes}\u5206${seconds}\u79D2`;
+  }
+  if (minutes > 0) {
+    return `${minutes}\u5206${seconds}\u79D2`;
+  }
+  return `${seconds}\u79D2`;
+};
+var minDate = (dates) => {
+  return dayjs.min(dates.map((d) => dayjs(d)));
+};
+var maxDate = (dates) => {
+  return dayjs.max(dates.map((d) => dayjs(d)));
+};
+var isThisMonth = (date) => {
+  return dayjs(date).isSame(dayjs(), "month");
+};
+var isThisYear = (date) => {
+  return dayjs(date).isSame(dayjs(), "year");
+};
+var isThisWeek = (date) => {
+  return dayjs(date).isSame(dayjs(), "week");
+};
+var isSameMonth = (date1, date2) => {
+  return dayjs(date1).isSame(date2, "month");
+};
+var isSameYear = (date1, date2) => {
+  return dayjs(date1).isSame(date2, "year");
+};
+var getChineseYear = (date = /* @__PURE__ */ new Date()) => {
+  const animals = ["\u9F20", "\u725B", "\u864E", "\u5154", "\u9F99", "\u86C7", "\u9A6C", "\u7F8A", "\u7334", "\u9E21", "\u72D7", "\u732A"];
+  const baseYear = 1900;
+  const year = dayjs(date).year();
+  const index = (year - baseYear) % 12;
+  return animals[index >= 0 ? index : index + 12] + "\u5E74";
+};
+var getZodiacSign = (date = /* @__PURE__ */ new Date()) => {
+  const month = dayjs(date).month() + 1;
+  const day = dayjs(date).date();
+  if (month === 3 && day >= 21 || month === 4 && day <= 19) return "\u767D\u7F8A\u5EA7";
+  if (month === 4 && day >= 20 || month === 5 && day <= 20) return "\u91D1\u725B\u5EA7";
+  if (month === 5 && day >= 21 || month === 6 && day <= 20) return "\u53CC\u5B50\u5EA7";
+  if (month === 6 && day >= 21 || month === 7 && day <= 22) return "\u5DE8\u87F9\u5EA7";
+  if (month === 7 && day >= 23 || month === 8 && day <= 22) return "\u72EE\u5B50\u5EA7";
+  if (month === 8 && day >= 23 || month === 9 && day <= 22) return "\u5904\u5973\u5EA7";
+  if (month === 9 && day >= 23 || month === 10 && day <= 22) return "\u5929\u79E4\u5EA7";
+  if (month === 10 && day >= 23 || month === 11 && day <= 21) return "\u5929\u874E\u5EA7";
+  if (month === 11 && day >= 22 || month === 12 && day <= 21) return "\u5C04\u624B\u5EA7";
+  if (month === 12 && day >= 22 || month === 1 && day <= 19) return "\u6469\u7FAF\u5EA7";
+  if (month === 1 && day >= 20 || month === 2 && day <= 18) return "\u6C34\u74F6\u5EA7";
+  return "\u53CC\u9C7C\u5EA7";
+};
+var isHoliday = (date = /* @__PURE__ */ new Date()) => {
+  const holidays = {
+    "0101": "\u5143\u65E6",
+    "0214": "\u60C5\u4EBA\u8282",
+    "0308": "\u5987\u5973\u8282",
+    "0401": "\u611A\u4EBA\u8282",
+    "0501": "\u52B3\u52A8\u8282",
+    "0504": "\u9752\u5E74\u8282",
+    "0601": "\u513F\u7AE5\u8282",
+    "0701": "\u5EFA\u515A\u8282",
+    "0801": "\u5EFA\u519B\u8282",
+    "0910": "\u6559\u5E08\u8282",
+    "1001": "\u56FD\u5E86\u8282",
+    "1224": "\u5E73\u5B89\u591C",
+    "1225": "\u5723\u8BDE\u8282"
+  };
+  const month = dayjs(date).format("MM");
+  const day = dayjs(date).format("DD");
+  const key = `${month}${day}`;
+  return holidays[key] !== void 0;
+};
+var getHolidayName = (date = /* @__PURE__ */ new Date()) => {
+  const holidays = {
+    "0101": "\u5143\u65E6",
+    "0214": "\u60C5\u4EBA\u8282",
+    "0308": "\u5987\u5973\u8282",
+    "0401": "\u611A\u4EBA\u8282",
+    "0501": "\u52B3\u52A8\u8282",
+    "0504": "\u9752\u5E74\u8282",
+    "0601": "\u513F\u7AE5\u8282",
+    "0701": "\u5EFA\u515A\u8282",
+    "0801": "\u5EFA\u519B\u8282",
+    "0910": "\u6559\u5E08\u8282",
+    "1001": "\u56FD\u5E86\u8282",
+    "1224": "\u5E73\u5B89\u591C",
+    "1225": "\u5723\u8BDE\u8282"
+  };
+  const month = dayjs(date).format("MM");
+  const day = dayjs(date).format("DD");
+  const key = `${month}${day}`;
+  return holidays[key] || null;
+};
+var parse = (dateString, formatStr) => {
+  return formatStr ? dayjs(dateString, formatStr) : dayjs(dateString);
+};
+var toNow = (date) => {
+  return dayjs(date).toNow();
+};
+var clone = (date) => {
+  return dayjs(date).clone();
+};
+var unix = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).unix();
+};
+var fromUnix = (timestamp) => {
+  return dayjs.unix(timestamp);
+};
+var valueOf = (date = /* @__PURE__ */ new Date()) => {
+  return dayjs(date).valueOf();
+};
+var date_default = dayjs;
+
+// src/modules/array/index.ts
+var array_exports = {};
+__export(array_exports, {
+  arrayToTree: () => arrayToTree,
+  average: () => average,
+  chunk: () => chunk,
+  compact: () => compact,
+  difference: () => difference,
+  filter: () => filter,
+  find: () => find,
+  findIndex: () => findIndex,
+  flatten: () => flatten,
+  flattenDeep: () => flattenDeep,
+  getPaginationInfo: () => getPaginationInfo,
+  groupBy: () => groupBy,
+  head: () => head,
+  includes: () => includes,
+  insert: () => insert,
+  intersection: () => intersection,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  last: () => last,
+  map: () => map,
+  max: () => max,
+  maxValue: () => maxValue,
+  min: () => min,
+  minValue: () => minValue,
+  move: () => move,
+  omit: () => omit,
+  paginate: () => paginate,
+  reduceSum: () => reduceSum,
+  remove: () => remove,
+  removeAt: () => removeAt,
+  sample: () => sample,
+  shuffle: () => shuffle,
+  sortBy: () => sortBy,
+  split: () => split,
+  sum: () => sum,
+  treeToArray: () => treeToArray,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  unique: () => unique
+});
+var unique = (arr, key) => {
+  if (key) {
+    return uniqBy(arr, (item) => item[key]);
+  }
+  return uniq(arr);
+};
+var min = (arr) => {
+  if (arr.length === 0) return void 0;
+  return Math.min(...arr);
+};
+var max = (arr) => {
+  if (arr.length === 0) return void 0;
+  return Math.max(...arr);
+};
+var isEmpty = (arr) => {
+  return arr.length === 0;
+};
+var split = (arr, size2) => {
+  const result = [];
+  for (let i = 0; i < arr.length; i += size2) {
+    result.push(arr.slice(i, i + size2));
+  }
+  return result;
+};
+var 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;
+};
+var findIndex = (arr, predicate) => {
+  return arr.findIndex(predicate);
+};
+var find = (arr, predicate) => {
+  return arr.find(predicate);
+};
+var filter = (arr, predicate) => {
+  return arr.filter(predicate);
+};
+var map = (arr, mapper) => {
+  return arr.map(mapper);
+};
+var reduceSum = (arr, mapper) => {
+  if (mapper) {
+    return arr.reduce((acc, item) => acc + mapper(item), 0);
+  }
+  return arr.reduce((acc, item) => acc + item, 0);
+};
+var average = (arr, mapper) => {
+  if (arr.length === 0) return 0;
+  if (mapper) {
+    const sum3 = arr.reduce((acc, item) => acc + mapper(item), 0);
+    return sum3 / arr.length;
+  }
+  return arr.reduce((acc, item) => acc + item, 0) / arr.length;
+};
+var maxValue = (arr, mapper) => {
+  if (arr.length === 0) return void 0;
+  if (mapper) {
+    return Math.max(...arr.map(mapper));
+  }
+  return Math.max(...arr);
+};
+var minValue = (arr, mapper) => {
+  if (arr.length === 0) return void 0;
+  if (mapper) {
+    return Math.min(...arr.map(mapper));
+  }
+  return Math.min(...arr);
+};
+var includes = (arr, value) => {
+  return arr.includes(value);
+};
+var remove = (arr, value) => {
+  return arr.filter((item) => item !== value);
+};
+var removeAt = (arr, index) => {
+  return arr.filter((_, i) => i !== index);
+};
+var insert = (arr, index, value) => {
+  return [...arr.slice(0, index), value, ...arr.slice(index)];
+};
+var move = (arr, from, to) => {
+  const result = [...arr];
+  const [removed] = result.splice(from, 1);
+  result.splice(to, 0, removed);
+  return result;
+};
+var arrayToTree = (arr, options = {}) => {
+  const { idKey = "id", parentIdKey = "parentId", childrenKey = "children" } = options;
+  const map2 = /* @__PURE__ */ new Map();
+  const roots = [];
+  arr.forEach((item) => {
+    map2.set(item[idKey], { ...item, [childrenKey]: [] });
+  });
+  map2.forEach((item) => {
+    const parentId = item[parentIdKey];
+    if (parentId && map2.has(parentId)) {
+      const parent = map2.get(parentId);
+      if (parent) {
+        parent[childrenKey].push(item);
+      }
+    } else {
+      roots.push(item);
+    }
+  });
+  return roots;
+};
+var treeToArray = (tree, childrenKey = "children") => {
+  const result = [];
+  const traverse = (nodes) => {
+    nodes.forEach((node) => {
+      result.push(node);
+      if (node[childrenKey] && node[childrenKey].length > 0) {
+        traverse(node[childrenKey]);
+      }
+    });
+  };
+  traverse(tree);
+  return result;
+};
+var paginate = (arr, page, pageSize) => {
+  const start = (page - 1) * pageSize;
+  return arr.slice(start, start + pageSize);
+};
+var getPaginationInfo = (total, page, pageSize) => {
+  const totalPages = Math.ceil(total / pageSize);
+  const startIndex = (page - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, total);
+  return {
+    total,
+    page,
+    pageSize,
+    totalPages,
+    startIndex,
+    endIndex,
+    hasNext: page < totalPages,
+    hasPrev: page > 1
+  };
+};
+
+// src/modules/string/index.ts
+var string_exports = {};
+__export(string_exports, {
+  byteLength: () => byteLength,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  escapeHtml: () => escapeHtml,
+  extractEmails: () => extractEmails,
+  extractNumbers: () => extractNumbers,
+  extractPhones: () => extractPhones,
+  firstLowerCase: () => firstLowerCase,
+  firstUpperCase: () => firstUpperCase,
+  formatMoney: () => formatMoney,
+  getExtension: () => getExtension,
+  getFileName: () => getFileName,
+  hideEmail: () => hideEmail,
+  hideIdCard: () => hideIdCard,
+  hidePhone: () => hidePhone,
+  highlight: () => highlight,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty2,
+  isIdCard: () => isIdCard,
+  isPhone: () => isPhone,
+  isUrl: () => isUrl,
+  kebabCase: () => kebabCase,
+  lowerFirst: () => lowerFirst,
+  pad: () => pad,
+  random: () => random,
+  repeat: () => repeat,
+  reverse: () => reverse,
+  shortId: () => shortId,
+  snakeCase: () => snakeCase,
+  startCase: () => startCase,
+  stripTags: () => stripTags,
+  toBoolean: () => toBoolean,
+  toNumber: () => toNumber,
+  trim: () => trim,
+  truncateText: () => truncateText,
+  unescapeHtml: () => unescapeHtml,
+  upperFirst: () => upperFirst,
+  uuid: () => uuid
+});
+var isEmpty2 = (str) => {
+  if (!str) return true;
+  return trim(str).length === 0;
+};
+var random = (length = 8, charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") => {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+};
+var uuid = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var shortId = (length = 6) => {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+};
+var firstUpperCase = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var firstLowerCase = (str) => {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+};
+var reverse = (str) => {
+  return str.split("").reverse().join("");
+};
+var repeat = (str, count) => {
+  return str.repeat(count);
+};
+var pad = (str, length, char = "0", isEnd = false) => {
+  const s = String(str);
+  if (isEnd) {
+    return s.padEnd(length, char);
+  }
+  return s.padStart(length, char);
+};
+var getExtension = (filename) => {
+  const idx = filename.lastIndexOf(".");
+  if (idx === -1) return "";
+  return filename.slice(idx + 1);
+};
+var getFileName = (filename) => {
+  const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+  const nameWithExt = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
+  const lastDot = nameWithExt.lastIndexOf(".");
+  return lastDot === -1 ? nameWithExt : nameWithExt.slice(0, lastDot);
+};
+var hidePhone = (phone) => {
+  return phone.replace(/(\d{3})\d{4}(\d{4})/, "$1****$2");
+};
+var hideEmail = (email) => {
+  const [username, domain] = email.split("@");
+  if (username.length <= 2) return email;
+  return `${username[0]}${"*".repeat(username.length - 2)}${username[username.length - 1]}@${domain}`;
+};
+var hideIdCard = (idCard) => {
+  if (idCard.length < 8) return idCard;
+  return `${idCard.slice(0, 4)}${"*".repeat(idCard.length - 8)}${idCard.slice(-4)}`;
+};
+var formatMoney = (amount, decimals = 2, separator = ",") => {
+  const str = amount.toFixed(decimals);
+  const parts = str.split(".");
+  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  return parts.join(".");
+};
+var toNumber = (str, defaultValue = 0) => {
+  if (typeof str === "number") return str;
+  if (!str) return defaultValue;
+  const num = Number(str);
+  return isNaN(num) ? defaultValue : num;
+};
+var toBoolean = (str, defaultValue = false) => {
+  if (typeof str === "boolean") return str;
+  if (!str) return defaultValue;
+  return ["true", "1", "yes", "on"].includes(str.toLowerCase());
+};
+var extractNumbers = (str) => {
+  const matches = str.match(/-?\d+(\.\d+)?/g);
+  return matches ? matches.map(Number) : [];
+};
+var extractPhones = (str) => {
+  const matches = str.match(/1[3-9]\d{9}/g);
+  return matches || [];
+};
+var extractEmails = (str) => {
+  const matches = str.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g);
+  return matches || [];
+};
+var isPhone = (phone) => {
+  return /^1[3-9]\d{9}$/.test(phone);
+};
+var isEmail = (email) => {
+  return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email);
+};
+var isIdCard = (idCard) => {
+  return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(idCard);
+};
+var isUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var highlight = (text, keyword, highlightClass = "highlight") => {
+  if (!keyword) return text;
+  const regex = new RegExp(`(${keyword})`, "gi");
+  return text.replace(regex, `<span class="${highlightClass}">$1</span>`);
+};
+var truncateText = (text, length = 100, suffix = "...") => {
+  if (text.length <= length) return text;
+  return text.slice(0, length) + suffix;
+};
+var escapeHtml = (str) => {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+};
+var unescapeHtml = (str) => {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&(amp|lt|gt|quot|#39);/g, (match) => htmlUnescapes[match]);
+};
+var stripTags = (str) => {
+  return str.replace(/<[^>]*>/g, "");
+};
+var byteLength = (str) => {
+  let len = 0;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code >= 1 && code <= 126) {
+      len += 1;
+    } else if (code >= 128 && code <= 2047) {
+      len += 2;
+    } else if (code >= 2048 && code <= 65535) {
+      len += 3;
+    } else {
+      len += 4;
+    }
+  }
+  return len;
+};
+
+// src/modules/object/index.ts
+var object_exports = {};
+__export(object_exports, {
+  clear: () => clear,
+  cloneDeep: () => cloneDeep,
+  deepFreeze: () => deepFreeze,
+  deepMerge: () => deepMerge,
+  deleteDeep: () => deleteDeep,
+  diff: () => diff2,
+  entries: () => entries,
+  filter: () => filter2,
+  first: () => first,
+  fromPairs: () => fromPairs,
+  fromQueryString: () => fromQueryString,
+  get: () => get,
+  getDeep: () => getDeep,
+  groupBy: () => groupBy,
+  groupByPath: () => groupByPath,
+  has: () => has,
+  hasDeep: () => hasDeep,
+  invert: () => invert,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isEmpty: () => isEmpty3,
+  isEmptyObject: () => isEmptyObject,
+  isEqual: () => isEqual,
+  isFunction: () => isFunction,
+  isNil: () => isNil,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  keys: () => keys,
+  last: () => last2,
+  mapKeys: () => mapKeys,
+  mapValues: () => mapValues,
+  merge: () => merge,
+  omit: () => omit,
+  pick: () => pick,
+  renameKeys: () => renameKeys,
+  set: () => set,
+  setDeep: () => setDeep,
+  size: () => size,
+  sortKeys: () => sortKeys,
+  toFormData: () => toFormData,
+  toQueryString: () => toQueryString,
+  values: () => values
+});
+var keys = (obj) => {
+  return Object.keys(obj);
+};
+var values = (obj) => {
+  return Object.values(obj);
+};
+var entries = (obj) => {
+  return Object.entries(obj);
+};
+var fromPairs = (pairs) => {
+  const result = {};
+  for (const [key, value] of pairs) {
+    result[key] = value;
+  }
+  return result;
+};
+var get = (obj, path, defaultValue) => {
+  const keys2 = path.split(".");
+  let result = obj;
+  for (const key of keys2) {
+    if (result === null || result === void 0) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+};
+var set = (obj, path, value) => {
+  const keys2 = path.split(".");
+  let result = obj;
+  for (let i = 0; i < keys2.length - 1; i++) {
+    const key = keys2[i];
+    if (!(key in result) || typeof result[key] !== "object") {
+      result[key] = {};
+    }
+    result = result[key];
+  }
+  result[keys2[keys2.length - 1]] = value;
+};
+var has = (obj, path) => {
+  const keys2 = path.split(".");
+  let result = obj;
+  for (const key of keys2) {
+    if (result === null || result === void 0 || !(key in result)) {
+      return false;
+    }
+    result = result[key];
+  }
+  return true;
+};
+var isEmpty3 = (obj) => {
+  if (obj === null || obj === void 0) return true;
+  if (Array.isArray(obj)) return obj.length === 0;
+  if (typeof obj === "object") return isEmptyObject(obj);
+  return false;
+};
+var deepMerge = (target, ...sources) => {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (isObject(sourceValue)) {
+          if (!isObject(targetValue)) {
+            target[key] = {};
+          }
+          deepMerge(target[key], sourceValue);
+        } else {
+          target[key] = sourceValue;
+        }
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+};
+var isObject = (obj) => {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+};
+var isArray = (obj) => {
+  return Array.isArray(obj);
+};
+var isFunction = (obj) => {
+  return typeof obj === "function";
+};
+var isNumber = (obj) => {
+  return typeof obj === "number" && !isNaN(obj);
+};
+var isString = (obj) => {
+  return typeof obj === "string";
+};
+var isBoolean = (obj) => {
+  return typeof obj === "boolean";
+};
+var isNil = (obj) => {
+  return obj === null || obj === void 0;
+};
+var isNull = (obj) => {
+  return obj === null;
+};
+var isUndefined = (obj) => {
+  return obj === void 0;
+};
+var size = (obj) => {
+  return Object.keys(obj).length;
+};
+var clear = (obj) => {
+  Object.keys(obj).forEach((key) => {
+    delete obj[key];
+  });
+  return obj;
+};
+var toQueryString = (obj) => {
+  return Object.entries(obj).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+};
+var fromQueryString = (queryString) => {
+  const params = {};
+  const pairs = queryString.slice(1).split("&");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=");
+    if (key) {
+      params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : "";
+    }
+  }
+  return params;
+};
+var sortKeys = (obj, compareFn) => {
+  const sortedKeys = Object.keys(obj).sort(compareFn);
+  const result = {};
+  for (const key of sortedKeys) {
+    result[key] = obj[key];
+  }
+  return result;
+};
+var renameKeys = (obj, renameMap) => {
+  const result = {};
+  for (const key in obj) {
+    const newKey = renameMap[key] || key;
+    result[newKey] = obj[key];
+  }
+  return result;
+};
+var filter2 = (obj, predicate) => {
+  const result = {};
+  for (const key in obj) {
+    if (predicate(obj[key], key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+};
+var mapValues = (obj, mapper) => {
+  const result = {};
+  for (const key in obj) {
+    result[key] = mapper(obj[key], key);
+  }
+  return result;
+};
+var mapKeys = (obj, mapper) => {
+  const result = {};
+  for (const key in obj) {
+    const newKey = mapper(key, obj[key]);
+    result[newKey] = obj[key];
+  }
+  return result;
+};
+var getDeep = (obj, path, defaultValue) => {
+  return get(obj, path, defaultValue);
+};
+var setDeep = (obj, path, value) => {
+  set(obj, path, value);
+};
+var hasDeep = (obj, path) => {
+  return has(obj, path);
+};
+var deleteDeep = (obj, path) => {
+  const keys2 = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys2.length - 1; i++) {
+    if (!current[keys2[i]]) {
+      return false;
+    }
+    current = current[keys2[i]];
+  }
+  const lastKey = keys2[keys2.length - 1];
+  if (lastKey in current) {
+    delete current[lastKey];
+    return true;
+  }
+  return false;
+};
+var toFormData = (obj) => {
+  const formData = new FormData();
+  for (const key in obj) {
+    const value = obj[key];
+    if (value !== void 0 && value !== null) {
+      if (value instanceof File) {
+        formData.append(key, value);
+      } else if (Array.isArray(value)) {
+        formData.append(key, JSON.stringify(value));
+      } else if (typeof value === "object") {
+        formData.append(key, JSON.stringify(value));
+      } else {
+        formData.append(key, String(value));
+      }
+    }
+  }
+  return formData;
+};
+var diff2 = (obj, base) => {
+  const result = {};
+  for (const key in obj) {
+    if (!isEqual(obj[key], base[key])) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+};
+var deepFreeze = (obj) => {
+  if (isObject(obj) || isArray(obj)) {
+    Object.freeze(obj);
+    for (const key in obj) {
+      deepFreeze(obj[key]);
+    }
+  }
+  return obj;
+};
+var first = (obj) => {
+  const values2 = Object.values(obj);
+  return values2[0];
+};
+var last2 = (obj) => {
+  const values2 = Object.values(obj);
+  return values2[values2.length - 1];
+};
+var groupByPath = (arr, keyPath) => {
+  return groupBy(arr, (item) => get(item, keyPath));
+};
+
+// src/modules/excel/index.ts
+var excel_exports = {};
+__export(excel_exports, {
+  excelToTable: () => excelToTable,
+  exportExcel: () => exportExcel,
+  exportExcelWithColumnWidths: () => exportExcelWithColumnWidths,
+  exportExcelWithHeaders: () => exportExcelWithHeaders,
+  exportExcelWithMerges: () => exportExcelWithMerges,
+  exportMultiSheetExcel: () => exportMultiSheetExcel,
+  exportTableToExcel: () => exportTableToExcel,
+  getSheetNames: () => getSheetNames,
+  importAllSheetsExcel: () => importAllSheetsExcel,
+  importExcel: () => importExcel
+});
+var exportExcel = (data, options = {}) => {
+  const { filename = "export.xlsx", sheetName = "Sheet1", header } = options;
+  const processedData = header ? data.map((item) => {
+    const row = {};
+    for (const key in header) {
+      row[header[key]] = item[key];
+    }
+    return row;
+  }) : data;
+  const worksheet = XLSX.utils.json_to_sheet(processedData);
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+  XLSX.writeFile(workbook, filename);
+};
+var exportMultiSheetExcel = (sheetsData, filename = "export.xlsx") => {
+  const workbook = XLSX.utils.book_new();
+  sheetsData.forEach(({ name, data, header }) => {
+    const processedData = header ? data.map((item) => {
+      const row = {};
+      for (const key in header) {
+        row[header[key]] = item[key];
+      }
+      return row;
+    }) : data;
+    const worksheet = XLSX.utils.json_to_sheet(processedData);
+    XLSX.utils.book_append_sheet(workbook, worksheet, name);
+  });
+  XLSX.writeFile(workbook, filename);
+};
+var importExcel = (file, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const { header = 0, raw = false, defval = "" } = options;
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        const data = e.target?.result;
+        if (!data) {
+          throw new Error("Failed to read file");
+        }
+        const workbook = XLSX.read(data, { type: "binary" });
+        const sheetName = workbook.SheetNames[0];
+        const worksheet = workbook.Sheets[sheetName];
+        const jsonData = XLSX.utils.sheet_to_json(worksheet, {
+          header,
+          raw,
+          defval
+        });
+        resolve(jsonData);
+      } catch (error) {
+        reject(new Error(String(error)));
+      }
+    };
+    reader.onerror = (error) => {
+      reject(new Error(String(error)));
+    };
+    if (file instanceof File) {
+      reader.readAsBinaryString(file);
+    } else {
+      reader.readAsBinaryString(new Blob([file]));
+    }
+  });
+};
+var importAllSheetsExcel = (file, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const { header = 0, raw = false, defval = "" } = options;
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        const data = e.target?.result;
+        if (!data) {
+          throw new Error("Failed to read file");
+        }
+        const workbook = XLSX.read(data, { type: "binary" });
+        const result = {};
+        workbook.SheetNames.forEach((sheetName) => {
+          const worksheet = workbook.Sheets[sheetName];
+          result[sheetName] = XLSX.utils.sheet_to_json(worksheet, {
+            header,
+            raw,
+            defval
+          });
+        });
+        resolve(result);
+      } catch (error) {
+        reject(new Error(String(error)));
+      }
+    };
+    reader.onerror = (error) => {
+      reject(new Error(String(error)));
+    };
+    if (file instanceof File) {
+      reader.readAsBinaryString(file);
+    } else {
+      reader.readAsBinaryString(new Blob([file]));
+    }
+  });
+};
+var exportExcelWithHeaders = (data, headers, filename = "export.xlsx", sheetName = "Sheet1") => {
+  const worksheet = XLSX.utils.json_to_sheet([]);
+  XLSX.utils.sheet_add_aoa(worksheet, [headers.map((h) => h.label)], { origin: "A1" });
+  const rows = data.map((item) => headers.map((h) => item[h.key]));
+  XLSX.utils.sheet_add_aoa(worksheet, rows, { origin: "A2" });
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+  XLSX.writeFile(workbook, filename);
+};
+var exportExcelWithColumnWidths = (data, columnWidths, options = {}) => {
+  const { filename = "export.xlsx", sheetName = "Sheet1", header } = options;
+  const processedData = header ? data.map((item) => {
+    const row = {};
+    for (const key in header) {
+      row[header[key]] = item[key];
+    }
+    return row;
+  }) : data;
+  const worksheet = XLSX.utils.json_to_sheet(processedData);
+  worksheet["!cols"] = columnWidths;
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+  XLSX.writeFile(workbook, filename);
+};
+var exportExcelWithMerges = (data, merges, options = {}) => {
+  const { filename = "export.xlsx", sheetName = "Sheet1", header } = options;
+  const processedData = header ? data.map((item) => {
+    const row = {};
+    for (const key in header) {
+      row[header[key]] = item[key];
+    }
+    return row;
+  }) : data;
+  const worksheet = XLSX.utils.json_to_sheet(processedData);
+  worksheet["!merges"] = merges;
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+  XLSX.writeFile(workbook, filename);
+};
+var getSheetNames = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        const data = e.target?.result;
+        if (!data) {
+          throw new Error("Failed to read file");
+        }
+        const workbook = XLSX.read(data, { type: "binary" });
+        resolve(workbook.SheetNames);
+      } catch (error) {
+        reject(new Error(String(error)));
+      }
+    };
+    reader.onerror = (error) => {
+      reject(new Error(String(error)));
+    };
+    if (file instanceof File) {
+      reader.readAsBinaryString(file);
+    } else {
+      reader.readAsBinaryString(new Blob([file]));
+    }
+  });
+};
+var exportTableToExcel = (tableElement, filename = "export.xlsx") => {
+  const workbook = XLSX.utils.table_to_book(tableElement);
+  XLSX.writeFile(workbook, filename);
+};
+var excelToTable = (file, sheetIndex = 0) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        const data = e.target?.result;
+        if (!data) {
+          throw new Error("Failed to read file");
+        }
+        const workbook = XLSX.read(data, { type: "binary" });
+        const sheetName = workbook.SheetNames[sheetIndex];
+        const worksheet = workbook.Sheets[sheetName];
+        const html = XLSX.utils.sheet_to_html(worksheet);
+        resolve(html);
+      } catch (error) {
+        reject(new Error(String(error)));
+      }
+    };
+    reader.onerror = (error) => {
+      reject(new Error(String(error)));
+    };
+    reader.readAsBinaryString(file);
+  });
+};
+
+// src/modules/pdf/index.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  addImageToPDF: () => addImageToPDF,
+  addPage: () => addPage,
+  addTableToPDF: () => addTableToPDF,
+  addTextToPDF: () => addTextToPDF,
+  captureToImage: () => captureToImage,
+  captureToImageDownload: () => captureToImageDownload,
+  captureToPDF: () => captureToPDF,
+  captureToPDFWithPagination: () => captureToPDFWithPagination,
+  createPDF: () => createPDF,
+  html2canvas: () => html2canvas,
+  jsPDF: () => jsPDF,
+  mergePDFs: () => mergePDFs,
+  pdfToBlob: () => pdfToBlob,
+  pdfToDataURL: () => pdfToDataURL,
+  savePDF: () => savePDF
+});
+var captureToPDF = async (element, options = {}) => {
+  const {
+    filename = "download.pdf",
+    scale = 2,
+    useCORS = true,
+    backgroundColor = "#ffffff",
+    logging = false,
+    margin = 10
+  } = options;
+  const canvas = await html2canvas(element, {
+    scale,
+    useCORS,
+    backgroundColor,
+    logging
+  });
+  const imgData = canvas.toDataURL("image/png");
+  const imgWidth = canvas.width;
+  const imgHeight = canvas.height;
+  const pdfWidth = imgWidth / scale;
+  const pdfHeight = imgHeight / scale;
+  const pdf = new jsPDF({
+    orientation: pdfWidth > pdfHeight ? "l" : "p",
+    unit: "pt",
+    format: [pdfWidth + margin * 2, pdfHeight + margin * 2]
+  });
+  pdf.addImage(imgData, "PNG", margin, margin, pdfWidth, pdfHeight);
+  pdf.save(filename);
+};
+var captureToPDFWithPagination = async (element, options = {}) => {
+  const {
+    filename = "download.pdf",
+    scale = 2,
+    useCORS = true,
+    backgroundColor = "#ffffff",
+    logging = false,
+    margin = 10
+  } = options;
+  const canvas = await html2canvas(element, {
+    scale,
+    useCORS,
+    backgroundColor,
+    logging
+  });
+  const imgData = canvas.toDataURL("image/png");
+  const imgWidth = canvas.width;
+  const imgHeight = canvas.height;
+  const pdf = new jsPDF("p", "pt", "a4");
+  const pdfWidth = pdf.internal.pageSize.getWidth();
+  const pdfHeight = pdf.internal.pageSize.getHeight();
+  const imgWidthInPDF = pdfWidth - margin * 2;
+  const imgHeightInPDF = imgHeight / imgWidth * imgWidthInPDF;
+  let heightLeft = imgHeightInPDF;
+  let position = margin;
+  pdf.addImage(imgData, "PNG", margin, position, imgWidthInPDF, imgHeightInPDF);
+  heightLeft -= pdfHeight - margin * 2;
+  while (heightLeft > 0) {
+    position = heightLeft - imgHeightInPDF + margin;
+    pdf.addPage();
+    pdf.addImage(imgData, "PNG", margin, position, imgWidthInPDF, imgHeightInPDF);
+    heightLeft -= pdfHeight - margin * 2;
+  }
+  pdf.save(filename);
+};
+var captureToImage = async (element, options = {}) => {
+  const canvas = await html2canvas(element, {
+    scale: 2,
+    useCORS: true,
+    backgroundColor: "#ffffff",
+    logging: false,
+    ...options
+  });
+  return canvas.toDataURL("image/png");
+};
+var captureToImageDownload = async (element, filename = "screenshot.png", options = {}) => {
+  const dataUrl = await captureToImage(element, options);
+  const link = document.createElement("a");
+  link.href = dataUrl;
+  link.download = filename;
+  link.click();
+};
+var createPDF = (options = {}) => {
+  return new jsPDF(options);
+};
+var addTextToPDF = (pdf, text, x, y, options = {}) => {
+  const { maxWidth, align = "left", fontSize = 12, fontStyle = "normal" } = options;
+  pdf.setFontSize(fontSize);
+  pdf.setFont("helvetica", fontStyle);
+  pdf.text(text, x, y, { maxWidth, align });
+};
+var addImageToPDF = (pdf, imageData, x, y, width, height) => {
+  pdf.addImage(imageData, "PNG", x, y, width, height);
+};
+var addTableToPDF = (pdf, headers, data, options = {}) => {
+  const {
+    x = 10,
+    y = 10,
+    cellWidth = 50,
+    cellHeight = 20,
+    headerBackgroundColor = "#4472C4",
+    headerTextColor = "#ffffff",
+    textColor = "#000000",
+    fontSize = 10,
+    lineWidth = 0.1,
+    lineColor = [200, 200, 200]
+  } = options;
+  pdf.setFontSize(fontSize);
+  let currentY = y;
+  headers.forEach((header, index) => {
+    const cellX = x + index * cellWidth;
+    pdf.setFillColor(
+      parseInt(headerBackgroundColor.slice(1, 3), 16),
+      parseInt(headerBackgroundColor.slice(3, 5), 16),
+      parseInt(headerBackgroundColor.slice(5, 7), 16)
+    );
+    pdf.rect(cellX, currentY, cellWidth, cellHeight, "F");
+    pdf.setDrawColor(lineColor[0], lineColor[1], lineColor[2]);
+    pdf.setLineWidth(lineWidth);
+    pdf.rect(cellX, currentY, cellWidth, cellHeight, "S");
+    pdf.setTextColor(
+      parseInt(headerTextColor.slice(1, 3), 16),
+      parseInt(headerTextColor.slice(3, 5), 16),
+      parseInt(headerTextColor.slice(5, 7), 16)
+    );
+    pdf.text(header, cellX + cellWidth / 2, currentY + cellHeight / 2 + fontSize / 4, {
+      align: "center"
+    });
+  });
+  currentY += cellHeight;
+  pdf.setTextColor(
+    parseInt(textColor.slice(1, 3), 16),
+    parseInt(textColor.slice(3, 5), 16),
+    parseInt(textColor.slice(5, 7), 16)
+  );
+  data.forEach((row) => {
+    row.forEach((cell, index) => {
+      const cellX = x + index * cellWidth;
+      pdf.setDrawColor(lineColor[0], lineColor[1], lineColor[2]);
+      pdf.setLineWidth(lineWidth);
+      pdf.rect(cellX, currentY, cellWidth, cellHeight, "S");
+      pdf.text(cell, cellX + cellWidth / 2, currentY + cellHeight / 2 + fontSize / 4, {
+        align: "center"
+      });
+    });
+    currentY += cellHeight;
+  });
+};
+var addPage = (pdf) => {
+  pdf.addPage();
+};
+var savePDF = (pdf, filename = "download.pdf") => {
+  pdf.save(filename);
+};
+var pdfToDataURL = (pdf) => {
+  return pdf.output("dataurlstring");
+};
+var pdfToBlob = (pdf) => {
+  return pdf.output("blob");
+};
+var mergePDFs = (_pdfs) => {
+  return Promise.reject(
+    new Error("mergePDFs \u529F\u80FD\u9700\u8981\u4F7F\u7528 pdf-lib \u5E93\u5B9E\u73B0\u3002\u8BF7\u5B89\u88C5 pdf-lib \u5E76\u4F7F\u7528\u5176\u63D0\u4F9B\u7684\u5408\u5E76\u529F\u80FD\u3002")
+  );
+};
+
+// src/modules/map/index.ts
+var map_exports = {};
+__export(map_exports, {
+  MapInstance: () => MapInstance,
+  createCircleStyle: () => createCircleStyle,
+  createFillStyle: () => createFillStyle,
+  createGaodeLayer: () => createGaodeLayer,
+  createIconStyle: () => createIconStyle,
+  createLineFeature: () => createLineFeature,
+  createOSMLayer: () => createOSMLayer,
+  createPointFeature: () => createPointFeature,
+  createPolygonFeature: () => createPolygonFeature,
+  createStrokeStyle: () => createStrokeStyle,
+  createStyledLineFeature: () => createStyledLineFeature,
+  createStyledPointFeature: () => createStyledPointFeature,
+  createStyledPolygonFeature: () => createStyledPolygonFeature,
+  createTiandituLayer: () => createTiandituLayer,
+  createXYZLayer: () => createXYZLayer,
+  lonLatToXY: () => lonLatToXY,
+  xyToLonLat: () => xyToLonLat
+});
+var MapInstance = class {
+  constructor(options) {
+    this.vectorSources = /* @__PURE__ */ new Map();
+    this.vectorLayers = /* @__PURE__ */ new Map();
+    this.overlays = /* @__PURE__ */ new Map();
+    this.themeLayers = /* @__PURE__ */ new Map();
+    this.drawInteraction = null;
+    this.modifyInteraction = null;
+    this.snapInteraction = null;
+    this.selectInteraction = null;
+    this.currentTheme = "light";
+    this.icons = /* @__PURE__ */ new Map();
+    this.enableDynamicScale = false;
+    this.projection = "EPSG:4326";
+    this.enableDynamicScale = options.enableDynamicScale || false;
+    this.projection = options.projection || "EPSG:4326";
+    this.currentTheme = options.theme || "light";
+    if (options.icons) {
+      Object.entries(options.icons).forEach(([name, config]) => {
+        this.icons.set(name, config);
+      });
+    }
+    const controls = defaults({
+      zoom: false,
+      rotate: false,
+      attribution: false
+    });
+    if (options.showScaleLine !== false) {
+      controls.push(new ScaleLine());
+    }
+    if (options.showFullScreen !== false) {
+      controls.push(new FullScreen());
+    }
+    this.map = new Map$1({
+      target: options.container,
+      layers: [],
+      view: new View({
+        center: fromLonLat(options.center || [116.3974, 39.9093]),
+        // 默认北京
+        zoom: options.zoom || 10,
+        minZoom: options.minZoom || 1,
+        maxZoom: options.maxZoom || 20,
+        projection: this.projection,
+        constrainResolution: true,
+        smoothResolutionConstraint: false
+      }),
+      controls
+    });
+    if (options.themeConfig) {
+      this.setupThemeLayers(options.themeConfig);
+    }
+    if (options.layers) {
+      options.layers.forEach((layer) => this.map.addLayer(layer.layer));
+    }
+    if (this.enableDynamicScale) {
+      this.map.on("moveend", () => this.handleZoomChange());
+    }
+  }
+  // ==================== 主题管理 ====================
+  /**
+   * 设置主题图层
+   */
+  setupThemeLayers(config) {
+    const lightUrl = config.lightUrl || "https://webrd0{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}";
+    const darkUrl = config.darkUrl || "https://webrd0{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=9&x={x}&y={y}&z={z}";
+    const lightLayer = new TileLayer({
+      preload: Infinity,
+      source: new XYZ({ url: lightUrl })
+    });
+    const darkLayer = new TileLayer({
+      preload: Infinity,
+      source: new XYZ({ url: darkUrl })
+    });
+    this.themeLayers.set("light", lightLayer);
+    this.themeLayers.set("dark", darkLayer);
+    this.map.addLayer(lightLayer);
+    this.map.addLayer(darkLayer);
+    this.setTheme(this.currentTheme);
+  }
+  /**
+   * 切换主题
+   */
+  setTheme(theme) {
+    this.currentTheme = theme;
+    this.themeLayers.forEach((layer, key) => {
+      layer.setVisible(key === theme);
+    });
+  }
+  /**
+   * 获取当前主题
+   */
+  getTheme() {
+    return this.currentTheme;
+  }
+  // ==================== 图层管理 ====================
+  /**
+   * 创建矢量图层
+   */
+  createVectorLayer(config) {
+    if (this.vectorLayers.has(config.name)) {
+      console.warn(`\u56FE\u5C42 "${config.name}" \u5DF2\u5B58\u5728`);
+      return;
+    }
+    const source = new VectorSource({
+      format: new GeoJSON()
+    });
+    const layer = new VectorLayer({
+      source,
+      style: config.style,
+      minZoom: config.minZoom,
+      maxZoom: config.maxZoom,
+      zIndex: config.zIndex,
+      visible: config.visible !== false
+    });
+    this.vectorSources.set(config.name, source);
+    this.vectorLayers.set(config.name, layer);
+    this.map.addLayer(layer);
+  }
+  /**
+   * 获取矢量图层
+   */
+  getVectorLayer(name) {
+    return this.vectorLayers.get(name);
+  }
+  /**
+   * 获取矢量数据源
+   */
+  getVectorSource(name) {
+    return this.vectorSources.get(name);
+  }
+  /**
+   * 显示/隐藏矢量图层
+   */
+  setLayerVisible(name, visible) {
+    const layer = this.vectorLayers.get(name);
+    if (layer) {
+      layer.setVisible(visible);
+    }
+  }
+  /**
+   * 设置矢量图层样式
+   */
+  setLayerStyle(name, style) {
+    const layer = this.vectorLayers.get(name);
+    if (layer) {
+      layer.setStyle(style);
+    }
+  }
+  /**
+   * 清除矢量图层
+   */
+  clearLayer(name) {
+    const source = this.vectorSources.get(name);
+    if (source) {
+      source.clear();
+    }
+  }
+  /**
+   * 删除矢量图层
+   */
+  removeLayer(name) {
+    const layer = this.vectorLayers.get(name);
+    if (layer) {
+      this.map.removeLayer(layer);
+      this.vectorLayers.delete(name);
+      this.vectorSources.delete(name);
+    }
+  }
+  // ==================== 要素管理 ====================
+  /**
+   * 添加标记
+   */
+  addMarker(options, layerName = "default") {
+    if (!this.vectorLayers.has(layerName)) {
+      this.createVectorLayer({ name: layerName });
+    }
+    const source = this.vectorSources.get(layerName);
+    const feature = new Feature({
+      geometry: new Point(fromLonLat(options.coordinate))
+    });
+    const style = options.style || this.createMarkerStyle(options);
+    feature.setStyle(style);
+    source.addFeature(feature);
+    return feature;
+  }
+  /**
+   * 创建标记样式
+   */
+  createMarkerStyle(options) {
+    if (options.icon && this.icons.has(options.icon)) {
+      const iconConfig = this.icons.get(options.icon);
+      return new Style({
+        image: new Icon({
+          anchor: iconConfig.anchor || [0.5, 0.5],
+          src: iconConfig.src,
+          scale: iconConfig.scale || 1
+        })
+      });
+    }
+    if (options.iconConfig) {
+      return new Style({
+        image: new Icon({
+          anchor: options.iconConfig.anchor || [0.5, 0.5],
+          src: options.iconConfig.src,
+          scale: options.iconConfig.scale || 1
+        })
+      });
+    }
+    return new Style({
+      image: new Circle({
+        radius: options.radius || 7,
+        fill: new Fill({ color: options.color || "#ff3333" }),
+        stroke: new Stroke({
+          color: options.strokeColor || "#ffffff",
+          width: options.strokeWidth || 2
+        })
+      })
+    });
+  }
+  /**
+   * 移除标记
+   */
+  removeMarker(feature, layerName = "default") {
+    const source = this.vectorSources.get(layerName);
+    if (source) {
+      source.removeFeature(feature);
+    }
+  }
+  /**
+   * 从 GeoJSON 添加要素
+   */
+  addFeaturesFromGeoJSON(geoJson, layerName = "default") {
+    if (!this.vectorLayers.has(layerName)) {
+      this.createVectorLayer({ name: layerName });
+    }
+    const source = this.vectorSources.get(layerName);
+    const format2 = new GeoJSON();
+    const features = format2.readFeatures(typeof geoJson === "string" ? geoJson : JSON.stringify(geoJson));
+    source.addFeatures(features);
+    return features;
+  }
+  /**
+   * 添加要素
+   */
+  addFeature(feature, layerName = "default") {
+    if (!this.vectorLayers.has(layerName)) {
+      this.createVectorLayer({ name: layerName });
+    }
+    const source = this.vectorSources.get(layerName);
+    source.addFeature(feature);
+  }
+  /**
+   * 批量添加要素
+   */
+  addFeatures(features, layerName = "default") {
+    if (!this.vectorLayers.has(layerName)) {
+      this.createVectorLayer({ name: layerName });
+    }
+    const source = this.vectorSources.get(layerName);
+    source.addFeatures(features);
+  }
+  /**
+   * 移除要素
+   */
+  removeFeature(feature, layerName = "default") {
+    const source = this.vectorSources.get(layerName);
+    if (source) {
+      source.removeFeature(feature);
+    }
+  }
+  /**
+   * 清除所有矢量要素
+   */
+  clearFeatures(layerName = "default") {
+    const source = this.vectorSources.get(layerName);
+    if (source) {
+      source.clear();
+    }
+  }
+  /**
+   * 获取图层中的所有要素
+   */
+  getFeatures(layerName = "default") {
+    const source = this.vectorSources.get(layerName);
+    return source ? source.getFeatures() : [];
+  }
+  /**
+   * 创建 GeoJSON
+   */
+  createGeoJSON(type, data) {
+    const coordinates = this.getCoordinates(type, data);
+    const id = this.generateUUID();
+    return {
+      type: "FeatureCollection",
+      features: [{
+        type: "Feature",
+        geometry: {
+          type,
+          coordinates
+        },
+        properties: {
+          id,
+          value: data
+        }
+      }]
+    };
+  }
+  /**
+   * 获取坐标
+   */
+  getCoordinates(type, data) {
+    if (type === "Point") {
+      return fromLonLat(transform(data.points, "EPSG:3857", "EPSG:4326"));
+    } else if (type === "LineString") {
+      return this.setPointArray(data.points);
+    } else if (type === "Polygon") {
+      return [this.setPointArray(data.points)];
+    }
+    return [];
+  }
+  /**
+   * 设置点数组
+   */
+  setPointArray(points) {
+    return points.map((item) => fromLonLat(transform(item, "EPSG:3857", "EPSG:4326")));
+  }
+  /**
+   * 生成 UUID
+   */
+  generateUUID() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * 设置要素样式
+   */
+  setFeatureStyle(feature, options) {
+    const style = this.createFeatureStyle(options);
+    feature.setStyle(style);
+  }
+  /**
+   * 创建要素样式
+   */
+  createFeatureStyle(options) {
+    if (options.style) {
+      return options.style;
+    }
+    if (options.icon && this.icons.has(options.icon)) {
+      const iconConfig = this.icons.get(options.icon);
+      return new Style({
+        image: new Icon({
+          anchor: iconConfig.anchor || [0.5, 0.5],
+          src: iconConfig.src,
+          scale: iconConfig.scale || 1
+        })
+      });
+    }
+    if (options.iconConfig) {
+      return new Style({
+        image: new Icon({
+          anchor: options.iconConfig.anchor || [0.5, 0.5],
+          src: options.iconConfig.src,
+          scale: options.iconConfig.scale || 1
+        })
+      });
+    }
+    return new Style({
+      stroke: new Stroke({
+        color: options.strokeColor || "#3388ff",
+        width: options.strokeWidth || 2
+      }),
+      fill: new Fill({
+        color: options.fillColor || "rgba(51, 136, 255, 0.2)"
+      }),
+      image: new Circle({
+        radius: 7,
+        fill: new Fill({ color: options.strokeColor || "#3388ff" }),
+        stroke: new Stroke({
+          color: "#ffffff",
+          width: 2
+        })
+      })
+    });
+  }
+  // ==================== 动态缩放 ====================
+  /**
+   * 处理缩放变化
+   */
+  handleZoomChange() {
+    const zoom = this.getZoom();
+    if (zoom !== void 0) {
+      this.updateIconScale(zoom);
+    }
+  }
+  /**
+   * 更新图标缩放比例
+   */
+  updateIconScale(zoom) {
+    let scale = 1;
+    if (zoom >= 14) {
+      scale = 0.5;
+    } else if (zoom < 14 && zoom >= 12) {
+      scale = 0.4;
+    } else if (zoom < 12) {
+      scale = 0.3;
+    }
+    this.vectorLayers.forEach((layer) => {
+      const features = layer.getSource()?.getFeatures();
+      if (features) {
+        features.forEach((feature) => {
+          const style = feature.getStyle();
+          if (style) {
+            const image = style.getImage();
+            if (image instanceof Icon) {
+              image.setScale(scale);
+            }
+          }
+        });
+      }
+    });
+  }
+  // ==================== Overlay 管理 ====================
+  /**
+   * 创建 Overlay
+   */
+  createOverlay(options) {
+    const overlay = new Overlay({
+      element: options.element,
+      autoPan: options.autoPan !== false,
+      offset: options.offset,
+      positioning: options.positioning || "bottom-center"
+    });
+    this.overlays.set(options.name, overlay);
+    this.map.addOverlay(overlay);
+  }
+  /**
+   * 显示 Overlay
+   */
+  showOverlay(name, coordinate) {
+    const overlay = this.overlays.get(name);
+    if (overlay) {
+      overlay.setPosition(fromLonLat(coordinate));
+    }
+  }
+  /**
+   * 隐藏 Overlay
+   */
+  hideOverlay(name) {
+    const overlay = this.overlays.get(name);
+    if (overlay) {
+      overlay.setPosition(void 0);
+    }
+  }
+  /**
+   * 移除 Overlay
+   */
+  removeOverlay(name) {
+    const overlay = this.overlays.get(name);
+    if (overlay) {
+      this.map.removeOverlay(overlay);
+      this.overlays.delete(name);
+    }
+  }
+  // ==================== 交互管理 ====================
+  /**
+   * 开始绘制
+   */
+  startDraw(options) {
+    this.stopDraw();
+    const source = options.layerName && this.vectorSources.has(options.layerName) ? this.vectorSources.get(options.layerName) : new VectorSource();
+    this.drawInteraction = new Draw({
+      source,
+      type: options.type,
+      style: options.style
+    });
+    this.map.addInteraction(this.drawInteraction);
+    if (options.onDrawEnd) {
+      this.drawInteraction.on("drawend", (evt) => {
+        options.onDrawEnd?.(evt.feature);
+      });
+    }
+    this.snapInteraction = new Snap({ source });
+    this.map.addInteraction(this.snapInteraction);
+  }
+  /**
+   * 停止绘制
+   */
+  stopDraw() {
+    if (this.drawInteraction) {
+      this.map.removeInteraction(this.drawInteraction);
+      this.drawInteraction = null;
+    }
+    if (this.snapInteraction) {
+      this.map.removeInteraction(this.snapInteraction);
+      this.snapInteraction = null;
+    }
+  }
+  /**
+   * 开始编辑
+   */
+  startModify(layerName = "default") {
+    this.stopModify();
+    const source = this.vectorSources.get(layerName);
+    if (!source) {
+      console.warn(`\u56FE\u5C42 "${layerName}" \u4E0D\u5B58\u5728`);
+      return;
+    }
+    this.modifyInteraction = new Modify({
+      source
+    });
+    this.map.addInteraction(this.modifyInteraction);
+    this.snapInteraction = new Snap({ source });
+    this.map.addInteraction(this.snapInteraction);
+  }
+  /**
+   * 停止编辑
+   */
+  stopModify() {
+    if (this.modifyInteraction) {
+      this.map.removeInteraction(this.modifyInteraction);
+      this.modifyInteraction = null;
+    }
+    if (this.snapInteraction) {
+      this.map.removeInteraction(this.snapInteraction);
+      this.snapInteraction = null;
+    }
+  }
+  /**
+   * 开始选择
+   */
+  startSelect(layerName = "default", onSelect) {
+    this.stopSelect();
+    this.selectInteraction = new Select({
+      layers: this.vectorLayers.get(layerName) ? [this.vectorLayers.get(layerName)] : void 0
+    });
+    this.map.addInteraction(this.selectInteraction);
+    if (onSelect) {
+      this.selectInteraction.on("select", (evt) => {
+        onSelect(evt.selected);
+      });
+    }
+  }
+  /**
+   * 停止选择
+   */
+  stopSelect() {
+    if (this.selectInteraction) {
+      this.map.removeInteraction(this.selectInteraction);
+      this.selectInteraction = null;
+    }
+  }
+  /**
+   * 获取选中的要素
+   */
+  getSelectedFeatures() {
+    return this.selectInteraction?.getFeatures().getArray() || [];
+  }
+  // ==================== 地图控制 ====================
+  /**
+   * 获取原始地图实例
+   */
+  getOlMap() {
+    return this.map;
+  }
+  /**
+   * 获取视图
+   */
+  getView() {
+    return this.map.getView();
+  }
+  /**
+   * 设置中心点
+   */
+  setCenter(coord) {
+    const view = this.getView();
+    if (view) {
+      view.setCenter(fromLonLat(coord));
+      this.map.render();
+    }
+  }
+  /**
+   * 获取中心点
+   */
+  getCenter() {
+    const view = this.getView();
+    if (view) {
+      const center = view.getCenter();
+      return center ? toLonLat(center) : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * 设置缩放级别
+   */
+  setZoom(zoom) {
+    const view = this.getView();
+    if (view) {
+      view.setZoom(zoom);
+      this.map.render();
+    }
+  }
+  /**
+   * 获取缩放级别
+   */
+  getZoom() {
+    return this.getView()?.getZoom();
+  }
+  /**
+   * 缩放到指定范围
+   */
+  fit(extent, options) {
+    if (!extent) return;
+    const view = this.getView();
+    if (view) {
+      view.fit(extent, options);
+      this.map.render();
+    }
+  }
+  /**
+   * 缩放到图层
+   */
+  fitLayer(layerName, options) {
+    const source = this.vectorSources.get(layerName);
+    if (source) {
+      const extent = source.getExtent();
+      if (extent && extent[0] !== Infinity) {
+        this.fit(extent, options);
+      }
+    }
+  }
+  /**
+   * 缩放到坐标数组
+   */
+  fitCoordinates(coordinates, options) {
+    const extent = boundingExtent(coordinates);
+    this.fit(extent, options);
+  }
+  /**
+   * 添加图层
+   */
+  addLayer(layer) {
+    this.map.addLayer(layer.layer);
+  }
+  /**
+   * 移除图层
+   */
+  removeMapLayer(layer) {
+    this.map.removeLayer(layer.layer);
+  }
+  /**
+   * 更新地图大小
+   */
+  updateSize() {
+    this.map.updateSize();
+  }
+  /**
+   * 地图事件监听
+   */
+  on(event, callback) {
+    this.map.on(event, callback);
+  }
+  /**
+   * 移除事件监听
+   */
+  off(event, callback) {
+    this.map.un(event, callback);
+  }
+  /**
+   * 销毁地图
+   */
+  destroy() {
+    this.stopDraw();
+    this.stopModify();
+    this.stopSelect();
+    this.overlays.forEach((overlay) => this.map.removeOverlay(overlay));
+    this.overlays.clear();
+    this.vectorLayers.forEach((layer) => this.map.removeLayer(layer));
+    this.vectorLayers.clear();
+    this.vectorSources.clear();
+    this.map.setTarget(void 0);
+  }
+};
+function createOSMLayer(name = "OSM") {
+  return {
+    name,
+    layer: new TileLayer({
+      source: new OSM()
+    })
+  };
+}
+function createXYZLayer(url, name = "XYZ") {
+  return {
+    name,
+    layer: new TileLayer({
+      source: new XYZ({
+        url
+      })
+    })
+  };
+}
+function createGaodeLayer(name = "\u9AD8\u5FB7\u5730\u56FE") {
+  return createXYZLayer(
+    "https://webrd0{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}",
+    name
+  );
+}
+function createTiandituLayer(token, type = "vec", name = "\u5929\u5730\u56FE") {
+  const url = `https://t{s}.tianditu.gov.cn/DataServer?T=${type}_w&x={x}&y={y}&l={z}&tk=${token}`;
+  return createXYZLayer(url, name);
+}
+function lonLatToXY(lon, lat) {
+  return fromLonLat([lon, lat]);
+}
+function xyToLonLat(x, y) {
+  return toLonLat([x, y]);
+}
+function createPointFeature(coordinate) {
+  return new Feature({
+    geometry: new Point(fromLonLat(coordinate))
+  });
+}
+function createLineFeature(coordinates) {
+  return new Feature({
+    geometry: new LineString(coordinates.map((coord) => fromLonLat(coord)))
+  });
+}
+function createPolygonFeature(coordinates) {
+  return new Feature({
+    geometry: new Polygon(coordinates.map((ring) => ring.map((coord) => fromLonLat(coord))))
+  });
+}
+function createStyledPointFeature(coordinate, style) {
+  const feature = createPointFeature(coordinate);
+  feature.setStyle(style);
+  return feature;
+}
+function createStyledLineFeature(coordinates, style) {
+  const feature = createLineFeature(coordinates);
+  feature.setStyle(style);
+  return feature;
+}
+function createStyledPolygonFeature(coordinates, style) {
+  const feature = createPolygonFeature(coordinates);
+  feature.setStyle(style);
+  return feature;
+}
+function createIconStyle(iconUrl, options) {
+  return new Style({
+    image: new Icon({
+      anchor: options?.anchor || [0.5, 0.5],
+      src: iconUrl,
+      scale: options?.scale || 1,
+      color: options?.color
+    })
+  });
+}
+function createCircleStyle(options) {
+  return new Style({
+    image: new Circle({
+      radius: options?.radius || 7,
+      fill: new Fill({ color: options?.fillColor || "#3388ff" }),
+      stroke: new Stroke({
+        color: options?.strokeColor || "#ffffff",
+        width: options?.strokeWidth || 2
+      })
+    })
+  });
+}
+function createStrokeStyle(options) {
+  return new Style({
+    stroke: new Stroke({
+      color: options?.color || "#3388ff",
+      width: options?.width || 2,
+      lineDash: options?.lineDash
+    })
+  });
+}
+function createFillStyle(options) {
+  return new Style({
+    stroke: new Stroke({
+      color: options?.strokeColor || "#3388ff",
+      width: options?.strokeWidth || 2
+    }),
+    fill: new Fill({
+      color: options?.fillColor || "rgba(51, 136, 255, 0.2)"
+    })
+  });
+}
+
+// src/modules/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  clearLocal: () => clearLocal,
+  clearSession: () => clearSession,
+  clearStorage: () => clearStorage,
+  getAllCookies: () => getAllCookies,
+  getCookie: () => getCookie,
+  getCookieJSON: () => getCookieJSON,
+  getCookieSize: () => getCookieSize,
+  getLocal: () => getLocal,
+  getLocalKeys: () => getLocalKeys,
+  getLocalSize: () => getLocalSize,
+  getSession: () => getSession,
+  getSessionKeys: () => getSessionKeys,
+  getSessionSize: () => getSessionSize,
+  getStorage: () => getStorage,
+  hasCookie: () => hasCookie,
+  removeCookie: () => removeCookie,
+  removeLocal: () => removeLocal,
+  removeSession: () => removeSession,
+  removeStorage: () => removeStorage,
+  setCookie: () => setCookie,
+  setCookieJSON: () => setCookieJSON,
+  setLocal: () => setLocal,
+  setSession: () => setSession,
+  setStorage: () => setStorage
+});
+function safeParse(json) {
+  if (!json || json === "undefined" || json === "null") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return json;
+  }
+}
+function isStorageAvailable(storage) {
+  try {
+    const testKey = "__storage_test__";
+    storage.setItem(testKey, testKey);
+    storage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setLocal(key, value, options) {
+  if (!isStorageAvailable(window.localStorage)) {
+    console.warn("LocalStorage is not available");
+    return;
+  }
+  const data = options?.ttl ? {
+    value,
+    expires: Date.now() + options.ttl
+  } : value;
+  window.localStorage.setItem(key, JSON.stringify(data));
+}
+function getLocal(key) {
+  if (!isStorageAvailable(window.localStorage)) {
+    return void 0;
+  }
+  const json = window.localStorage.getItem(key);
+  if (!json) {
+    return void 0;
+  }
+  const data = safeParse(json);
+  if (data && typeof data === "object" && "expires" in data && "value" in data) {
+    if (data.expires && Date.now() > data.expires) {
+      removeLocal(key);
+      return void 0;
+    }
+    return data.value;
+  }
+  return data;
+}
+function removeLocal(key) {
+  if (isStorageAvailable(window.localStorage)) {
+    window.localStorage.removeItem(key);
+  }
+}
+function clearLocal() {
+  if (isStorageAvailable(window.localStorage)) {
+    window.localStorage.clear();
+  }
+}
+function getLocalKeys() {
+  if (!isStorageAvailable(window.localStorage)) {
+    return [];
+  }
+  return Object.keys(window.localStorage);
+}
+function getLocalSize() {
+  return getLocalKeys().length;
+}
+function setSession(key, value, options) {
+  if (!isStorageAvailable(window.sessionStorage)) {
+    console.warn("SessionStorage is not available");
+    return;
+  }
+  const data = options?.ttl ? {
+    value,
+    expires: Date.now() + options.ttl
+  } : value;
+  window.sessionStorage.setItem(key, JSON.stringify(data));
+}
+function getSession(key) {
+  if (!isStorageAvailable(window.sessionStorage)) {
+    return void 0;
+  }
+  const json = window.sessionStorage.getItem(key);
+  if (!json) {
+    return void 0;
+  }
+  const data = safeParse(json);
+  if (data && typeof data === "object" && "expires" in data && "value" in data) {
+    if (data.expires && Date.now() > data.expires) {
+      removeSession(key);
+      return void 0;
+    }
+    return data.value;
+  }
+  return data;
+}
+function removeSession(key) {
+  if (isStorageAvailable(window.sessionStorage)) {
+    window.sessionStorage.removeItem(key);
+  }
+}
+function clearSession() {
+  if (isStorageAvailable(window.sessionStorage)) {
+    window.sessionStorage.clear();
+  }
+}
+function getSessionKeys() {
+  if (!isStorageAvailable(window.sessionStorage)) {
+    return [];
+  }
+  return Object.keys(window.sessionStorage);
+}
+function getSessionSize() {
+  return getSessionKeys().length;
+}
+function setCookie(key, value, options) {
+  const cookieOptions = {};
+  if (options?.days) {
+    cookieOptions.expires = options.days;
+  } else if (options?.expires !== void 0) {
+    cookieOptions.expires = options.expires;
+  }
+  if (options?.path !== void 0) {
+    cookieOptions.path = options.path;
+  }
+  if (options?.domain !== void 0) {
+    cookieOptions.domain = options.domain;
+  }
+  if (options?.secure !== void 0) {
+    cookieOptions.secure = options.secure;
+  }
+  if (options?.sameSite !== void 0) {
+    cookieOptions.sameSite = options.sameSite;
+  }
+  Cookies.set(key, value, cookieOptions);
+}
+function getCookie(key) {
+  return Cookies.get(key);
+}
+function removeCookie(key, options) {
+  Cookies.remove(key, options);
+}
+function getAllCookies() {
+  return Cookies.get() || {};
+}
+function hasCookie(key) {
+  return Cookies.get(key) !== void 0;
+}
+function getCookieJSON(key) {
+  const value = Cookies.get(key);
+  if (!value) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function setCookieJSON(key, value, options) {
+  setCookie(key, JSON.stringify(value), options);
+}
+function getCookieSize() {
+  return Object.keys(getAllCookies()).length;
+}
+function setStorage(type, key, value, options) {
+  switch (type) {
+    case "local":
+      setLocal(key, value, options);
+      break;
+    case "session":
+      setSession(key, value, options);
+      break;
+    case "cookie":
+      setCookie(key, value, options);
+      break;
+  }
+}
+function getStorage(type, key) {
+  switch (type) {
+    case "local":
+      return getLocal(key);
+    case "session":
+      return getSession(key);
+    case "cookie":
+      return getCookie(key);
+  }
+}
+function removeStorage(type, key) {
+  switch (type) {
+    case "local":
+      removeLocal(key);
+      break;
+    case "session":
+      removeSession(key);
+      break;
+    case "cookie":
+      removeCookie(key);
+      break;
+  }
+}
+function clearStorage(type) {
+  switch (type) {
+    case "local":
+      clearLocal();
+      break;
+    case "session":
+      clearSession();
+      break;
+    case "cookie": {
+      const cookies = getAllCookies();
+      for (const key of Object.keys(cookies)) {
+        removeCookie(key);
+      }
+      break;
+    }
+  }
+}
+
+// src/modules/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  avg: () => avg,
+  base64toBlob: () => base64toBlob,
+  base64toFile: () => base64toFile,
+  camelToSnake: () => camelToSnake,
+  capitalize: () => capitalize2,
+  chunk: () => chunk2,
+  clone: () => clone2,
+  copyToClipboard: () => copyToClipboard,
+  debounce: () => debounce,
+  deepMerge: () => deepMerge2,
+  delay: () => delay,
+  downloadBase64: () => downloadBase64,
+  downloadBlob: () => downloadBlob,
+  downloadFile: () => downloadFile,
+  formatFileSize: () => formatFileSize,
+  formatNumber: () => formatNumber,
+  get: () => get2,
+  getDarkColor: () => getDarkColor,
+  getLightColor: () => getLightColor,
+  groupBy: () => groupBy3,
+  hexToRgb: () => hexToRgb,
+  hexToRgbString: () => hexToRgbString,
+  imgToBase64: () => imgToBase64,
+  isArray: () => isArray2,
+  isBoolean: () => isBoolean2,
+  isEmpty: () => isEmpty4,
+  isEqual: () => isEqual3,
+  isFunction: () => isFunction2,
+  isNumber: () => isNumber2,
+  isObject: () => isObject2,
+  isString: () => isString2,
+  isValidEmail: () => isValidEmail,
+  isValidPhone: () => isValidPhone,
+  isValidUrl: () => isValidUrl,
+  max: () => max2,
+  min: () => min2,
+  omit: () => omit3,
+  pick: () => pick2,
+  randomInt: () => randomInt,
+  readFromClipboard: () => readFromClipboard,
+  retry: () => retry,
+  rgbArrayToHex: () => rgbArrayToHex,
+  rgbToHex: () => rgbToHex,
+  set: () => set2,
+  snakeToCamel: () => snakeToCamel,
+  sortBy: () => sortBy2,
+  sum: () => sum2,
+  throttle: () => throttle,
+  truncate: () => truncate,
+  uniq: () => uniq2,
+  uniqueId: () => uniqueId
+});
+var clone2 = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Array) {
+    return obj.map((item) => clone2(item));
+  }
+  if (obj instanceof Object) {
+    const copy = {};
+    Object.keys(obj).forEach((key) => {
+      copy[key] = clone2(obj[key]);
+    });
+    return copy;
+  }
+  return obj;
+};
+var isEqual3 = (a, b) => {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return a === b;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!isEqual3(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!isEqual3(a[key], b[key])) return false;
+  }
+  return true;
+};
+var deepMerge2 = (...objects) => {
+  const result = {};
+  objects.forEach((obj) => {
+    if (isObject2(obj)) {
+      Object.keys(obj).forEach((key) => {
+        const value = obj[key];
+        if (isObject2(value) && isObject2(result[key])) {
+          result[key] = deepMerge2(result[key], value);
+        } else {
+          result[key] = clone2(value);
+        }
+      });
+    }
+  });
+  return result;
+};
+var get2 = (obj, path) => {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+};
+var set2 = (obj, path, value) => {
+  const keys2 = path.split(".");
+  const lastKey = keys2.pop();
+  const target = keys2.reduce((acc, key) => {
+    if (!acc[key]) acc[key] = {};
+    return acc[key];
+  }, obj);
+  target[lastKey] = value;
+};
+var omit3 = (obj, keys2) => {
+  const result = { ...obj };
+  keys2.forEach((key) => delete result[key]);
+  return result;
+};
+var pick2 = (obj, keys2) => {
+  const result = {};
+  keys2.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+};
+var isObject2 = (value) => {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+var isArray2 = (value) => {
+  return Array.isArray(value);
+};
+var isString2 = (value) => {
+  return typeof value === "string";
+};
+var isNumber2 = (value) => {
+  return typeof value === "number" && !isNaN(value);
+};
+var isBoolean2 = (value) => {
+  return typeof value === "boolean";
+};
+var isFunction2 = (value) => {
+  return typeof value === "function";
+};
+var isEmpty4 = (value) => {
+  if (value === null || value === void 0) return true;
+  if (isString2(value) || Array.isArray(value)) return value.length === 0;
+  if (isObject2(value)) return Object.keys(value).length === 0;
+  return false;
+};
+var uniq2 = (array) => {
+  return [...new Set(array)];
+};
+var sortBy2 = (array, key) => {
+  const sortFn = typeof key === "function" ? key : (item) => item[key];
+  return [...array].sort((a, b) => {
+    const valueA = sortFn(a);
+    const valueB = sortFn(b);
+    if (valueA < valueB) return -1;
+    if (valueA > valueB) return 1;
+    return 0;
+  });
+};
+var chunk2 = (array, size2) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += size2) {
+    result.push(array.slice(i, i + size2));
+  }
+  return result;
+};
+var groupBy3 = (array, key) => {
+  const groupFn = typeof key === "function" ? key : (item) => String(item[key]);
+  return array.reduce(
+    (result, item) => {
+      const groupKey = groupFn(item);
+      if (!result[groupKey]) {
+        result[groupKey] = [];
+      }
+      result[groupKey].push(item);
+      return result;
+    },
+    {}
+  );
+};
+var sum2 = (array) => {
+  return array.reduce((acc, num) => acc + num, 0);
+};
+var avg = (array) => {
+  return array.length > 0 ? sum2(array) / array.length : 0;
+};
+var max2 = (array) => {
+  return Math.max(...array);
+};
+var min2 = (array) => {
+  return Math.min(...array);
+};
+var camelToSnake = (str) => {
+  return str.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+};
+var snakeToCamel = (str) => {
+  return str.replace(/_([a-z])/g, (_, match) => match.toUpperCase());
+};
+var capitalize2 = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+var truncate = (str, length = 100, suffix = "...") => {
+  if (str.length <= length) return str;
+  return `${str.slice(0, length)}${suffix}`;
+};
+var formatFileSize = (bytes) => {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+};
+var formatNumber = (num) => {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+var isValidUrl = (str) => {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isValidEmail = (email) => {
+  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return regex.test(email);
+};
+var isValidPhone = (phone) => {
+  const regex = /^1[3-9]\d{9}$/;
+  return regex.test(phone);
+};
+var randomInt = (min3, max3) => {
+  return Math.floor(Math.random() * (max3 - min3 + 1)) + min3;
+};
+var uniqueId = (prefix = "") => {
+  return `${prefix}${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+};
+var delay = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var retry = async (fn, retries = 3, delayMs = 1e3) => {
+  try {
+    return await fn();
+  } catch (error) {
+    if (retries <= 0) {
+      throw error;
+    }
+    await delay(delayMs);
+    return retry(fn, retries - 1, delayMs);
+  }
+};
+var hexToRgb = (str) => {
+  const hexRegex = /^#?([0-9A-Fa-f]{6})$/;
+  if (!hexRegex.test(str)) {
+    return null;
+  }
+  const hex = str.replace("#", "");
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  return [r, g, b];
+};
+var hexToRgbString = (str) => {
+  const rgb = hexToRgb(str);
+  if (!rgb) {
+    return null;
+  }
+  return `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
+};
+var rgbToHex = (r, g, b) => {
+  const numRegex = /^\d{1,3}$/;
+  if (!numRegex.test(r.toString()) || !numRegex.test(g.toString()) || !numRegex.test(b.toString())) {
+    return null;
+  }
+  if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+    return null;
+  }
+  const toHex = (num) => {
+    const hex = num.toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+};
+var rgbArrayToHex = (rgb) => {
+  if (rgb.length !== 3) {
+    return null;
+  }
+  return rgbToHex(rgb[0], rgb[1], rgb[2]);
+};
+var getLightColor = (color, alpha) => {
+  const rgb = hexToRgb(color);
+  if (!rgb) {
+    return null;
+  }
+  const [r, g, b] = rgb;
+  const newR = Math.floor((255 - r) * alpha + r);
+  const newG = Math.floor((255 - g) * alpha + g);
+  const newB = Math.floor((255 - b) * alpha + b);
+  return rgbToHex(newR, newG, newB);
+};
+var getDarkColor = (color, alpha) => {
+  const rgb = hexToRgb(color);
+  if (!rgb) {
+    return null;
+  }
+  const [r, g, b] = rgb;
+  const newR = Math.floor(r * (1 - alpha));
+  const newG = Math.floor(g * (1 - alpha));
+  const newB = Math.floor(b * (1 - alpha));
+  return rgbToHex(newR, newG, newB);
+};
+var imgToBase64 = (url, type = "image/png") => {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.crossOrigin = "anonymous";
+    image.onload = () => {
+      const canvas = document.createElement("canvas");
+      canvas.width = image.naturalWidth;
+      canvas.height = image.naturalHeight;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas context"));
+        return;
+      }
+      ctx.drawImage(image, 0, 0);
+      const base64 = canvas.toDataURL(type);
+      resolve(base64);
+    };
+    image.onerror = (err) => {
+      reject(new Error(`Failed to load image: ${String(err)}`));
+    };
+    image.src = url;
+  });
+};
+var base64toFile = (base64, fileName, mimeType = "image/jpeg") => {
+  const dataArr = base64.split(",");
+  const byteString = atob(dataArr[1]);
+  const u8Arr = new Uint8Array(byteString.length);
+  for (let i = 0; i < byteString.length; i++) {
+    u8Arr[i] = byteString.charCodeAt(i);
+  }
+  return new File([u8Arr], fileName, { type: mimeType });
+};
+var base64toBlob = (base64, mimeType = "image/jpeg") => {
+  const dataArr = base64.split(",");
+  const byteString = atob(dataArr[1]);
+  const u8Arr = new Uint8Array(byteString.length);
+  for (let i = 0; i < byteString.length; i++) {
+    u8Arr[i] = byteString.charCodeAt(i);
+  }
+  return new Blob([u8Arr], { type: mimeType });
+};
+var downloadFile = (url, fileName = "\u6587\u4EF6", target = false) => {
+  const link = document.createElement("a");
+  link.style.display = "none";
+  link.href = url;
+  if (target) {
+    link.target = "_blank";
+  } else {
+    link.setAttribute("download", fileName);
+  }
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+};
+var downloadBlob = (blob, fileName) => {
+  const url = URL.createObjectURL(blob);
+  downloadFile(url, fileName);
+  URL.revokeObjectURL(url);
+};
+var downloadBase64 = (base64, fileName, mimeType = "image/jpeg") => {
+  const blob = base64toBlob(base64, mimeType);
+  downloadBlob(blob, fileName);
+};
+var copyToClipboard = async (text) => {
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.style.position = "fixed";
+    textarea.style.opacity = "0";
+    document.body.appendChild(textarea);
+    textarea.select();
+    const success = document.execCommand("copy");
+    document.body.removeChild(textarea);
+    return success;
+  } catch {
+    return false;
+  }
+};
+var readFromClipboard = async () => {
+  try {
+    if (navigator.clipboard && navigator.clipboard.readText) {
+      return await navigator.clipboard.readText();
+    }
+    return "";
+  } catch {
+    return "";
+  }
+};
+
+// src/modules/crypto/index.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  CryptoJS: () => CryptoJS,
+  aesDecrypt: () => aesDecrypt,
+  aesEncrypt: () => aesEncrypt,
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  desDecrypt: () => desDecrypt,
+  desEncrypt: () => desEncrypt,
+  generateIV: () => generateIV,
+  generateKey: () => generateKey,
+  hexDecode: () => hexDecode,
+  hexEncode: () => hexEncode,
+  hmacMD5: () => hmacMD5,
+  hmacSHA1: () => hmacSHA1,
+  hmacSHA256: () => hmacSHA256,
+  hmacSHA512: () => hmacSHA512,
+  md5: () => md5,
+  pbkdf2: () => pbkdf2,
+  rabbitDecrypt: () => rabbitDecrypt,
+  rabbitEncrypt: () => rabbitEncrypt,
+  rc4Decrypt: () => rc4Decrypt,
+  rc4Encrypt: () => rc4Encrypt,
+  sha1: () => sha1,
+  sha256: () => sha256,
+  sha512: () => sha512,
+  tripleDesDecrypt: () => tripleDesDecrypt,
+  tripleDesEncrypt: () => tripleDesEncrypt,
+  utf8Decode: () => utf8Decode,
+  utf8Encode: () => utf8Encode,
+  uuid: () => uuid2
+});
+var md5 = (message) => {
+  return CryptoJS.MD5(message).toString();
+};
+var sha1 = (message) => {
+  return CryptoJS.SHA1(message).toString();
+};
+var sha256 = (message) => {
+  return CryptoJS.SHA256(message).toString();
+};
+var sha512 = (message) => {
+  return CryptoJS.SHA512(message).toString();
+};
+var hmacMD5 = (message, key) => {
+  return CryptoJS.HmacMD5(message, key).toString();
+};
+var hmacSHA1 = (message, key) => {
+  return CryptoJS.HmacSHA1(message, key).toString();
+};
+var hmacSHA256 = (message, key) => {
+  return CryptoJS.HmacSHA256(message, key).toString();
+};
+var hmacSHA512 = (message, key) => {
+  return CryptoJS.HmacSHA512(message, key).toString();
+};
+var aesEncrypt = (message, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const encrypted = CryptoJS.AES.encrypt(message, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return encrypted.toString();
+};
+var aesDecrypt = (ciphertext, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const decrypted = CryptoJS.AES.decrypt(ciphertext, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+var desEncrypt = (message, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const encrypted = CryptoJS.DES.encrypt(message, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return encrypted.toString();
+};
+var desDecrypt = (ciphertext, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const decrypted = CryptoJS.DES.decrypt(ciphertext, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+var tripleDesEncrypt = (message, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const encrypted = CryptoJS.TripleDES.encrypt(message, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return encrypted.toString();
+};
+var tripleDesDecrypt = (ciphertext, key, iv, mode2 = CryptoJS.mode.CBC, padding = CryptoJS.pad.Pkcs7) => {
+  const keyWord = CryptoJS.enc.Utf8.parse(key);
+  const ivWord = iv ? CryptoJS.enc.Utf8.parse(iv) : void 0;
+  const decrypted = CryptoJS.TripleDES.decrypt(ciphertext, keyWord, {
+    iv: ivWord,
+    mode: mode2,
+    padding
+  });
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+var rc4Encrypt = (message, key) => {
+  const encrypted = CryptoJS.RC4.encrypt(message, key);
+  return encrypted.toString();
+};
+var rc4Decrypt = (ciphertext, key) => {
+  const decrypted = CryptoJS.RC4.decrypt(ciphertext, key);
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+var rabbitEncrypt = (message, key) => {
+  const encrypted = CryptoJS.Rabbit.encrypt(message, key);
+  return encrypted.toString();
+};
+var rabbitDecrypt = (ciphertext, key) => {
+  const decrypted = CryptoJS.Rabbit.decrypt(ciphertext, key);
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+var base64Encode = (message) => {
+  return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(message));
+};
+var base64Decode = (encoded) => {
+  return CryptoJS.enc.Base64.parse(encoded).toString(CryptoJS.enc.Utf8);
+};
+var utf8Encode = (message) => {
+  return CryptoJS.enc.Utf8.stringify(CryptoJS.enc.Utf8.parse(message));
+};
+var utf8Decode = (encoded) => {
+  return CryptoJS.enc.Utf8.parse(encoded).toString(CryptoJS.enc.Utf8);
+};
+var hexEncode = (message) => {
+  return CryptoJS.enc.Hex.stringify(CryptoJS.enc.Utf8.parse(message));
+};
+var hexDecode = (encoded) => {
+  return CryptoJS.enc.Hex.parse(encoded).toString(CryptoJS.enc.Utf8);
+};
+var generateKey = (length = 32) => {
+  const key = CryptoJS.lib.WordArray.random(length);
+  return CryptoJS.enc.Base64.stringify(key);
+};
+var generateIV = (length = 16) => {
+  const iv = CryptoJS.lib.WordArray.random(length);
+  return CryptoJS.enc.Base64.stringify(iv);
+};
+var pbkdf2 = (password, salt, iterations = 1e3, keySize = 32) => {
+  const key = CryptoJS.PBKDF2(password, salt, {
+    keySize: keySize / 4,
+    iterations
+  });
+  return key.toString();
+};
+var uuid2 = () => {
+  return CryptoJS.lib.WordArray.random(16).toString();
+};
+/**
+ * Utils Toolkit
+ * 一个功能强大的 JavaScript/TypeScript 工具函数库
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+
+export { array_exports as array, crypto_exports as crypto, date_exports as date, excel_exports as excel, map_exports as map, object_exports as object, pdf_exports as pdf, storage_exports as storage, string_exports as string, utils_exports as utils };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map