@hzab/utils 1.1.6 → 1.1.7

package/dist/index.js

@@ -0,0 +1,1423 @@
+import { customAlphabet } from 'nanoid';
+import { cloneDeep } from 'lodash-es';
+import dayjs2 from 'dayjs';
+import { axios } from '@hzab/data-model';
+
+// src/array.ts
+function getArr(value) {
+  return Array.isArray(value) ? value : value && [value] || [];
+}
+
+// src/base64Str.ts
+var isBase64Str = function(str) {
+  if (typeof str !== "string") {
+    return false;
+  }
+  return /^data:\w+\/\w+;base64/i.test(str);
+};
+function getFileTypeFromBase64(base64Str) {
+  if (!isBase64Str(base64Str)) {
+    return base64Str;
+  }
+  const base64Data = base64Str.replace(/^data:.*;base64,/, "");
+  const prefixMap = {
+    JVBERi0: { type: "pdf", mimeType: "application/pdf" },
+    R0lGODdh: { type: "gif", mimeType: "image/gif" },
+    R0lGODlh: { type: "gif", mimeType: "image/gif" },
+    iVBORw0KGgo: { type: "png", mimeType: "image/png" },
+    "/9j/": { type: "jpeg", mimeType: "image/jpeg" },
+    SUQzB: { type: "mp4", mimeType: "video/mp4" },
+    AAAAGGZ0eXBpc29tAA: { type: "mpeg", mimeType: "audio/mpeg" },
+    UklGR: { type: "webp", mimeType: "image/webp" },
+    PD94bWwgdmVyc2lvbj0: { type: "xml", mimeType: "text/xml" },
+    PHN2ZyB4bWxucz0: { type: "svg", mimeType: "image/svg+xml" },
+    dGV4dCB4bWxucz0: { type: "txt", mimeType: "text/plain" }
+  };
+  for (const prefix of Object.keys(prefixMap)) {
+    if (base64Data.startsWith(prefix)) {
+      return prefixMap[prefix];
+    }
+  }
+  return { type: "unknown", mimeType: "application/octet-stream" };
+}
+
+// src/blob.ts
+async function getFileTypeFromBlob(blob) {
+  const fileSignatures = {
+    "89504E47": "image/png",
+    FFD8FF: "image/jpeg",
+    "47494638": "image/gif",
+    "25504446": "application/pdf",
+    "504B0304": "application/zip",
+    // ZIP 或 DOCX/XLSX 等基于 ZIP 的格式
+    "3C3F786D6C": "text/xml",
+    // XML
+    "7B22": "application/json",
+    // JSON（开头可能为 { 或 {"）
+    "25215053": "application/postscript",
+    // PS
+    "494433": "audio/mpeg",
+    // MP3
+    "0000001866747970": "video/mp4"
+    // MP4（部分情况）
+  };
+  const buffer = await blob.slice(0, 8).arrayBuffer();
+  const uint8Array = new Uint8Array(buffer);
+  let hex = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    const byte = uint8Array[i].toString(16).padStart(2, "0");
+    hex += byte.toUpperCase();
+  }
+  const signatures = Object.keys(fileSignatures).sort((a, b) => b.length - a.length);
+  for (const signature of signatures) {
+    if (hex.startsWith(signature)) {
+      return fileSignatures[signature];
+    }
+  }
+  return "unknown";
+}
+
+// src/color.ts
+function luminance(r, g, b) {
+  const a = [r, g, b].map((v) => {
+    v /= 255;
+    return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  });
+  return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+}
+function contrast(l1, l2) {
+  const brightest = Math.max(l1, l2);
+  const darkest = Math.min(l1, l2);
+  return (brightest + 0.05) / (darkest + 0.05);
+}
+function contrastRatio(luminance1, luminance2) {
+  return (Math.max(luminance1, luminance2) + 0.05) / (Math.min(luminance1, luminance2) + 0.05);
+}
+function hexToRGB(hex) {
+  hex = hex.replace("#", "");
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  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];
+}
+function rgbNumLimit(val) {
+  if (val > 250) {
+    return 250;
+  }
+  if (val < 0) {
+    return 0;
+  }
+  return val;
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((x) => {
+    const hex = x.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+function rgbToHsl(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h, s, l = (max + min) / 2;
+  if (max === min) {
+    h = s = 0;
+  } else {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return [h * 360, s * 100, l * 100];
+}
+function hslToRgb(h, s, l) {
+  h /= 360;
+  s /= 100;
+  l /= 100;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+function isGray(r, g, b, opt = { tolerance: 10 }) {
+  const {
+    /**
+     * 允许的误差范围
+     */
+    tolerance = 10
+  } = opt || {};
+  return Math.abs(r - g) <= tolerance && Math.abs(g - b) <= tolerance && Math.abs(r - b) <= tolerance;
+}
+function getTextColor(backgroundColor) {
+  let [r, g, b] = [0, 0, 0];
+  if (backgroundColor.startsWith("#")) {
+    [r, g, b] = hexToRGB(backgroundColor);
+  } else {
+    const div = document.createElement("div");
+    div.style.color = backgroundColor;
+    document.body.appendChild(div);
+    const cs = getComputedStyle(div);
+    const rgb = cs.color.match(/\d+/g).map(Number);
+    document.body.removeChild(div);
+    [r, g, b] = rgb;
+  }
+  const bgLuminance = luminance(r, g, b);
+  const whiteLuminance = luminance(255, 255, 255);
+  const blackLuminance = luminance(0, 0, 0);
+  const whiteContrast = contrast(bgLuminance, whiteLuminance);
+  const blackContrast = contrast(bgLuminance, blackLuminance);
+  return whiteContrast > blackContrast ? "#ffffff" : "#000000";
+}
+function adjustTextColor(hexColor) {
+  const [bgR, bgG, bgB] = hexToRGB(hexColor);
+  const bgLuminance = luminance(bgR, bgG, bgB);
+  let textR, textG, textB;
+  const targetContrast = 4.5;
+  if (bgR === 0 && bgG === 0 && bgB === 0) {
+    let textR2 = 255, textG2 = 255, textB2 = 255;
+    const textLuminance = luminance(textR2, textG2, textB2);
+    const ratio = contrastRatio(bgLuminance, textLuminance);
+    if (ratio < targetContrast) {
+      textR2 = 230;
+      textG2 = 230;
+      textB2 = 230;
+    }
+    return rgbToHex(textR2, textG2, textB2);
+  } else if (bgR === 255 && bgG === 255 && bgB === 255) {
+    let textR2 = 0, textG2 = 0, textB2 = 0;
+    const textLuminance = luminance(textR2, textG2, textB2);
+    const ratio = contrastRatio(bgLuminance, textLuminance);
+    if (ratio < targetContrast) {
+      textR2 = 20;
+      textG2 = 20;
+      textB2 = 20;
+    }
+    return rgbToHex(textR2, textG2, textB2);
+  } else if (isGray(bgR, bgG, bgB)) {
+    if (bgLuminance < 0.4) {
+      let textR2 = 255, textG2 = 255, textB2 = 255;
+      const textLuminance = luminance(textR2, textG2, textB2);
+      const ratio = contrastRatio(bgLuminance, textLuminance);
+      if (ratio < targetContrast) {
+        textR2 = 230;
+        textG2 = 230;
+        textB2 = 230;
+      }
+      return rgbToHex(textR2, textG2, textB2);
+    } else {
+      let textR2 = 0, textG2 = 0, textB2 = 0;
+      const textLuminance = luminance(textR2, textG2, textB2);
+      const ratio = contrastRatio(bgLuminance, textLuminance);
+      if (ratio < targetContrast) {
+        textR2 = 20;
+        textG2 = 20;
+        textB2 = 20;
+      }
+      return rgbToHex(textR2, textG2, textB2);
+    }
+  }
+  const adjustNum = 150;
+  if (bgLuminance > 0.5) {
+    textR = Math.max(0, bgR - adjustNum);
+    textG = Math.max(0, bgG - adjustNum);
+    textB = Math.max(0, bgB - adjustNum);
+  } else {
+    textR = Math.min(255, bgR + adjustNum);
+    textG = Math.min(255, bgG + adjustNum);
+    textB = Math.min(255, bgB + adjustNum);
+  }
+  return rgbToHex(textR, textG, textB);
+}
+function adjustColor(hexColor, amount) {
+  const [r, g, b] = hexToRGB(hexColor);
+  const newR = rgbNumLimit(r + amount);
+  const newG = rgbNumLimit(g + amount);
+  const newB = rgbNumLimit(b + amount);
+  return rgbToHex(newR, newG, newB);
+}
+
+// src/empty-val.ts
+function checkEmpty(val, opt = {}) {
+  const { checkEmptyArr = true } = opt || {};
+  if (val === "" || val === null || val === void 0) {
+    return true;
+  }
+  if (checkEmptyArr && Array.isArray(val) && Array.length === 0) {
+    return true;
+  }
+  return false;
+}
+var handleEmptyVal = (val, opt = {}) => {
+  const { emptyStr = "--" } = opt || {};
+  const emptySymbol = opt?.emptySymbol ?? emptyStr;
+  if (checkEmpty(val, opt)) {
+    return emptySymbol;
+  }
+  return val;
+};
+
+// src/globalConfig.ts
+window.utilsGlobalServeConfig = {};
+function getGlobalServeConfig() {
+  return window.utilsGlobalServeConfig || {};
+}
+function setGlobalServeConfigs(data) {
+  Object.assign(window.utilsGlobalServeConfig || {}, data);
+  return window.utilsGlobalServeConfig || {};
+}
+function setGlobalServeConfig(key, data) {
+  window.utilsGlobalServeConfig[key] = data;
+  return window.utilsGlobalServeConfig || {};
+}
+
+// src/idCardVerify.ts
+function isValidIdCard(idCard, opt) {
+  if (!idCard) return false;
+  idCard = idCard.trim().toUpperCase();
+  const len = idCard.length;
+  if (len !== 15 && len !== 18) return false;
+  const reg15 = /^[1-9]\d{7}((0[1-9])|(1[0-2]))((0[1-9])|([1-2]\d)|(3[0-1]))\d{3}$/;
+  const reg18 = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))((0[1-9])|([1-2]\d)|(3[0-1]))\d{3}[\dX]$/;
+  if (len === 15 && !reg15.test(idCard)) return false;
+  if (len === 18 && !reg18.test(idCard)) return false;
+  let id18 = idCard;
+  if (len === 15) {
+    id18 = convert15to18(idCard);
+  }
+  if (opt?.validBirthDate && !isValidBirthDate(id18)) return false;
+  return verifyCheckCode(id18);
+}
+function isValidBirthDate(id18) {
+  const birthYear = parseInt(id18.substring(6, 10));
+  const birthMonth = parseInt(id18.substring(10, 12));
+  const birthDay = parseInt(id18.substring(12, 14));
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  if (birthYear < 1900 || birthYear > currentYear) {
+    return false;
+  }
+  if (birthMonth < 1 || birthMonth > 12) {
+    return false;
+  }
+  const daysInMonth = getDaysInMonth(birthYear, birthMonth);
+  if (birthDay < 1 || birthDay > daysInMonth) {
+    return false;
+  }
+  return true;
+}
+function getDaysInMonth(year, month) {
+  const isLeapYear = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+  const daysInMonth = [31, isLeapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return daysInMonth[month - 1];
+}
+function convert15to18(id15) {
+  const yearTwoDigits = parseInt(id15.substring(6, 8));
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const currentYearTwoDigits = currentYear % 100;
+  let fullYear;
+  if (yearTwoDigits > currentYearTwoDigits) {
+    fullYear = 1900 + yearTwoDigits;
+  } else {
+    fullYear = 2e3 + yearTwoDigits;
+  }
+  const id17 = id15.substring(0, 6) + fullYear + id15.substring(8);
+  const checkCode = calculateCheckCode(id17);
+  return id17 + checkCode;
+}
+function calculateCheckCode(id17) {
+  const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+  const checkCodes = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+  let sum = 0;
+  for (let i = 0; i < 17; i++) {
+    sum += parseInt(id17[i]) * weights[i];
+  }
+  const mod = sum % 11;
+  return checkCodes[mod];
+}
+function verifyCheckCode(id18) {
+  const id17 = id18.substring(0, 17);
+  const providedCode = id18[17];
+  const calculatedCode = calculateCheckCode(id17);
+  return providedCode === calculatedCode;
+}
+function calculateAge(year, month, day) {
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - year;
+  const monthDiff = today.getMonth() + 1 - month;
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < day) {
+    age--;
+  }
+  return age;
+}
+function getIdCardInfo(idCard) {
+  if (!isValidIdCard(idCard)) return null;
+  let id18 = idCard.trim().toUpperCase();
+  if (id18.length === 15) {
+    id18 = convert15to18(id18);
+  }
+  const provinceCode = id18.substring(0, 2);
+  const birthYear = parseInt(id18.substring(6, 10));
+  const birthMonth = parseInt(id18.substring(10, 12));
+  const birthDay = parseInt(id18.substring(12, 14));
+  const genderCode = parseInt(id18.substring(16, 17));
+  const birthDate = new Date(birthYear, birthMonth - 1, birthDay);
+  return {
+    province: provinceCode,
+    birthDate,
+    birthYear,
+    birthMonth,
+    birthDay,
+    age: calculateAge(birthYear, birthMonth, birthDay),
+    gender: genderCode % 2 === 1 ? "\u7537" : "\u5973",
+    isValid: true
+  };
+}
+
+// src/img-utils.ts
+var IMAGE_TYPES = class {
+  static JPEG = "image/jpeg";
+  static PNG = "image/png";
+};
+function checkEmptyImg(img) {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return;
+  }
+  canvas.width = img.width;
+  canvas.height = img.height;
+  ctx.drawImage(img, 0, 0);
+  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+  const data = imageData.data;
+  let topLeftToBottomRight = true;
+  const iUp = 0;
+  const redUp = data[iUp];
+  const greenUp = data[iUp + 1];
+  const blueUp = data[iUp + 2];
+  const alphaUp = data[iUp + 3];
+  for (let i = 0; i < data.length; i += 4) {
+    const red = data[i];
+    const green = data[i + 1];
+    const blue = data[i + 2];
+    const alpha = data[i + 3];
+    if (red !== redUp || green !== greenUp || blue !== blueUp || alpha !== alphaUp) {
+      topLeftToBottomRight = false;
+      break;
+    }
+  }
+  let topRightToBottomLeft = true;
+  const jDown = data.length - 4;
+  const redDown = data[jDown];
+  const greenDown = data[jDown + 1];
+  const blueDown = data[jDown + 2];
+  const alphaDown = data[jDown + 3];
+  for (let j = jDown; j >= 0; j -= 4) {
+    const red = data[j];
+    const green = data[j + 1];
+    const blue = data[j + 2];
+    const alpha = data[j + 3];
+    if (red !== redDown || green !== greenDown || blue !== blueDown || alpha !== alphaDown) {
+      topRightToBottomLeft = false;
+      break;
+    }
+  }
+  if (topLeftToBottomRight && topRightToBottomLeft) {
+    return false;
+  } else {
+    return true;
+  }
+}
+function getDomWH(d) {
+  if (d instanceof Image || d instanceof HTMLCanvasElement) {
+    return {
+      width: d.width || d.offsetWidth,
+      height: d.width || d.offsetHeight
+    };
+  }
+  return {
+    width: d.offsetWidth,
+    height: d.offsetHeight
+  };
+}
+function setDomWH(dom, w, h) {
+  dom.setAttribute("width", `${w}`);
+  dom.setAttribute("height", `${h}`);
+}
+function getCanvasPic(canvas) {
+  canvas.getContext("2d", { preserveDrawingBuffer: true });
+  return dataURItoBlob(canvas.toDataURL(IMAGE_TYPES.PNG, 1));
+}
+function dataURItoBlob(base64) {
+  const arr = base64.split(",");
+  const mime = arr[0]?.match(/:(.*?);/)?.[1];
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new Blob([u8arr], { type: mime });
+}
+function getImgEle(imgSrc) {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = function() {
+      resolve(img);
+    };
+    img.src = imgSrc;
+  });
+}
+function getImgBase64(imgSrc) {
+  return getImgEle(imgSrc).then((img) => {
+    const canvas = document.createElement("canvas");
+    const { width, height } = getDomWH(img);
+    setDomWH(canvas, width, height);
+    const ctx = canvas.getContext("2d");
+    ctx && ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
+    return canvas.toDataURL(IMAGE_TYPES.PNG, 1);
+  });
+}
+function getCanvas(imgSrc) {
+  return getImgEle(imgSrc).then((img) => {
+    const canvas = document.createElement("canvas");
+    const { width, height } = getDomWH(img);
+    setDomWH(canvas, width, height);
+    const ctx = canvas.getContext("2d");
+    ctx && ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
+    return canvas;
+  });
+}
+function getCanvasByImg(img) {
+  const canvas = document.createElement("canvas");
+  const { width, height } = getDomWH(img);
+  setDomWH(canvas, width, height);
+  const ctx = canvas.getContext("2d");
+  ctx && ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
+  return canvas;
+}
+function cropImage(img, opt) {
+  return cropImageToCanvas(img, opt).toDataURL(IMAGE_TYPES.PNG, 1);
+}
+function cropImageToCanvas(img, opt) {
+  const { startX, startY, width, height } = opt;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = width;
+  canvas.height = height;
+  ctx?.drawImage(img, startX, startY, width, height, 0, 0, width, height);
+  return canvas;
+}
+function imgToCanvas(img) {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = img.width;
+  canvas.height = img.height;
+  ctx?.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+  return canvas;
+}
+function scaleImage(img, opt = { scaleFactor: 1 }) {
+  return scaleImageToCanvas(img, opt).toDataURL(IMAGE_TYPES.PNG, 1);
+}
+function scaleImageToCanvas(img, opt = { scaleFactor: 1 }) {
+  const { scaleFactor = 1 } = opt;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = img.width * scaleFactor;
+  canvas.height = img.height * scaleFactor;
+  ctx?.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+  return canvas;
+}
+async function imgToBase64(img) {
+  if (!img || img instanceof Blob) {
+    return img;
+  }
+  let _img = img;
+  if (img instanceof Image) {
+    _img = img.src;
+  } else if (img instanceof HTMLVideoElement) {
+    const canvas = document.createElement("canvas");
+    const { width, height } = getDomWH(img);
+    setDomWH(canvas, width, height);
+    const ctx = canvas.getContext("2d");
+    ctx && ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
+    _img = canvas.toDataURL(IMAGE_TYPES.PNG, 1);
+  } else if (img instanceof HTMLCanvasElement) {
+    _img = img.toDataURL(IMAGE_TYPES.PNG, 1);
+  } else if (typeof _img === "string" && !_img.startsWith("data:image/")) {
+    _img = await getImgBase64(_img);
+  }
+  return _img;
+}
+async function imgToBlob(img) {
+  if (!img) {
+    throw new Error("\u8BF7\u4F20\u5165\u56FE\u7247\u6570\u636E");
+  }
+  if (img instanceof Blob) {
+    return Promise.resolve(img);
+  }
+  const _img = await imgToBase64(img);
+  if (typeof _img !== "string") {
+    throw new Error("\u4F20\u5165\u7684\u56FE\u7247\u6570\u636E\u4E0D\u6B63\u786E");
+  }
+  return dataURItoBlob(_img);
+}
+async function getAllTypeImg(img) {
+  const base64 = await imgToBase64(img);
+  return {
+    base64,
+    blob: typeof base64 === "string" && dataURItoBlob(base64)
+  };
+}
+function drawScaleImage(img, scale) {
+  return new Promise((resolve) => {
+    const w = Math.round(img.width * scale);
+    const h = Math.round(img.height * scale);
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0, w, h);
+    canvas.toBlob((blob) => resolve(blob), "image/png");
+  });
+}
+function compressByQuality(blob, img, maxSize) {
+  return new Promise((resolve) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = img.width;
+    canvas.height = img.height;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    let quality = 0.98;
+    const minQ = 0.5;
+    function loop() {
+      canvas.toBlob(
+        (newBlob) => {
+          if (newBlob.size <= maxSize || quality <= minQ) {
+            resolve(newBlob);
+            return;
+          }
+          quality -= 0.02;
+          loop();
+        },
+        blob.type,
+        quality
+      );
+    }
+    loop();
+  });
+}
+function smartImageCompress(blob, maxSize) {
+  if (blob.size <= maxSize) {
+    return Promise.resolve(blob);
+  }
+  return new Promise((resolve) => {
+    const isPng = blob.type === "image/png";
+    const img = new Image();
+    img.src = URL.createObjectURL(blob);
+    img.onload = async () => {
+      URL.revokeObjectURL(img.src);
+      if (!isPng) {
+        const resBlob = await compressByQuality(blob, img, maxSize);
+        return resolve(resBlob);
+      }
+      let scale = 0.95;
+      const minScale = 0.5;
+      let currentBlob = blob;
+      const loopScale = async () => {
+        currentBlob = await drawScaleImage(img, scale);
+        if (currentBlob.size <= maxSize || scale <= minScale) {
+          resolve(currentBlob);
+          return;
+        }
+        scale -= 0.05;
+        loopScale();
+      };
+      loopScale();
+    };
+  });
+}
+
+// src/locationUtils.ts
+var DEFAULT_POSITION = {
+  lon: 120.168893,
+  lat: 30.225404,
+  addr: "\u6D59\u6C5F\u7701\u676D\u5DDE\u5E02\u4E0A\u57CE\u533A\u5357\u661F\u8857\u9053\u676D\u5DDE\u897F\u6E56\u98CE\u666F\u540D\u80DC\u533A"
+};
+function getCurrentPosition(config) {
+  return new Promise((resolve, reject) => {
+    navigator?.geolocation?.getCurrentPosition(
+      (position) => {
+        resolve(position);
+      },
+      reject,
+      {
+        enableHighAccuracy: true,
+        timeout: 5e3,
+        ...config
+      }
+    );
+  });
+}
+var numALetters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var nanoidNumALetters = customAlphabet(numALetters, 8);
+var numALettersAUrl = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_~";
+var nanoidUrl = customAlphabet(numALettersAUrl, 20);
+var DEF_FIELD_NAMES = {
+  value: "value",
+  label: "label",
+  children: "children"
+};
+var findOptionByVal = function(val, options, opt = {
+  // 是否返回完整的路径数组
+  isPathList: false,
+  pathList: [],
+  labelList: [],
+  parent: void 0,
+  fieldNames: {
+    label: "label",
+    value: "value",
+    children: "children"
+  }
+}) {
+  if (!options) {
+    console.warn("getDeepData \u8BF7\u4F20\u5165 options");
+    return;
+  }
+  const { fieldNames, isPathList, pathList = [], labelList = [] } = opt || {};
+  const { label = "label", value = "value", children = "children" } = fieldNames || {};
+  const res = options.find((it) => it[value] === val);
+  if (res) {
+    if (isPathList) {
+      pathList.unshift(res);
+      labelList.unshift(res[label]);
+      return {
+        last: res,
+        pathList,
+        labelList
+      };
+    }
+    return res;
+  }
+  const len = options.length;
+  for (let i = 0; i < len; i++) {
+    const item = options[i];
+    const childList = item[children];
+    if (Array.isArray(childList) && childList.length > 0) {
+      const res2 = findOptionByVal(val, childList, {
+        ...opt,
+        parent: item,
+        pathList,
+        labelList
+      });
+      if (res2) {
+        if (isPathList) {
+          pathList.unshift(item);
+          labelList.unshift(item[label]);
+          return {
+            last: res2.last,
+            labelList,
+            pathList
+          };
+        }
+        return res2;
+      }
+    }
+  }
+};
+function normalizeOption(item, fieldNames) {
+  const { value = "value", label = "label", children = "children" } = fieldNames || {};
+  return {
+    ...item,
+    value: item?.[value],
+    label: item?.[label],
+    children: item?.[children]
+  };
+}
+var getOptionLabel = function(val, options = [], opt = {}) {
+  const { fieldNames = DEF_FIELD_NAMES } = opt || {};
+  return findOptionByVal(val, options, opt)?.[fieldNames?.label || DEF_FIELD_NAMES.label];
+};
+function getValLabel(val, options = [], opt = {}) {
+  const { showEmpty } = opt;
+  if (showEmpty && checkEmpty(val, opt)) {
+    return handleEmptyVal(val, opt);
+  }
+  return getOptionLabel(val, options, opt);
+}
+function getArrayLabels(values, options, opt = {}) {
+  if (checkEmpty(values, opt)) {
+    return handleEmptyVal(values, opt);
+  }
+  const { split = "\u3001" } = opt || {};
+  let _values = values;
+  if (!Array.isArray(_values)) {
+    _values = [_values];
+  }
+  return _values?.map((val) => getOptionLabel(val, options, opt) ?? val)?.filter((it) => (it ?? it) || false)?.join(split);
+}
+var formatOptions = function(options, opt = {}) {
+  if (!Array.isArray(options)) {
+    console.warn("formatOptions Error: options not Array");
+    return options;
+  }
+  const {
+    fieldNames = DEF_FIELD_NAMES,
+    sourceFieldNames = DEF_FIELD_NAMES,
+    // 是否清除其他参数
+    isClear
+  } = opt || {};
+  const { label, value, children } = fieldNames;
+  const { label: sLabel, value: sValue, children: sChildren } = sourceFieldNames;
+  const _options = cloneDeep(options);
+  const resOptions = [];
+  _options.forEach((it) => {
+    const _it = isClear ? {} : { ...it };
+    _it[value] = it[sValue];
+    _it[label] = it[sLabel];
+    resOptions.push(_it);
+    const childList = it[sChildren];
+    if (childList) {
+      _it[children] = formatOptions(childList, opt);
+    }
+  });
+  return resOptions;
+};
+var getOptItByVal = function(val, options, opt) {
+  const { fieldNames } = opt || {};
+  const { value = "value", label = "label", children = "children" } = fieldNames || {};
+  for (let i = 0; i < options.length; i++) {
+    const it = options[i];
+    if (it?.[value] === val) {
+      return {
+        ...it,
+        value: it?.[value],
+        label: it?.[label],
+        children: it?.[children]
+      };
+    }
+    const _children = it?.[children];
+    if (Array.isArray(_children) && _children.length > 0) {
+      const child = getOptItByVal(val, _children, opt);
+      if (child) {
+        return {
+          ...child,
+          value: child?.[value],
+          label: child?.[label],
+          children: child?.[children]
+        };
+      }
+    }
+  }
+};
+
+// src/file/fileName.ts
+function getFileExt(fileUrl) {
+  if (typeof fileUrl !== "string") {
+    return;
+  }
+  const res = fileUrl?.match(/([^\/]+?)\.([^\/\.]+)$/);
+  if (res && res.length > 2) {
+    return res[2];
+  }
+  return fileUrl;
+}
+function getFileName(fileUrl) {
+  if (typeof fileUrl !== "string") {
+    return;
+  }
+  const res = fileUrl?.match(/([^\/]+?)\.[^\/\.]+$/);
+  if (res && res.length > 0) {
+    return res?.[1] || res?.[0];
+  }
+  return fileUrl;
+}
+function getFullFileName(fileUrl) {
+  if (typeof fileUrl !== "string") {
+    return;
+  }
+  const res = fileUrl?.match(/[^\/]+?\.[^\/\.]+$/);
+  if (res && res.length > 0) {
+    return res[0];
+  }
+  return fileUrl;
+}
+var mergeFileName = function(fileName, str = "") {
+  if (typeof fileName !== "string") {
+    return "";
+  }
+  const name = fileName?.match(/([^\/]+?)\.[^\/]+$/)?.[1] || "";
+  const suffix = fileName?.match(/[^\/]+?\.([^\/]+)$/)?.[1] || "";
+  return `${name}${str ?? ""}.${suffix}`;
+};
+var getUFileName = function(fileName) {
+  return mergeFileName(getFileName(fileName) || "up", `-~kid-${nanoidNumALetters()}~`);
+};
+var getFileNameExt = function(fileName) {
+  const regex = /^(.*)\.([^.]+)$/;
+  const result = fileName.match(regex);
+  if (result) {
+    const [, mainPart, ext] = result;
+    return {
+      mainPart,
+      ext
+    };
+  }
+  return {
+    mainPart: fileName,
+    ext: ""
+  };
+};
+
+// src/file/fileType.ts
+var TYPE_VIDEO = "video";
+var TYPE_IMG = "image";
+var TYPE_AUDIO = "audio";
+function checkUrlSuffix(url, types = [], caseSensitive = false) {
+  if (!url) {
+    return false;
+  }
+  const _url = url?.replace(/\?.+/, "");
+  const reg = new RegExp(`.(${types.join("|")})$`, caseSensitive ? void 0 : "i");
+  if (reg.test(_url)) {
+    return true;
+  }
+}
+function getFileType(file) {
+  if (typeof file === "object" && file?.type) {
+    return file?.type;
+  }
+  if (typeof file === "string") {
+    let type = null;
+    if (checkVideoUrl(file)) {
+      type = "video/mp4";
+    } else if (checkImageUrl(file)) {
+      type = "image/jpeg";
+    } else if (checkAudioUrl(file)) {
+      type = "audio/3gpp";
+    } else if (checkUrlSuffix(file, ["pdf"])) {
+      type = "application/pdf";
+    } else if (checkUrlSuffix(file, ["xlsx", "xls", "csv", "xlsm", "xlsb"])) {
+      type = "application/vnd.ms-excel";
+    } else if (checkUrlSuffix(file, ["doc", "docx"])) {
+      type = "application/msword";
+    } else if (checkUrlSuffix(file, ["ppt", "pptx"])) {
+      type = "application/vnd.ms-powerpoint";
+    }
+    return type;
+  }
+}
+function checkImageUrl(url) {
+  if (/^data:image\/\w+;base64/i.test(url)) {
+    return true;
+  }
+  const imgTypes = [
+    "apng",
+    "avif",
+    "bmp",
+    "gif",
+    "ico",
+    "cur",
+    "jpg",
+    "jpeg",
+    "jfif",
+    "pjpeg",
+    "pjp",
+    "png",
+    "svg",
+    "tif",
+    "tiff",
+    "webp"
+  ];
+  return checkUrlSuffix(url, imgTypes);
+}
+function isValidMediaType(input) {
+  const validPrefixes = ["image/", "video/", "audio/"];
+  return validPrefixes.some((prefix) => input?.startsWith(prefix));
+}
+function checkVideoUrl(url) {
+  const imgTypes = ["3gp", "mpg", "mpeg", "mp4", "m4v", "m4p", "ogv", "ogg", "mov", "webm"];
+  return checkUrlSuffix(url, imgTypes);
+}
+function checkAudioUrl(url) {
+  const imgTypes = ["3gp", "adts", "mpeg", "mp3", "mp4", "ogg", "mov", "webm", "rtp", "amr", "wav"];
+  return checkUrlSuffix(url, imgTypes);
+}
+function getFileTypeStr(file) {
+  const { type, url = file?.ossUrl } = file || {};
+  let fileType = "";
+  if (url) {
+    if (url.startsWith("data:image/") || checkImageUrl(url)) {
+      fileType = TYPE_IMG;
+    } else if (checkVideoUrl(url)) {
+      fileType = TYPE_VIDEO;
+    } else if (checkAudioUrl(url)) {
+      fileType = TYPE_AUDIO;
+    }
+  } else if (type) {
+    if (type?.startsWith("image/")) {
+      fileType = TYPE_IMG;
+    }
+    if (type?.startsWith("video/")) {
+      fileType = TYPE_VIDEO;
+    }
+    if (type?.startsWith("audio/")) {
+      fileType = TYPE_AUDIO;
+    }
+  }
+  return fileType || type;
+}
+var getFileTypeExt = function(mimeType) {
+  const mimeToExtMap = {
+    // 图片类型
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "image/bmp": "bmp",
+    "image/tiff": "tiff",
+    // 文档类型
+    "application/pdf": "pdf",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "application/vnd.ms-powerpoint": "ppt",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+    "text/plain": "txt",
+    "text/html": "html",
+    "application/json": "json",
+    // 音频/视频类型
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "video/mp4": "mp4",
+    "video/avi": "avi",
+    "video/mpeg": "mpeg",
+    // 压缩包类型
+    "application/zip": "zip",
+    "application/x-rar-compressed": "rar",
+    "application/x-7z-compressed": "7z"
+  };
+  if (!mimeType || typeof mimeType !== "string") {
+    return "";
+  }
+  const normalizedMimeType = mimeType.trim().toLowerCase();
+  if (mimeToExtMap[normalizedMimeType]) {
+    return mimeToExtMap[normalizedMimeType];
+  }
+  const mainType = normalizedMimeType.split("/")[0];
+  switch (mainType) {
+    case "image":
+      return "img";
+    case "audio":
+      return "audio";
+    case "video":
+      return "video";
+    default:
+      return mainType?.match(/[^\/]*\/([^\/]+)$/)?.[1] || mimeType;
+  }
+};
+
+// src/url.ts
+function replaceSearch(url, search) {
+  if (!url || typeof url !== "string") {
+    console.warn("Warn replaceSearch: \u8BF7\u4F20\u5165\u6B63\u786E\u7684 url \u5B57\u7B26\u4E32");
+    return url;
+  }
+  const _url = fixUrlQuery(url);
+  const hashIdx = _url.indexOf("#");
+  const queryIdx = _url.indexOf("?");
+  let hash = "";
+  let resUrl = _url;
+  if (queryIdx >= 0) {
+    resUrl = _url.slice(0, queryIdx);
+  } else if (hashIdx >= 0) {
+    resUrl = _url.slice(0, hashIdx);
+  }
+  if (hashIdx >= 0) {
+    hash = _url.slice(hashIdx);
+  }
+  resUrl += search?.indexOf("?") >= 0 ? "" : "?";
+  resUrl += search;
+  resUrl += hash;
+  return resUrl;
+}
+function objToSearch(query, opt) {
+  if (!query || typeof query !== "object") {
+    console.warn("Warn objToSearch: \u8BF7\u4F20\u5165\u6B63\u786E\u7684\u5BF9\u8C61");
+    return;
+  }
+  let hasQuery = opt?.hasQuery;
+  if (typeof opt === "boolean") {
+    hasQuery = opt;
+  }
+  const { isEncode } = opt || {};
+  let search = hasQuery ? "?" : "";
+  Object.keys(query).forEach((key) => {
+    if (search && search != "?") {
+      search += "&";
+    }
+    const _key = isEncode ? encodeURIComponent(key) : key;
+    search += _key;
+    search += "=";
+    const val = isEncode ? encodeURIComponent(query[key]) : query[key];
+    search += val;
+  });
+  return search;
+}
+function fixUrlQuery(url) {
+  if (!url || typeof url !== "string") {
+    console.warn("Warn handleUrlQuery: \u8BF7\u4F20\u5165\u6B63\u786E\u7684 url \u5B57\u7B26\u4E32");
+    return url;
+  }
+  const hashIdx = url.indexOf("#");
+  const queryIdx = url.indexOf("?");
+  if (queryIdx < hashIdx) {
+    let hash = url.slice(hashIdx);
+    const hashQueryIdx = hash.indexOf("?");
+    if (hashQueryIdx >= 0) {
+      const _url = url.slice(0, queryIdx);
+      const urlQuery = url.slice(queryIdx, hashIdx)?.replace(/\/$/, "");
+      const hashQuery = hash.slice(hashQueryIdx)?.replace("?", "")?.replace(/\/$/, "");
+      hash = hash.slice(0, hashQueryIdx);
+      return `${_url}${urlQuery}&${hashQuery}${hash}`;
+    }
+    return url;
+  }
+  if (queryIdx >= 0 && hashIdx >= 0 && queryIdx > hashIdx) {
+    const hash = url.slice(hashIdx, queryIdx);
+    const search = url.slice(queryIdx);
+    return `${url.slice(0, hashIdx)}${search}${hash}`;
+  }
+  return url;
+}
+function searchToObj(url) {
+  if (!url || typeof url !== "string") {
+    console.warn("Warn getSearchParams: \u8BF7\u4F20\u5165\u6B63\u786E\u7684 url \u5B57\u7B26\u4E32.");
+    return;
+  }
+  let queryBody;
+  if (url.includes("?")) {
+    const _url = fixUrlQuery(url).replace("/#", "#");
+    const queryIdx = _url.indexOf("?");
+    const hashIdx = _url.indexOf("#");
+    if (queryIdx < 0) {
+      return;
+    }
+    queryBody = hashIdx >= 0 ? _url.slice(queryIdx + 1, hashIdx) : _url.slice(queryIdx + 1);
+  } else {
+    const bare = url.replace(/^[?&]+/, "").split("#")[0];
+    if (!bare || !bare.includes("=") || url.includes("://")) {
+      return;
+    }
+    queryBody = bare;
+  }
+  if (!queryBody) {
+    return;
+  }
+  const res = {};
+  queryBody.split("&")?.forEach((it) => {
+    if (!it) {
+      return;
+    }
+    const eqIdx = it.indexOf("=");
+    const rawKey = eqIdx >= 0 ? it.slice(0, eqIdx) : it;
+    const rawVal = eqIdx >= 0 ? it.slice(eqIdx + 1) : "";
+    try {
+      res[decodeURIComponent(rawKey)] = decodeURIComponent(rawVal);
+    } catch {
+      res[rawKey] = rawVal;
+    }
+  });
+  return res;
+}
+function addQuery(url, params, opt = {}) {
+  const newObj = { ...searchToObj(url), ...params };
+  return replaceSearch(url, objToSearch(newObj, { hasQuery: !!params, isEncode: opt?.isEncode }));
+}
+function addSearch(url, params, opt = {}) {
+  const newObj = { ...searchToObj(url), ...params };
+  return objToSearch(newObj, { hasQuery: !!params, isEncode: opt?.isEncode });
+}
+
+// src/upload/uploadUtils.ts
+var formatDirStr = function(dir) {
+  return dir?.replace(/^\/(.*)\/*$/, "$1").replace(/(.?=*)\/*$/, "$1/");
+};
+
+// src/upload/OssUploadUtil.ts
+var isPublicMap = {
+  0: "&",
+  1: "?"
+};
+function getSignature(opt = {}) {
+  const { serverUrl = getGlobalServeConfig()?.serverUrl || "/api/v1/user/oss/getWebOssConfig" } = opt;
+  if (window._$ossSignatureRes && serverUrl === window._$ossSignatureRes.serverUrl && dayjs2().valueOf() - window._$ossSignatureRes.__saveTime < window._$ossSignatureRes.expireTimeMilles - 1e4) {
+    return Promise.resolve(window._$ossSignatureRes);
+  }
+  const { axios: _ax = axios, params = {}, axiosConf } = opt;
+  params.dir = formatDirStr(params.dir);
+  return _ax.get(serverUrl, {
+    ...axiosConf,
+    params: {
+      isPublic: 1,
+      ...params
+    }
+  }).then((res) => {
+    window._$ossSignatureRes = res?.data?.data ?? res?.data ?? res;
+    if (window._$ossSignatureRes) {
+      window._$ossSignatureRes.__saveTime = dayjs2().valueOf();
+      window._$ossSignatureRes.serverUrl = serverUrl;
+    }
+    return window._$ossSignatureRes;
+  });
+}
+var OssUploadUtil = class {
+  /** axios 实例 */
+  axios;
+  /** axios 配置参数 */
+  axiosConf;
+  /** 获取配置的接口地址 */
+  serverUrl;
+  /** 获取配置的接口自定义入参 */
+  signatureParams;
+  constructor(props = {}) {
+    this.axios = props.axios || axios;
+    this.axiosConf = props.axiosConf || {};
+    this.serverUrl = props.serverUrl || getGlobalServeConfig()?.serverUrl || "/api/v1/user/oss/getWebOssConfig";
+    this.signatureParams = props.signatureParams || {};
+  }
+  getSignature(serverUrl = this.serverUrl, opt) {
+    return this._getSignature(serverUrl, opt);
+  }
+  upload(file, opt = {}) {
+    return this._upload(file, { ...opt });
+  }
+  _getSignature(serverUrl = this.serverUrl, opt) {
+    return getSignature({
+      ...opt,
+      serverUrl,
+      axios: opt?.axios || this.axios,
+      axiosConf: { ...this.axiosConf, ...opt?.axiosConf }
+    });
+  }
+  _upload(file, opt = {}) {
+    return new Promise(async (resolve, reject) => {
+      const ossParams = await this._getSignature(opt.serverUrl || this.serverUrl, {
+        ...opt,
+        params: { ...this.signatureParams, ...opt.params }
+      });
+      const { ossParams: propOssParams, fileName } = opt || {};
+      const formData = new FormData();
+      const filename = fileName || file.name;
+      const key = `${ossParams?.dir}${filename}`;
+      formData.set("key", key);
+      formData.set("OSSAccessKeyId", ossParams.accessid);
+      formData.set("policy", ossParams.policy);
+      formData.set("Signature", ossParams.signature);
+      if (ossParams.callback) {
+        formData.set("callback", ossParams.callback);
+      }
+      formData.set("success_action_status", 200);
+      formData.set("file", file);
+      if (propOssParams) {
+        for (const key2 in propOssParams) {
+          if (Object.hasOwnProperty.call(propOssParams, key2)) {
+            formData.set(key2, propOssParams[key2]);
+          }
+        }
+      }
+      const _axios = opt?.axios || this.axios;
+      return _axios.post(ossParams.host, formData, { ...this.axiosConf, ...opt?.axiosConf }).then((res) => {
+        if (getGlobalServeConfig()?.showThumbnail) {
+          res.data.data.thumbnailUrl = `${res?.data?.data?.fileUrl}${opt?.thumbnailParams ? isPublicMap[opt?.signatureParams?.isPublic] + opt?.thumbnailParams : ""}`;
+        }
+        resolve(res);
+        return res;
+      }).catch((err) => {
+        console.error("oss upload err", err);
+        reject(err);
+        return Promise.reject(err);
+      });
+    });
+  }
+};
+var OssUploadUtil_default = OssUploadUtil;
+
+// src/scan-qr.ts
+function objToBlob(obj, charset = "utf-8") {
+  const jsonStr = JSON.stringify(obj);
+  const blob = new Blob([jsonStr], {
+    type: `application/json;charset=${charset}`
+  });
+  return blob;
+}
+var getCodeInfo = async (id, opt) => {
+  const { env, baseUrl } = opt;
+  try {
+    const url = ` ${baseUrl || "https://open-oss.abt.hzabjt.com"}/qr-code/${env}/${String(id)}`;
+    const response = await fetch(url);
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw error;
+  }
+};
+var setCodeInfo = async (value, opt) => {
+  const { env } = opt;
+  try {
+    const id = nanoidUrl();
+    const file = objToBlob(value);
+    const ossUploader = new OssUploadUtil_default({ signatureParams: { withoutPrefix: true } });
+    const uploadResult = await ossUploader.upload(file, {
+      fileName: id,
+      params: {
+        dir: `/qr-code/${env}`
+      }
+    });
+    const fileUrl = uploadResult?.data?.data?.fileUrl;
+    return {
+      fileUrl,
+      id
+    };
+  } catch (error) {
+    throw error;
+  }
+};
+
+// src/sizeAdapter.ts
+function getClientStyle() {
+  return {
+    width: document.documentElement.clientWidth || document.body.clientWidth,
+    height: document.documentElement.clientHeight || document.body.clientHeight
+  };
+}
+var clientStyle = getClientStyle();
+window.addEventListener("resize", () => {
+  const { width, height } = getClientStyle();
+  clientStyle.width = width;
+  clientStyle.height = height;
+});
+function getViewportPX() {
+  const { width, height } = clientStyle;
+  return {
+    wPx: width / 100,
+    hPx: height / 100
+  };
+}
+var DEFAULT_SIZE = {
+  width: 750,
+  height: 1334
+};
+function setDefaultSize(width, height) {
+  DEFAULT_SIZE.width = width || 750;
+  DEFAULT_SIZE.height = height || 1334;
+}
+function getClientRate(current, defaultVal) {
+  return parseFloat(current) / defaultVal;
+}
+function getVW(pxNum = 0) {
+  return `${getClientRate(pxNum, DEFAULT_SIZE.width) * 100}vw`;
+}
+function getVH(pxNum = 0) {
+  return `${getClientRate(pxNum, DEFAULT_SIZE.height) * 100}vh`;
+}
+function getWpx(pxNum = 0) {
+  return getClientRate(pxNum, DEFAULT_SIZE.width) * clientStyle.width;
+}
+function getHpx(pxNum = 0) {
+  return getClientRate(pxNum, DEFAULT_SIZE.height) * clientStyle.height;
+}
+function getHPxByVW(vw = 0) {
+  let _vw = vw;
+  if (typeof _vw === "string") {
+    _vw = parseFloat(_vw);
+  }
+  return clientStyle.width * (_vw / 100);
+}
+function getWPxByVH(vh = 0) {
+  let _vh = vh;
+  if (typeof _vh === "string") {
+    _vh = parseFloat(_vh);
+  }
+  return clientStyle.height * (_vh / 100);
+}
+
+// src/string.ts
+var convertToCamelCase = function(s) {
+  return s.replace(/-(\w)/g, function(all, letter) {
+    return letter.toUpperCase();
+  });
+};
+var objStrToObj = function(objStr) {
+  let _objStr = objStr;
+  if (typeof _objStr === "object") {
+    return _objStr;
+  }
+  if (typeof _objStr === "string") {
+    _objStr = _objStr.trim();
+    if (/^\[.*\]$|^\{.*\}$/.test(_objStr)) {
+      try {
+        _objStr = JSON.parse(_objStr);
+      } catch (error) {
+      }
+    }
+  }
+  return _objStr;
+};
+
+// src/file/file.ts
+function getFileURL(file) {
+  const _file = file?.file || file;
+  if (!(_file instanceof File)) {
+    return;
+  }
+  const url = _file.url || null;
+  try {
+    const win = window;
+    if (win.createObjectURL != void 0) {
+      return win.createObjectURL(_file);
+    } else if (window.URL != void 0) {
+      return window.URL.createObjectURL(_file);
+    } else if (window.webkitURL != void 0) {
+      return window.webkitURL.createObjectURL(_file);
+    }
+  } catch (error) {
+    console.warn("getFileURL Error: ", error);
+  }
+  return url;
+}
+
+export { DEFAULT_POSITION, DEFAULT_SIZE, DEF_FIELD_NAMES, IMAGE_TYPES, TYPE_AUDIO, TYPE_IMG, TYPE_VIDEO, addQuery, addSearch, adjustColor, adjustTextColor, calculateAge, calculateCheckCode, checkAudioUrl, checkEmpty, checkEmptyImg, checkImageUrl, checkUrlSuffix, checkVideoUrl, clientStyle, compressByQuality, contrast, contrastRatio, convert15to18, convertToCamelCase, cropImage, cropImageToCanvas, dataURItoBlob, drawScaleImage, findOptionByVal, fixUrlQuery, formatOptions, getAllTypeImg, getArr, getArrayLabels, getCanvas, getCanvasByImg, getCanvasPic, getClientRate, getClientStyle, getCodeInfo, getCurrentPosition, getDaysInMonth, getDomWH, getFileExt, getFileName, getFileNameExt, getFileType, getFileTypeExt, getFileTypeFromBase64, getFileTypeFromBlob, getFileTypeStr, getFileURL, getFullFileName, getGlobalServeConfig, getHPxByVW, getHpx, getIdCardInfo, getImgBase64, getImgEle, getOptItByVal, getOptionLabel, getTextColor, getUFileName, getVH, getVW, getValLabel, getViewportPX, getWPxByVH, getWpx, handleEmptyVal, hexToRGB, hslToRgb, imgToBase64, imgToBlob, imgToCanvas, isBase64Str, isGray, isValidBirthDate, isValidIdCard, isValidMediaType, luminance, mergeFileName, nanoidNumALetters, nanoidUrl, normalizeOption, numALetters, numALettersAUrl, objStrToObj, objToSearch, replaceSearch, rgbNumLimit, rgbToHex, rgbToHsl, scaleImage, scaleImageToCanvas, searchToObj, setCodeInfo, setDefaultSize, setDomWH, setGlobalServeConfig, setGlobalServeConfigs, smartImageCompress, verifyCheckCode };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map