@zero-library/common 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,1527 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var icons = require('@ant-design/icons');
+var react = require('react');
+var antd = require('antd');
+var parse = require('html-react-parser');
+var jsonrepair = require('jsonrepair');
+var markdownit = require('markdown-it');
+var container = require('markdown-it-container');
+var core = require('@react-pdf-viewer/core');
+var pageNavigation = require('@react-pdf-viewer/page-navigation');
+var thumbnail = require('@react-pdf-viewer/thumbnail');
+var zoom = require('@react-pdf-viewer/zoom');
+require('@react-pdf-viewer/core/lib/styles/index.css');
+var zh_CN = require('@react-pdf-viewer/locales/lib/zh_CN.json');
+require('@react-pdf-viewer/page-navigation/lib/styles/index.css');
+var dayjs = require('dayjs');
+var relativeTime = require('dayjs/plugin/relativeTime');
+var AES = require('crypto-js/aes');
+var encUtf8 = require('crypto-js/enc-utf8');
+var Decimal = require('decimal.js');
+var axios = require('axios');
+var lib = require('antd/lib');
+require('@react-pdf-viewer/thumbnail/lib/styles/index.css');
+require('@react-pdf-viewer/zoom/lib/styles/index.css');
+var classNames = require('classnames');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var parse__default = /*#__PURE__*/_interopDefault(parse);
+var markdownit__default = /*#__PURE__*/_interopDefault(markdownit);
+var container__default = /*#__PURE__*/_interopDefault(container);
+var zh_CN__default = /*#__PURE__*/_interopDefault(zh_CN);
+var dayjs__default = /*#__PURE__*/_interopDefault(dayjs);
+var relativeTime__default = /*#__PURE__*/_interopDefault(relativeTime);
+var AES__default = /*#__PURE__*/_interopDefault(AES);
+var encUtf8__default = /*#__PURE__*/_interopDefault(encUtf8);
+var Decimal__default = /*#__PURE__*/_interopDefault(Decimal);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var classNames__default = /*#__PURE__*/_interopDefault(classNames);
+
+// src/components/File/styles.module.less
+var styles_module_default = {
+  nsPreviewImage: "styles_module_nsPreviewImage",
+  nsPreviewPdf: "styles_module_nsPreviewPdf",
+  pdfToolbar: "styles_module_pdfToolbar",
+  nsPreviewVideo: "styles_module_nsPreviewVideo",
+  nsPreviewAudio: "styles_module_nsPreviewAudio"
+};
+var AudioPlayer_default = ({ fileUrl }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs("audio", { controls: true, className: styles_module_default.nsPreviewAudio, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("source", { src: fileUrl, type: "audio/mpeg" }),
+    "\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 audio \u6807\u7B7E\u3002"
+  ] });
+};
+
+// src/utils/theme.ts
+var getPrimaryColor = () => {
+  const searchParams = new URLSearchParams(location.search);
+  const mainSource = searchParams.get("mainSource") || "cube-uc";
+  if (mainSource === "cube-uc") {
+    return "#34AFBE";
+  } else if (mainSource === "uc") {
+    return "#FA541C";
+  }
+};
+var LgPrimaryColor = getPrimaryColor();
+var themeConfig = {
+  token: { colorPrimary: LgPrimaryColor, colorLink: LgPrimaryColor },
+  cssVar: true
+};
+var FileIcon_default = ({ suffix, fontSize = 22 }) => {
+  const styles = { fontSize, color: LgPrimaryColor };
+  const Icon = react.useMemo(() => {
+    switch (suffix?.toUpperCase()) {
+      case "TXT":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileTextOutlined, {});
+      case "PDF":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FilePdfOutlined, {});
+      case "DOC":
+      case "DOCX":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileWordOutlined, {});
+      case "XLS":
+      case "XLSX":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileExcelOutlined, {});
+      case "PPT":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FilePptOutlined, {});
+      case "MP4":
+      case "MOV":
+      case "AVI":
+      case "FLV":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.VideoCameraOutlined, {});
+      case "MP3":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.NotificationOutlined, {});
+      case "JPG":
+      case "JPEG":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileJpgOutlined, {});
+      case "PNG":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileImageOutlined, {});
+      case "GIF":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileGifOutlined, {});
+      case "ZIP":
+      case "RAR":
+      case "7Z":
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileZipOutlined, {});
+      case "CATALOG":
+        return /* @__PURE__ */ jsxRuntime.jsx("i", { style: styles, className: "iconfont icon-wenjianjia" });
+      // 文件夹
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(icons.FileUnknownOutlined, {});
+    }
+  }, [suffix]);
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { style: styles, children: Icon });
+};
+var VideoPlayer_default = ({ fileUrl }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs("video", { controls: true, className: styles_module_default.nsPreviewVideo, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("source", { src: fileUrl, type: "video/mp4" }),
+    "\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 video \u6807\u7B7E\u3002"
+  ] });
+};
+var baseComponentMap = {
+  // renderMarkdown: () => import('@/components/RenderMarkdown')
+};
+var LazyComponent_default = ({ type, customComponents, ...rest }) => {
+  const componentMap = react.useMemo(() => {
+    return { ...baseComponentMap, ...customComponents };
+  }, [customComponents]);
+  const LazyComponent = react.useMemo(() => {
+    const loader = componentMap[type];
+    return loader ? react.lazy(loader) : null;
+  }, [type, componentMap]);
+  if (!LazyComponent) return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+    "\u672A\u77E5\u7C7B\u578B\uFF1A",
+    type
+  ] });
+  return /* @__PURE__ */ jsxRuntime.jsx(react.Suspense, { fallback: /* @__PURE__ */ jsxRuntime.jsx("div", { children: "\u52A0\u8F7D\u4E2D..." }), children: /* @__PURE__ */ jsxRuntime.jsx(LazyComponent, { ...rest }) });
+};
+var md = markdownit__default.default({ html: true, breaks: true });
+md.renderer.rules.link_open = function(tokens, idx, options, env, self) {
+  const token = tokens[idx];
+  token.attrPush(["target", "_blank"]);
+  return self.renderToken(tokens, idx, options);
+};
+var replaceSpecialCharacter = (str) => {
+  return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+function parseParams(info) {
+  const params = {};
+  const regex = /(\w+)\s*=\s*(?:(['"])(.*?)\2|(\S+))/g;
+  let match;
+  while ((match = regex.exec(info)) !== null) {
+    const key = match[1];
+    const value = match[3] ?? match[4] ?? "";
+    if (key === "data") {
+      let obj = {};
+      try {
+        obj = JSON.parse(value);
+      } catch {
+        try {
+          obj = JSON.parse(jsonrepair.jsonrepair(value));
+        } catch {
+          obj = {};
+        }
+      }
+      params[key] = replaceSpecialCharacter(JSON.stringify(obj));
+    } else {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+md.use(container__default.default, "alert", {
+  validate: (params) => /^alert/.test(params.trim()),
+  render: function(tokens, idx) {
+    const token = tokens[idx];
+    if (token.nesting === 1) {
+      const info = token.info.trim();
+      const params = parseParams(info);
+      return `<lazy-component ${Object.entries(params).map(([key, value]) => `${key}=${value}`).join(" ")}>`;
+    } else {
+      return "</lazy-component>";
+    }
+  }
+});
+function preprocess(content) {
+  return content.replace(
+    /:::alert([\s\S]*?):::/g,
+    // 匹配 :::alert ... :::
+    (match, params) => {
+      return `
+ :::alert ${params.trim()} 
+ ::: 
+`;
+    }
+  );
+}
+function highlightKeywords(html, keywords) {
+  const escaped = keywords.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const regex = new RegExp(`(${escaped.join("|")})`, "gi");
+  return html.replace(regex, '<span class="cube-hl">$1</span>');
+}
+var RenderMarkdown_default = ({ content = "", searchValue, customComponents, onChange, onPartialChange }) => {
+  const reactContent = react.useMemo(() => {
+    if (!content) return null;
+    let fixedContent = content;
+    const openCount = (fixedContent.match(/:::alert\b/g) || []).length;
+    const closeCount = (fixedContent.match(/\s*:::\s*/gm) || []).length - openCount;
+    let incomplete = false;
+    if (openCount > closeCount) {
+      incomplete = true;
+      fixedContent += ":::";
+    }
+    fixedContent = preprocess(fixedContent);
+    let rawHtml = md.render(fixedContent);
+    rawHtml = searchValue ? highlightKeywords(rawHtml, [searchValue]) : rawHtml;
+    let lazyIndex = -1;
+    const allLazyMatches = [...rawHtml.matchAll(/<lazy-component/gi)];
+    const lastLazyIndex = allLazyMatches.length - 1;
+    return parse__default.default(rawHtml, {
+      replace: (domNode) => {
+        if (domNode.name === "lazy-component") {
+          lazyIndex++;
+          const el = domNode;
+          const type = el.attribs.type;
+          const data = JSON.parse(el.attribs.data || "{}");
+          const loading = incomplete && lazyIndex === lastLazyIndex;
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            LazyComponent_default,
+            {
+              type,
+              data,
+              loading,
+              customComponents,
+              onChange,
+              onPartialChange
+            },
+            `${type}${lazyIndex}`
+          );
+        }
+      }
+    });
+  }, [content, searchValue]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ns-markdown", children: reactContent });
+};
+var MarkdownPreview_default = ({ fileUrl, searchValue }) => {
+  const [content, setContent] = react.useState("");
+  const [error, setError] = react.useState("");
+  const fetchMarkdown = async () => {
+    const res = await fetch(fileUrl);
+    if (res.status !== 200) {
+      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${res.status}`);
+    }
+    const markdownText = await res.text();
+    if (!markdownText) {
+      throw new Error("\u8FD4\u56DE\u5185\u5BB9\u4E3A\u7A7A");
+    }
+    setContent(markdownText);
+  };
+  const init = async () => {
+    setContent("");
+    setError("");
+    if (fileUrl) {
+      try {
+        await fetchMarkdown();
+      } catch (error2) {
+        setError("\u52A0\u8F7D\u6216\u89E3\u6790 Markdown \u5931\u8D25");
+      }
+    }
+  };
+  react.useEffect(() => {
+    init();
+  }, [fileUrl]);
+  return error ? /* @__PURE__ */ jsxRuntime.jsx(antd.Result, { status: "error", title: error }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "height-full", children: /* @__PURE__ */ jsxRuntime.jsx(RenderMarkdown_default, { content, searchValue }) });
+};
+function createValtioContext() {
+  const Context = react.createContext(null);
+  const ValtioProvider = ({ store, children }) => /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value: store, children });
+  const useValtioStore = () => {
+    const store = react.useContext(Context);
+    if (!store) throw new Error("useStore must be used within Provider");
+    return store;
+  };
+  return {
+    ValtioProvider,
+    useValtioStore
+    // Context
+  };
+}
+
+// src/hooks/iframe/iframeRelay.ts
+function emit(type, data, to = "top") {
+  const payload = { type, data, to };
+  try {
+    window.parent.postMessage(payload, "*");
+  } catch (err) {
+    console.warn("emit parent failed", err);
+  }
+}
+function emitToChild(iframeWindow, type, data, origin = "*") {
+  if (!iframeWindow) {
+    console.warn("emitToChild failed: iframeWindow is null");
+    return;
+  }
+  const payload = { type, data, to: "child" };
+  try {
+    iframeWindow.postMessage(payload, origin);
+  } catch (err) {
+    console.warn("emit to child failed", err);
+  }
+}
+
+// src/utils/is.ts
+var toString = Object.prototype.toString;
+function is(val, type) {
+  return toString.call(val) === `[object ${type}]`;
+}
+function isUnDef(val) {
+  return is(val, "Undefined");
+}
+function isDef(val) {
+  return !isUnDef(val);
+}
+function isObject(val) {
+  return is(val, "Object");
+}
+function isEmptyObj(val) {
+  if (isObject(val)) {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+}
+function isDate(val) {
+  return is(val, "Date");
+}
+function isNull(val) {
+  return is(val, "Null");
+}
+function isNullOrUnDef(val) {
+  return isUnDef(val) || isNull(val);
+}
+function isNumber(val) {
+  return is(val, "Number");
+}
+function isNumberNoNaN(val) {
+  return is(val, "Number") && !isNaN(val);
+}
+function isString(val) {
+  return is(val, "String");
+}
+function isFunction(val) {
+  return is(val, "Function");
+}
+function isPromise(val) {
+  return is(val, "Promise") && isObject(val) && isFunction(val.then) && isFunction(val.catch);
+}
+function isBoolean(val) {
+  return is(val, "Boolean");
+}
+function isRegExp(val) {
+  return is(val, "RegExp");
+}
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isEmpty(val) {
+  if (isArray(val) || isString(val)) {
+    return val.length === 0;
+  }
+  if (isNullOrUnDef(val)) {
+    return true;
+  }
+  if (val instanceof Map || val instanceof Set) {
+    return val.size === 0;
+  }
+  return isEmptyObj(val);
+}
+function isWindow(val) {
+  return typeof window !== "undefined" && is(val, "Window");
+}
+function isElement(val) {
+  return isObject(val) && !!val.tagName;
+}
+function isMap(val) {
+  return is(val, "Map");
+}
+var isServer = typeof window === "undefined";
+var isClient = !isServer;
+var isExternal = (path) => {
+  return /^(https?:|mailto:|tel:)/.test(path);
+};
+var isBlob = (val) => {
+  return is(val, "Blob");
+};
+
+// src/hooks/iframe/useIframeRelayBridge.ts
+function useIframeRelayBridge(allowedOrigins = ["*"]) {
+  const handlers = react.useRef({});
+  react.useEffect(() => {
+    const onMessage = (evt) => {
+      const { data, source, origin } = evt;
+      if (!data || !isObject(data) || !data.type) return;
+      if (allowedOrigins[0] !== "*" && !allowedOrigins.includes(origin)) return;
+      const { type, data: params, to = "parent" } = data;
+      const isTop = window.parent === window;
+      if (to === "top" && !isTop) {
+        window.parent.postMessage(data, allowedOrigins[0] === "*" ? "*" : origin);
+        return;
+      }
+      const fns = handlers.current[type] || [];
+      fns.forEach((fn) => fn(params, source, origin));
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [allowedOrigins]);
+  function on(type, handler) {
+    handlers.current[type] = handlers.current[type] || [];
+    handlers.current[type].push(handler);
+  }
+  function off(type, handler) {
+    handlers.current[type] = (handlers.current[type] || []).filter((fn) => fn !== handler);
+  }
+  return { on, off };
+}
+function useDebounce(func, wait = 400) {
+  const { current } = react.useRef({ func, timeOut: null });
+  react.useEffect(() => {
+    current.func = func;
+  }, [func]);
+  let args;
+  function debounce(..._args) {
+    args = _args;
+    if (current.timeOut) {
+      clearTimeout(current.timeOut);
+      current.timeOut = null;
+    }
+    return new Promise((resolve, reject) => {
+      current.timeOut = setTimeout(async () => {
+        try {
+          const result = await current.func.apply(null, args);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+      }, wait);
+    });
+  }
+  function cancel() {
+    if (!current.timeOut) return;
+    clearTimeout(current.timeOut);
+    current.timeOut = null;
+  }
+  function flush() {
+    cancel();
+    return current.func.apply(null, args);
+  }
+  debounce.flush = flush;
+  debounce.cancel = cancel;
+  return react.useCallback(debounce, []);
+}
+
+// src/utils/common.ts
+var deepCopy = (obj, isJson = true) => {
+  if (!isArray(obj) && !isObject(obj)) return obj;
+  if (isJson) return JSON.parse(JSON.stringify(obj));
+  const result = isArray(obj) ? [] : {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = deepCopy(obj[key], isJson);
+    }
+  }
+  return result;
+};
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, val] of a.entries()) {
+      if (!b.has(key) || !deepEqual(val, b.get(key))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const val of a.values()) {
+      if (!b.has(val)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+var deepMerge = (base, override) => {
+  const result = { ...base };
+  Object.keys(override || {}).forEach((key) => {
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (typeof baseValue === "object" && baseValue !== null && !isArray(baseValue) && typeof overrideValue === "object" && overrideValue !== null && !isArray(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue);
+    } else if (overrideValue !== void 0) {
+      result[key] = overrideValue;
+    }
+  });
+  return result;
+};
+var objToOptions = (obj) => {
+  return Object.keys(obj).map((key) => ({
+    label: obj[key],
+    value: Number(key)
+  }));
+};
+var arrToObj = (arr = [], key) => {
+  const obj = {};
+  arr?.forEach((item) => {
+    obj[item[key]] = item;
+  });
+  return obj;
+};
+var nsSetInterval = (fn, t) => {
+  let timer = null;
+  let isCancelled = false;
+  const interval = () => {
+    timer = setTimeout(async () => {
+      if (isCancelled) {
+        return;
+      }
+      await fn();
+      if (!isCancelled) {
+        interval();
+      }
+    }, t);
+  };
+  interval();
+  return {
+    isRun: () => !!timer,
+    cancel: () => {
+      isCancelled = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+};
+var genNonDuplicateID = () => {
+  let idStr = Date.now().toString(36);
+  idStr += Math.random().toString(36).substr(2);
+  return idStr;
+};
+var copyText = (text) => {
+  if (navigator.clipboard && window.isSecureContext) {
+    return navigator.clipboard.writeText(text);
+  } else {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "absolute";
+    textArea.style.opacity = "0";
+    textArea.style.left = "-999999px";
+    textArea.style.top = "-999999px";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    return new Promise((res, rej) => {
+      document.execCommand("copy") ? res() : rej();
+      textArea.remove();
+    });
+  }
+};
+function formatNumberWithCommas(number) {
+  const numericValue = parseFloat(number);
+  if (!isNaN(numericValue)) {
+    return numericValue.toLocaleString();
+  }
+  return number;
+}
+var generateRandomNumbers = (min, max, count) => {
+  const randomNumbers = /* @__PURE__ */ new Set();
+  while (randomNumbers.size < count) {
+    const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
+    randomNumbers.add(randomNumber);
+  }
+  return Array.from(randomNumbers);
+};
+var getFileName = (filePath) => {
+  return filePath.split("?")[0].split("/").pop() || "";
+};
+var textAreaView = (con) => {
+  return con ? con.replace(/\r\n/g, "\n").replace(/\n/g, "<br/>") : "";
+};
+var buildUrlParams = (obj, url) => {
+  const params = Object.entries(obj).filter(([, value]) => !isNullOrUnDef(value)).map(([key, value]) => {
+    if (isArray(value)) {
+      return value.filter((v) => !isNullOrUnDef(v)).map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`).join("&");
+    }
+    return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+  }).join("&");
+  if (url) {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}${params}`;
+  }
+  return params;
+};
+var downloadFile = (url, name) => {
+  const a = document.createElement("a");
+  a.download = name || "\u56FE\u7247\u4E0B\u8F7D";
+  a.href = url;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+};
+var addUrlLastSlash = (url = "") => {
+  const u = new URL(url, "https://logosdata.cn");
+  let pathname = u.pathname;
+  if (!pathname.endsWith("/")) {
+    pathname += "/";
+  }
+  u.pathname = pathname;
+  return `${isExternal(url) ? u.origin : ""}${u.pathname}${u.search}${u.hash}`;
+};
+var getUrlMainSource = (url, preHref) => {
+  if (!preHref) return url;
+  let newUrl = "";
+  const preHrefUrl = new URL(preHref);
+  const urlParts = url.split("?");
+  const srcParams = new URLSearchParams(urlParts[1] || "");
+  if (srcParams.has("mainSource")) {
+    newUrl = url;
+  } else {
+    const mainSource = preHrefUrl.searchParams.get("mainSource");
+    if (mainSource) {
+      newUrl = buildUrlParams({ mainSource }, url);
+    } else {
+      newUrl = url;
+    }
+  }
+  return newUrl;
+};
+var getWebSocketUrl = (path, customHost) => {
+  const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+  const host = customHost || window.location.host;
+  return `${protocol}//${host}${path}`;
+};
+
+// src/hooks/useDeepEffect.ts
+function useDeepEffect(effect, deps) {
+  const prevDepsRef = react.useRef();
+  const depsChanged = !prevDepsRef.current || deps.length !== prevDepsRef.current.length || deps.some((dep, i) => !deepEqual(dep, prevDepsRef.current[i]));
+  react.useEffect(() => {
+    if (depsChanged) {
+      prevDepsRef.current = deps;
+      return effect();
+    }
+  }, [depsChanged]);
+}
+function useRefState(init) {
+  const [state, setState] = react.useState(init);
+  const stateRef = react.useRef(init);
+  const setProxy = (newVal) => {
+    stateRef.current = newVal;
+    setState(newVal);
+  };
+  const getState = () => stateRef.current;
+  return [state, setProxy, getState];
+}
+var useSyncInput = (storeValue, setStoreValue) => {
+  const [inputValue, setInputValue] = react.useState(storeValue);
+  react.useEffect(() => {
+    if (storeValue !== inputValue) {
+      setInputValue(storeValue);
+    }
+  }, [storeValue]);
+  const handleValueChange = (value) => {
+    setStoreValue(value);
+    setInputValue(value);
+  };
+  return {
+    inputValue,
+    setInputValue: handleValueChange
+  };
+};
+function useThrottle(func, wait) {
+  const { current } = react.useRef({ func, timeOut: null });
+  react.useEffect(() => {
+    current.func = func;
+  }, [func]);
+  let args;
+  function throttle(..._args) {
+    args = _args;
+    return new Promise((resolve, reject) => {
+      if (!current.timeOut) {
+        try {
+          const result = current.func.apply(null, args);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        current.timeOut = setTimeout(() => {
+          current.timeOut = null;
+        }, wait);
+      }
+    });
+  }
+  function cancel() {
+    if (!current.timeOut) return;
+    clearTimeout(current.timeOut);
+    current.timeOut = null;
+  }
+  function flush() {
+    cancel();
+    return current.func.apply(null, args);
+  }
+  throttle.flush = flush;
+  throttle.cancel = cancel;
+  return react.useCallback(throttle, []);
+}
+dayjs__default.default.extend(relativeTime__default.default);
+var DateFormatType = "YYYY-MM-DD HH:mm:ss";
+var DateFormatType2 = "YYYY-MM-DD";
+var UNIT = "date";
+var getStartOfTimestamp = (date, unit = UNIT) => {
+  return dayjs__default.default(date).startOf(unit).valueOf();
+};
+var getEndOfTimestamp = (date, unit = UNIT) => {
+  return dayjs__default.default(date).endOf(unit).valueOf();
+};
+var formatDate = (date, fmt = DateFormatType) => {
+  if (date) {
+    return dayjs__default.default(date).format(fmt);
+  }
+  return "";
+};
+var getTimestamp = (date) => {
+  return dayjs__default.default(date).valueOf();
+};
+var isExpire = (date) => {
+  return dayjs__default.default(date).isBefore(getStartOfTimestamp());
+};
+var USER_KEY = "NS-USER";
+function setCurrentUser(userInfo) {
+  const cipherText = AES__default.default.encrypt(JSON.stringify(userInfo), "((#II))").toString();
+  sessionStorage.setItem(USER_KEY, cipherText);
+}
+function getCurrentUser() {
+  const userInfoJson = sessionStorage.getItem(USER_KEY);
+  if (userInfoJson) {
+    const bytes = AES__default.default.decrypt(userInfoJson, "((#II))");
+    const originalText = bytes.toString(encUtf8__default.default);
+    return JSON.parse(originalText);
+  }
+  return null;
+}
+function clearCurrentUser() {
+  sessionStorage.removeItem(USER_KEY);
+}
+var DEVICEID_KEY = "NS-DEVICE-ID";
+function getDeviceId() {
+  let deviceId = localStorage.getItem(DEVICEID_KEY);
+  if (deviceId) {
+    return deviceId;
+  }
+  deviceId = genNonDuplicateID();
+  localStorage.setItem(DEVICEID_KEY, deviceId);
+  return deviceId;
+}
+var OperatorToMethodName = {
+  "+": "plus",
+  "-": "minus",
+  "*": "times",
+  "/": "dividedBy"
+};
+var calculate = (operator, ...args) => {
+  if (args.length === 0) return "0";
+  const [arg, ...newArgs] = args;
+  return newArgs.reduce((acc, val) => acc[OperatorToMethodName[operator]](new Decimal__default.default(val)), new Decimal__default.default(arg)).toString();
+};
+var plus = (...args) => calculate("+", ...args);
+var minus = (...args) => calculate("-", ...args);
+var times = (...args) => calculate("*", ...args);
+var dividedBy = (...args) => calculate("/", ...args);
+var decimalPlaces = (arg1) => {
+  return new Decimal__default.default(arg1).decimalPlaces();
+};
+var precision = (arg1) => {
+  return new Decimal__default.default(arg1).precision(true);
+};
+var absVal = (arg1) => new Decimal__default.default(arg1).abs().toString();
+var compareNum = (arg1, arg2, type) => {
+  const x = new Decimal__default.default(arg1);
+  const y = new Decimal__default.default(arg2);
+  switch (type) {
+    case ">":
+      return x.greaterThan(y);
+    case ">=":
+      return x.greaterThanOrEqualTo(y);
+    case "<":
+      return x.lessThan(y);
+    case "<=":
+      return x.lessThanOrEqualTo(y);
+    case "==":
+      return x.equals(y);
+  }
+};
+var toFixed = (num, decimals = 2, fill = true) => {
+  const x = new Decimal__default.default(num);
+  if (fill) {
+    return x.toFixed(decimals, Decimal__default.default.ROUND_HALF_UP);
+  } else {
+    return x.toDecimalPlaces(decimals, Decimal__default.default.ROUND_HALF_UP).toString();
+  }
+};
+var isInteger = (num) => {
+  return new Decimal__default.default(num).isInteger();
+};
+var isNegative = (num) => {
+  return new Decimal__default.default(num).isNegative();
+};
+var cacheMessage = () => {
+  const contents = {};
+  return ({ title = "\u63D0\u793A", content, type = "warning", duration = 3, onClose, isCache = true, isOnly = false }) => {
+    if (!content) return;
+    const key = isOnly ? "cache-key" : content;
+    const onClose2 = () => {
+      delete contents[key];
+      onClose?.();
+    };
+    if (isCache && contents[key]) ; else {
+      if (isCache) {
+        contents[key] = getTimestamp();
+      }
+      if (duration) {
+        if (content.length > 30) {
+          antd.notification[type]({
+            message: title,
+            description: content,
+            placement: "top",
+            duration,
+            onClose: onClose2
+          });
+        } else {
+          lib.message[type]({
+            content,
+            duration,
+            onClose: onClose2
+          });
+        }
+      } else {
+        antd.Modal[type]({
+          title,
+          content,
+          okButtonProps: { style: { background: LgPrimaryColor, outline: "none" } },
+          afterClose: onClose2
+        });
+      }
+    }
+  };
+};
+var showMessage = cacheMessage();
+
+// src/utils/session.ts
+var TOKEN_KEY = "NS-TOKEN";
+function setToken(accessToken) {
+  localStorage.setItem(TOKEN_KEY, accessToken);
+}
+function getUrlToken() {
+  const searchParams = new URLSearchParams(location.search);
+  const token = searchParams.get(TOKEN_KEY);
+  return token || "";
+}
+function getToken() {
+  const token = getUrlToken();
+  if (!token) {
+    const token2 = localStorage.getItem(TOKEN_KEY);
+    return token2 || "";
+  } else {
+    setToken(token);
+    return token;
+  }
+}
+function clearToken() {
+  localStorage.removeItem(TOKEN_KEY);
+}
+var SIGNPATH = "SIGNPATH";
+function getSignPath() {
+  const path = localStorage.getItem(SIGNPATH);
+  return `${path || "/sign-in"}`;
+}
+
+// src/utils/request.ts
+var OK = 200;
+var OK2 = "S0000";
+var ERROR = 500;
+var MISSING_PARAMETER = 400;
+var UNAUTHORIZED = 401;
+var FORBIDDEN = 403;
+var NOT_FOUND = 404;
+var ILLEGAL_PARAMETER = 901;
+var PERMISSION_DENIED = 13001;
+var LoginPastCode = 11200;
+var FacePastCode = 11201;
+var formType = "form";
+var jsonType = "json";
+var parseOptions = (options) => {
+  const headers = {};
+  if (options?.reqType && options.reqType === formType) {
+    headers["Content-Type"] = "application/x-www-form-urlencoded";
+  }
+  return { headers, ...options };
+};
+var redirectUrl = () => {
+  emit("jumpLink", { url: `/uc${getSignPath()}` });
+};
+axios__default.default.interceptors.request.use(
+  function(config) {
+    config.headers[TOKEN_KEY] = getToken();
+    if (config.url && !config.url.startsWith("/api/")) {
+      config.baseURL = "/api";
+    }
+    config.timeout = config.timeout || 6e4;
+    return config;
+  },
+  function(error) {
+    return Promise.reject(error);
+  }
+);
+axios__default.default.interceptors.response.use(
+  function(response) {
+    if (response.data?.code !== OK && response.data?.code !== OK2) {
+      const isPermission = response.data?.code === PERMISSION_DENIED;
+      if (response.config?.showError !== false) {
+        showMessage({
+          title: isPermission ? "" : void 0,
+          content: response.data.message,
+          duration: isPermission ? 0 : 3
+        });
+      }
+      return Promise.reject(response.data);
+    }
+    return response;
+  },
+  function(err) {
+    const showError = err?.config?.showError !== false;
+    if (!err.response) {
+      if (showError) showMessage({ content: "\u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC", type: "error" });
+    } else {
+      switch (err.response?.status) {
+        case UNAUTHORIZED:
+          if (showError) showMessage({ content: err.response?.data.message, type: "error" });
+          redirectUrl();
+          break;
+        case FORBIDDEN:
+        case NOT_FOUND:
+        case ERROR:
+        case MISSING_PARAMETER:
+        case ILLEGAL_PARAMETER:
+          if (showError) showMessage({ content: err.response?.data.message, type: "error" });
+          break;
+        default:
+          if (showError) showMessage({ content: "\u8BF7\u6C42\u6570\u636E\u53D1\u751F\u9519\u8BEF\uFF01", type: "info" });
+      }
+    }
+    return Promise.reject(err);
+  }
+);
+var get = async (url, params, options) => {
+  const res = await axios__default.default({ method: "get", url, params, ...options });
+  return res.data;
+};
+var post = async (url, data, options) => {
+  const res = await axios__default.default({
+    method: "post",
+    url,
+    data,
+    ...parseOptions(options)
+  });
+  return res.data;
+};
+var put = async (url, data, options) => {
+  const res = await axios__default.default({ method: "put", url, data, ...parseOptions(options) });
+  return res.data;
+};
+var del = async (url, data, options) => {
+  const reqConfig = {
+    method: "delete",
+    url,
+    ...parseOptions(options)
+  };
+  const params = options?.reqType === formType ? { params: data } : { data };
+  const res = await axios__default.default({ ...reqConfig, ...params });
+  return res.data;
+};
+var request_default = {
+  get,
+  post,
+  put,
+  delete: del
+};
+
+// src/hooks/useWebSocket.ts
+var useWebSocket = ({
+  url,
+  onMessage,
+  onClose,
+  heartbeatInterval = 3e4,
+  heartbeatMessage = "ping",
+  clientHeartbeat = true,
+  reconnectInterval = 5e3,
+  // 默认重连间隔为 5 秒
+  maxReconnectAttempts,
+  // 不设置默认值为无限重连
+  isReconnect = true
+  // 默认开启重连机制
+}) => {
+  const socketRef = react.useRef(null);
+  const heartbeatIntervalRef = react.useRef(null);
+  const [socketReadyState, setSocketReadyState] = react.useState(null);
+  const reconnectIntervalRef = react.useRef(null);
+  const reconnectAttempts = react.useRef(0);
+  const documentHide = react.useRef(document.visibilityState === "hidden");
+  const isDestroy = react.useRef(false);
+  const onMessageEctype = react.useCallback(onMessage, [onMessage]);
+  const startHeartbeat = (currentSocket) => {
+    if (!clientHeartbeat) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      if (currentSocket.readyState === WebSocket.OPEN) {
+        currentSocket.send(heartbeatMessage);
+      }
+    }, heartbeatInterval);
+    heartbeatIntervalRef.current = intervalId;
+  };
+  const stopHeartbeat = () => {
+    if (heartbeatIntervalRef.current) {
+      clearInterval(heartbeatIntervalRef.current);
+    }
+  };
+  const stopReconnectTimer = () => {
+    if (reconnectIntervalRef.current) {
+      clearTimeout(reconnectIntervalRef.current);
+      reconnectIntervalRef.current = null;
+    }
+  };
+  const tryReconnect = () => {
+    if (isDestroy.current) return;
+    if (isReconnect && !documentHide.current) {
+      if ((!isNumber(maxReconnectAttempts) || reconnectAttempts.current < maxReconnectAttempts) && isNullOrUnDef(reconnectIntervalRef.current)) {
+        reconnectIntervalRef.current = setTimeout(() => {
+          console.log(`\u5C1D\u8BD5\u7B2C ${reconnectAttempts.current + 1} \u6B21\u91CD\u8FDE...`, url);
+          reconnectAttempts.current = reconnectAttempts.current + 1;
+          createAndListenWebSocket();
+          stopReconnectTimer();
+        }, reconnectInterval);
+      } else {
+        if (isNumber(maxReconnectAttempts)) {
+          console.log("\u8FBE\u5230\u6700\u5927\u91CD\u8FDE\u5C1D\u8BD5\u6B21\u6570\uFF0C\u505C\u6B62\u91CD\u8FDE");
+        }
+      }
+    }
+  };
+  const handleOpen = (newSocket) => {
+    console.log("WebSocket \u8FDE\u63A5\u5DF2\u6253\u5F00");
+    setSocketReadyState(newSocket.readyState);
+    startHeartbeat(newSocket);
+    reconnectAttempts.current = 0;
+  };
+  const handleMessage = (event) => {
+    if (isString(event.data)) {
+      try {
+        const parsedData = JSON.parse(event.data);
+        onMessageEctype?.(parsedData);
+        stopHeartbeat();
+        startHeartbeat(socketRef.current);
+      } catch (error) {
+        console.error("\u89E3\u6790\u6D88\u606F\u6570\u636E\u65F6\u51FA\u9519:", error);
+      }
+    }
+  };
+  const handleClose = (event) => {
+    console.log("WebSocket \u8FDE\u63A5\u5DF2\u5173\u95ED", event.code, event.reason);
+    setSocketReadyState(event.code);
+    stopHeartbeat();
+    onClose?.();
+    tryReconnect();
+  };
+  const handleError = (error) => {
+    console.error("WebSocket \u53D1\u751F\u9519\u8BEF:", error);
+    setSocketReadyState(null);
+    stopHeartbeat();
+    tryReconnect();
+  };
+  const createAndListenWebSocket = () => {
+    const newSocket = new WebSocket(url);
+    socketRef.current = newSocket;
+    setSocketReadyState(newSocket.readyState);
+    newSocket.onopen = () => handleOpen(newSocket);
+    newSocket.onmessage = handleMessage;
+    newSocket.onclose = handleClose;
+    newSocket.onerror = handleError;
+  };
+  const handleVisibilityChange = () => {
+    documentHide.current = document.visibilityState === "hidden";
+    if (socketRef.current?.readyState !== WebSocket.OPEN) {
+      tryReconnect();
+    }
+  };
+  react.useEffect(() => {
+    isDestroy.current = false;
+    createAndListenWebSocket();
+    window.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      window.removeEventListener("visibilitychange", handleVisibilityChange);
+      isDestroy.current = true;
+      if (socketRef.current) {
+        socketRef.current.close();
+        return;
+      }
+      stopHeartbeat();
+      stopReconnectTimer();
+    };
+  }, [url]);
+  const sendMessage = (message2) => {
+    if (socketRef.current?.readyState === WebSocket.OPEN) {
+      socketRef.current.send(message2);
+      stopHeartbeat();
+      startHeartbeat(socketRef.current);
+    }
+  };
+  return {
+    sendMessage,
+    socketReadyState
+  };
+};
+var useWebSocket_default = useWebSocket;
+var ProtectedView = ({
+  passwordStatus,
+  verifyPassword,
+  onVerifyPasswordEnd
+}) => {
+  const [form] = antd.Form.useForm();
+  const onSubmit = () => {
+    form.validateFields().then((values) => {
+      if (values) {
+        verifyPassword(values.password);
+        onVerifyPasswordEnd(values.password);
+      }
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Flex, { justify: "center", align: "center", className: "height-full", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: 300 }, children: [
+    passwordStatus === core.PasswordStatus.WrongPassword && /* @__PURE__ */ jsxRuntime.jsx(antd.Alert, { message: "\u5BC6\u7801\u65E0\u6548\u3002\u8BF7\u518D\u8BD5\u4E00\u6B21\uFF01", type: "error" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(antd.Form, { form, size: "large", className: "m-t-24", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(antd.Form.Item, { name: "password", rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u5BC6\u7801" }], children: /* @__PURE__ */ jsxRuntime.jsx(antd.Input.Password, { autoComplete: "new-password", placeholder: "\u8BF7\u8F93\u5165\u5BC6\u7801" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(antd.Flex, { justify: "center", children: /* @__PURE__ */ jsxRuntime.jsx(antd.Button, { type: "primary", onClick: onSubmit, children: "\u63D0 \u4EA4" }) })
+    ] })
+  ] }) });
+};
+var PdfPreview_default = ({ password, fileUrl, pageNo = 1, scale = 1, isHasThumbnails = true, onSetPassword, onSetPageNo }) => {
+  const embedRef = react.useRef(null);
+  const [sizes, setSizes] = react.useState([0]);
+  const [, setDocLoaded, getDocLoaded] = useRefState(false);
+  const [currentPage, setCurrentPage, getCurrentPage] = useRefState(void 0);
+  const [temporaryPassword, setTemporaryPassword] = react.useState("");
+  const jumpToPageNo = react.useRef();
+  const onVerifyPasswordEnd = (password2) => {
+    setTemporaryPassword(password2);
+  };
+  const pageNavigationPluginInstance = pageNavigation.pageNavigationPlugin({ enableShortcuts: true });
+  const thumbnailPluginInstance = thumbnail.thumbnailPlugin({
+    thumbnailWidth: sizes[0] - 70
+    // 不会自适应
+  });
+  const zoomPluginInstance = zoom.zoomPlugin();
+  const { Thumbnails } = thumbnailPluginInstance;
+  const { ZoomIn, ZoomOut } = zoomPluginInstance;
+  const Toolbar = () => /* @__PURE__ */ jsxRuntime.jsxs(antd.Flex, { gap: 6, align: "center", className: styles_module_default.pdfToolbar, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ZoomIn, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(ZoomOut, {})
+  ] });
+  const onJumpToPage = (pageNo2) => {
+    if (getDocLoaded()) {
+      if (pageNo2 && pageNo2 - 1 !== getCurrentPage()) {
+        jumpToPageNo.current = pageNo2 - 1;
+        pageNavigationPluginInstance.jumpToPage(jumpToPageNo.current);
+      }
+    }
+  };
+  const handleDocumentLoad = () => {
+    setSizes([400]);
+    setDocLoaded(true);
+    onJumpToPage(pageNo);
+    if (temporaryPassword) {
+      onSetPassword?.(temporaryPassword);
+      setTemporaryPassword("");
+    }
+  };
+  react.useEffect(() => {
+    setCurrentPage(void 0);
+    setDocLoaded(false);
+    setSizes([0]);
+  }, [fileUrl]);
+  react.useEffect(() => {
+    setTimeout(() => {
+      onJumpToPage(pageNo);
+    }, 0);
+  }, [pageNo]);
+  const renderError = (error) => {
+    let message2 = "";
+    switch (error.name) {
+      case "InvalidPDFException":
+        message2 = "\u6587\u4EF6\u65E0\u6548\u6216\u5DF2\u635F\u574F";
+        break;
+      case "MissingPDFException":
+        message2 = "\u6587\u4EF6\u4E0D\u5B58\u5728";
+        break;
+      case "UnexpectedResponseException":
+        message2 = "\u610F\u5916\u7684\u670D\u52A1\u5668\u54CD\u5E94";
+        break;
+      // case 'CMapReaderFactory not initialized':
+      //   message = '字体映射文件加载失败，请刷新页面重试'
+      //   break
+      default:
+        message2 = "\u65E0\u6CD5\u52A0\u8F7D\u6587\u6863";
+        break;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(antd.Flex, { className: "height-full", justify: "center", align: "center", children: /* @__PURE__ */ jsxRuntime.jsx(antd.Alert, { message: message2, type: "error", showIcon: true }) });
+  };
+  const onPageChange = (e) => {
+    let newCurrentPage = e.currentPage;
+    if (isNumber(jumpToPageNo.current)) {
+      newCurrentPage = jumpToPageNo.current;
+      setTimeout(() => {
+        jumpToPageNo.current = void 0;
+      }, 1e3);
+    }
+    setCurrentPage(newCurrentPage);
+  };
+  react.useEffect(() => {
+    if (!(embedRef.current && isNumber(currentPage))) return;
+    setTimeout(() => {
+      const pages = embedRef.current?.querySelectorAll(".rpv-core__viewer .rpv-core__page-layer");
+      pages?.forEach((page) => {
+        if (Number(page.getAttribute("data-virtual-index")) === currentPage) {
+          page.classList.add("current-page-highlight");
+        } else {
+          page.classList.remove("current-page-highlight");
+        }
+      });
+    }, 500);
+    onSetPageNo?.(currentPage + 1);
+  }, [currentPage]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: embedRef, className: styles_module_default.nsPreviewPdf, children: /* @__PURE__ */ jsxRuntime.jsx(core.Worker, { workerUrl: `/uc/pdf/pdf.worker.min.js`, children: /* @__PURE__ */ jsxRuntime.jsxs(antd.Splitter, { onResize: setSizes, children: [
+    isHasThumbnails && /* @__PURE__ */ jsxRuntime.jsx(antd.Splitter.Panel, { resizable: false, size: sizes[0], min: 250, max: 500, collapsible: true, children: /* @__PURE__ */ jsxRuntime.jsx(Thumbnails, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(antd.Splitter.Panel, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "height-full", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        core.Viewer,
+        {
+          localization: zh_CN__default.default,
+          withCredentials: true,
+          onDocumentAskPassword: (e) => {
+            setTemporaryPassword("");
+            e.verifyPassword(password || "");
+          },
+          transformGetDocumentParams: (options) => {
+            return Object.assign({}, options, {
+              // disableRange: false,
+              disableStream: true,
+              // 建议传入是否加密字段来控制
+              httpHeaders: { "Cache-Control": "no-cache" },
+              // 启用 CMap 支持，解决中文字体显示问题
+              // cMapUrl: 指定 CMap 文件的 URL，用于处理非拉丁字符（如中文）
+              // cMapPacked: 使用压缩的 CMap 文件以提高性能
+              cMapUrl: "/uc/pdf/pdfjs-dist@3.2.146/cmaps/",
+              // 使用可用的源
+              cMapPacked: true,
+              // 禁用字体子集化，确保完整字体加载
+              disableFontFace: false,
+              // 启用标准字体支持
+              standardFontDataUrl: "/uc/pdf/pdfjs-dist@3.2.146/standard_fonts/",
+              // 设置字体回退策略
+              fallbackFontName: "Helvetica"
+            });
+          },
+          fileUrl,
+          defaultScale: scale,
+          plugins: [
+            pageNavigationPluginInstance,
+            thumbnailPluginInstance,
+            zoomPluginInstance
+            // printPluginInstance,
+            // rotatePluginInstance,
+            // searchPluginInstance,
+          ],
+          onPageChange,
+          renderError,
+          onDocumentLoad: handleDocumentLoad,
+          renderProtectedView: (renderProps) => /* @__PURE__ */ jsxRuntime.jsx(ProtectedView, { onVerifyPasswordEnd, ...renderProps })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(Toolbar, {})
+    ] }) })
+  ] }) }) });
+};
+var FilePreview_default = ({ suffix, fileUrl, pdfParams, password, searchValue }) => {
+  const Preview = react.useMemo(() => {
+    if (!fileUrl) {
+      return /* @__PURE__ */ jsxRuntime.jsx(antd.Empty, {});
+    }
+    switch (suffix?.toUpperCase()) {
+      case "PNG":
+      case "JPG":
+      case "JPEG":
+      case "GIF":
+        return /* @__PURE__ */ jsxRuntime.jsx(antd.Image, { rootClassName: styles_module_default.nsPreviewImage, src: fileUrl, alt: "\u9884\u89C8\u56FE\u7247" });
+      case "PDF":
+        return /* @__PURE__ */ jsxRuntime.jsx(PdfPreview_default, { fileUrl, ...pdfParams, password });
+      // onSetPassword={onSetPassword}
+      case "MP4":
+        return /* @__PURE__ */ jsxRuntime.jsx(VideoPlayer_default, { fileUrl });
+      case "MP3":
+        return /* @__PURE__ */ jsxRuntime.jsx(AudioPlayer_default, { fileUrl });
+      case "MD":
+      case "MARKDOWN":
+        return /* @__PURE__ */ jsxRuntime.jsx(MarkdownPreview_default, { fileUrl, searchValue });
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(antd.Result, { subTitle: `\u6682\u4E0D\u652F\u6301 ${suffix || ""} \u6587\u4EF6\u7684\u9884\u89C8` });
+    }
+  }, [suffix, fileUrl, pdfParams]);
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Flex, { justify: "center", align: "center", className: "height-full", children: Preview });
+};
+var FilePreviewDrawer_default = ({ open, fileUrl, suffix, title = "\u6587\u4EF6\u9884\u89C8", onClose, password, fileParams, pdfParams, onSetPassSuccess }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Drawer, { title, push: false, width: "100%", open, onClose, children: /* @__PURE__ */ jsxRuntime.jsx(
+    FilePreview_default,
+    {
+      fileUrl,
+      suffix,
+      password,
+      fileParams,
+      pdfParams,
+      onSetPassSuccess
+    }
+  ) });
+};
+
+// src/components/Iframe/styles.module.less
+var styles_module_default2 = {
+  iframe: "styles_module_iframe"
+};
+var Iframe_default = react.forwardRef(({ id, src, className, onLoad }, ref) => {
+  const [loading, setLoading] = react.useState(false);
+  const finalSrc = react.useMemo(() => {
+    return buildUrlParams({ v: Date.now() }, addUrlLastSlash(getUrlMainSource(src, location.href)));
+  }, [src]);
+  const onHandleLoad = () => {
+    setLoading(false);
+    onLoad?.();
+  };
+  react.useEffect(() => {
+    setLoading(true);
+  }, [src]);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(antd.Spin, { spinning: loading, wrapperClassName: "full-spin", tip: "\u52A0\u8F7D\u4E2D...", children: /* @__PURE__ */ jsxRuntime.jsx("iframe", { id, ref, src: finalSrc, className: classNames__default.default(styles_module_default2.iframe, className), onLoad: onHandleLoad }) }) });
+});
+function isRenderFn(node) {
+  return isFunction(node) || isObject(node) && !isNull(node) && "$$typeof" in node && node.$$typeof === Symbol.for("react.forward_ref");
+}
+function renderDefault(DefaultComponent, props) {
+  if (!DefaultComponent) return null;
+  return isRenderFn(DefaultComponent) ? /* @__PURE__ */ jsxRuntime.jsx(DefaultComponent, { ...props }) : DefaultComponent;
+}
+function RenderWrapper({ control = true, ctx, DefaultComponent }) {
+  if (control === false || isNull(control)) return null;
+  if (control === true || control === void 0) {
+    return renderDefault(DefaultComponent);
+  }
+  const { visible = true, render, props } = control;
+  if (!visible) return null;
+  if (render) {
+    return typeof render === "function" ? render(ctx) : render;
+  }
+  return renderDefault(DefaultComponent, props);
+}
+var shouldRender = (control) => control != null && (isBoolean(control) ? control : control?.visible !== false);
+function propsMerge(control, props) {
+  if (control === true || control === void 0) {
+    return {
+      props
+    };
+  }
+  if (isObject(control) && (control?.visible === true || control?.visible === void 0)) {
+    return {
+      props: {
+        ...props,
+        ...control?.props
+      }
+    };
+  }
+  return null;
+}
+var UserAvatar_default = ({ size, avatarSrc, userName }) => {
+  return avatarSrc ? /* @__PURE__ */ jsxRuntime.jsx(antd.Avatar, { size, src: avatarSrc }) : /* @__PURE__ */ jsxRuntime.jsx(antd.Avatar, { size, className: "cursor-pointer", style: { backgroundColor: LgPrimaryColor }, children: userName?.slice(0, 1)?.toLocaleUpperCase() });
+};
+
+exports.AudioPlayer = AudioPlayer_default;
+exports.DateFormatType = DateFormatType;
+exports.DateFormatType2 = DateFormatType2;
+exports.ERROR = ERROR;
+exports.FORBIDDEN = FORBIDDEN;
+exports.FacePastCode = FacePastCode;
+exports.FileIcon = FileIcon_default;
+exports.FilePreview = FilePreview_default;
+exports.FilePreviewDrawer = FilePreviewDrawer_default;
+exports.ILLEGAL_PARAMETER = ILLEGAL_PARAMETER;
+exports.Iframe = Iframe_default;
+exports.LazyComponent = LazyComponent_default;
+exports.LgPrimaryColor = LgPrimaryColor;
+exports.LoginPastCode = LoginPastCode;
+exports.MISSING_PARAMETER = MISSING_PARAMETER;
+exports.MarkdownPreview = MarkdownPreview_default;
+exports.NOT_FOUND = NOT_FOUND;
+exports.OK = OK;
+exports.OK2 = OK2;
+exports.PERMISSION_DENIED = PERMISSION_DENIED;
+exports.PdfPreview = PdfPreview_default;
+exports.RenderMarkdown = RenderMarkdown_default;
+exports.RenderWrapper = RenderWrapper;
+exports.TOKEN_KEY = TOKEN_KEY;
+exports.UNAUTHORIZED = UNAUTHORIZED;
+exports.UserAvatar = UserAvatar_default;
+exports.VideoPlayer = VideoPlayer_default;
+exports.absVal = absVal;
+exports.addUrlLastSlash = addUrlLastSlash;
+exports.arrToObj = arrToObj;
+exports.buildUrlParams = buildUrlParams;
+exports.calculate = calculate;
+exports.clearCurrentUser = clearCurrentUser;
+exports.clearToken = clearToken;
+exports.compareNum = compareNum;
+exports.copyText = copyText;
+exports.createValtioContext = createValtioContext;
+exports.decimalPlaces = decimalPlaces;
+exports.deepCopy = deepCopy;
+exports.deepEqual = deepEqual;
+exports.deepMerge = deepMerge;
+exports.dividedBy = dividedBy;
+exports.downloadFile = downloadFile;
+exports.emit = emit;
+exports.emitToChild = emitToChild;
+exports.formType = formType;
+exports.formatDate = formatDate;
+exports.formatNumberWithCommas = formatNumberWithCommas;
+exports.genNonDuplicateID = genNonDuplicateID;
+exports.generateRandomNumbers = generateRandomNumbers;
+exports.getCurrentUser = getCurrentUser;
+exports.getDeviceId = getDeviceId;
+exports.getEndOfTimestamp = getEndOfTimestamp;
+exports.getFileName = getFileName;
+exports.getSignPath = getSignPath;
+exports.getStartOfTimestamp = getStartOfTimestamp;
+exports.getTimestamp = getTimestamp;
+exports.getToken = getToken;
+exports.getUrlMainSource = getUrlMainSource;
+exports.getUrlToken = getUrlToken;
+exports.getWebSocketUrl = getWebSocketUrl;
+exports.is = is;
+exports.isArray = isArray;
+exports.isBlob = isBlob;
+exports.isBoolean = isBoolean;
+exports.isClient = isClient;
+exports.isDate = isDate;
+exports.isDef = isDef;
+exports.isElement = isElement;
+exports.isEmpty = isEmpty;
+exports.isEmptyObj = isEmptyObj;
+exports.isExpire = isExpire;
+exports.isExternal = isExternal;
+exports.isFunction = isFunction;
+exports.isInteger = isInteger;
+exports.isMap = isMap;
+exports.isNegative = isNegative;
+exports.isNull = isNull;
+exports.isNullOrUnDef = isNullOrUnDef;
+exports.isNumber = isNumber;
+exports.isNumberNoNaN = isNumberNoNaN;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isServer = isServer;
+exports.isString = isString;
+exports.isUnDef = isUnDef;
+exports.isWindow = isWindow;
+exports.jsonType = jsonType;
+exports.minus = minus;
+exports.nsSetInterval = nsSetInterval;
+exports.objToOptions = objToOptions;
+exports.plus = plus;
+exports.precision = precision;
+exports.propsMerge = propsMerge;
+exports.request = request_default;
+exports.setCurrentUser = setCurrentUser;
+exports.setToken = setToken;
+exports.shouldRender = shouldRender;
+exports.textAreaView = textAreaView;
+exports.themeConfig = themeConfig;
+exports.times = times;
+exports.toFixed = toFixed;
+exports.useDebounce = useDebounce;
+exports.useDeepEffect = useDeepEffect;
+exports.useIframeRelayBridge = useIframeRelayBridge;
+exports.useRefState = useRefState;
+exports.useSyncInput = useSyncInput;
+exports.useThrottle = useThrottle;
+exports.useWebSocket = useWebSocket_default;
+//# sourceMappingURL=index.cjs.js.map
+//# sourceMappingURL=index.cjs.js.map