@zlooks.cn/password-auth-server 1.0.1 → 1.0.3

package/.hile-rsc/build-mtsn68qv-a841a566/client-browser/src-plugin-page-frame-07c4de56a6-C2WHPDGD.js

@@ -0,0 +1,2312 @@
+"use client";
+import {
+  AntdIconLight_default,
+  App_default,
+  Button_default,
+  Fragment,
+  KeyCode_default,
+  LoadingOutlined_default,
+  Modal_default,
+  RscLink,
+  TextArea_default,
+  __commonJS,
+  __toESM,
+  _toConsumableArray,
+  cloneElement,
+  clsx,
+  composeRef,
+  config_provider_default,
+  createContext,
+  createElement,
+  deepFreeze,
+  devUseWarning,
+  divider_default,
+  empty_default,
+  es_default2 as es_default,
+  flex_default,
+  forwardRef,
+  genStyleHooks,
+  gold,
+  isFunction,
+  isNonNullable,
+  isNumber,
+  isPlainObject,
+  isReactRenderable,
+  isRequestError,
+  isStyleSupport,
+  isValidElement,
+  jsx,
+  jsxs,
+  merge,
+  omit,
+  operationUnit,
+  popover_default,
+  resetComponent,
+  responsiveArray,
+  space_default,
+  textEllipsis,
+  theme_default,
+  toArray,
+  tooltip_default,
+  unit,
+  useBreakpoint_default,
+  useCSSVarCls_default,
+  useCallback,
+  useComponentConfig,
+  useContext,
+  useControlledState,
+  useDelayState,
+  useEffect,
+  useEvent_default,
+  useImperativeHandle,
+  useLayoutEffect_default,
+  useLocale_default,
+  useMemo,
+  useMergeSemantic,
+  useRef,
+  useRequest,
+  useRscNavigation,
+  useSemanticRootStyle,
+  useSize_default,
+  useState,
+  useSyncExternalStore,
+  useZlooksApp,
+  warning_default
+} from "./chunks/chunk-CZF5VGOJ.js";
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EditOutlined.js
+var require_EditOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EditOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EditOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M257.7 752c2 0 4-.2 6-.5L431.9 722c2-.4 3.9-1.3 5.3-2.8l423.9-423.9a9.96 9.96 0 000-14.1L694.9 114.9c-1.9-1.9-4.4-2.9-7.1-2.9s-5.2 1-7.1 2.9L256.8 538.8c-1.5 1.5-2.4 3.3-2.8 5.3l-29.5 168.2a33.5 33.5 0 009.4 29.8c6.6 6.4 14.9 9.9 23.8 9.9zm67.4-174.4L687.8 215l73.3 73.3-362.7 362.6-88.9 15.7 15.6-89zM880 836H144c-17.7 0-32 14.3-32 32v36c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-36c0-17.7-14.3-32-32-32z" } }] }, "name": "edit", "theme": "outlined" };
+    exports.default = EditOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EnterOutlined.js
+var require_EnterOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EnterOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EnterOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M864 170h-60c-4.4 0-8 3.6-8 8v518H310v-73c0-6.7-7.8-10.5-13-6.3l-141.9 112a8 8 0 000 12.6l141.9 112c5.3 4.2 13 .4 13-6.3v-75h498c35.3 0 64-28.7 64-64V178c0-4.4-3.6-8-8-8z" } }] }, "name": "enter", "theme": "outlined" };
+    exports.default = EnterOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/CheckOutlined.js
+var require_CheckOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/CheckOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var CheckOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 00-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z" } }] }, "name": "check", "theme": "outlined" };
+    exports.default = CheckOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/CopyOutlined.js
+var require_CopyOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/CopyOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var CopyOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M832 64H296c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h496v688c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8V96c0-17.7-14.3-32-32-32zM704 192H192c-17.7 0-32 14.3-32 32v530.7c0 8.5 3.4 16.6 9.4 22.6l173.3 173.3c2.2 2.2 4.7 4 7.4 5.5v1.9h4.2c3.5 1.3 7.2 2 11 2H704c17.7 0 32-14.3 32-32V224c0-17.7-14.3-32-32-32zM350 856.2L263.9 770H350v86.2zM664 888H414V746c0-22.1-17.9-40-40-40H232V264h432v624z" } }] }, "name": "copy", "theme": "outlined" };
+    exports.default = CopyOutlined2;
+  }
+});
+
+// ../ui/dist/theme.js
+var theme = {
+  token: {
+    colorPrimary: "#1677ff",
+    borderRadius: 10,
+    motion: true,
+    fontFamily: [
+      "-apple-system",
+      "BlinkMacSystemFont",
+      "'Segoe UI'",
+      "Roboto",
+      "'Helvetica Neue'",
+      "Arial",
+      "'Noto Sans'",
+      "sans-serif"
+    ].join(", ")
+  }
+};
+var zlooksTheme = deepFreeze(theme);
+
+// ../ui/dist/theme-preference.js
+var THEME_STORAGE_KEY = "zlooks.theme";
+var THEME_CHANGE_EVENT = "zlooks:theme-change";
+var memoryMode = "default";
+function useZlooksTheme() {
+  const mode = useSyncExternalStore(subscribeThemePreference, readClientThemeMode, readServerThemeMode);
+  return { mode, setMode: setThemeMode };
+}
+function parseStoredZlooksThemeMode(value) {
+  return value === "dark" || value === "light" || value === "default" ? value : "default";
+}
+function readClientThemeMode() {
+  if (typeof window === "undefined")
+    return memoryMode;
+  try {
+    const stored = window.localStorage.getItem(THEME_STORAGE_KEY);
+    if (stored !== null)
+      memoryMode = parseStoredZlooksThemeMode(stored);
+  } catch {
+  }
+  return memoryMode;
+}
+function readServerThemeMode() {
+  return "default";
+}
+function setThemeMode(mode) {
+  if (parseStoredZlooksThemeMode(mode) !== mode) {
+    throw new TypeError(`Unsupported Zlooks theme mode: ${String(mode)}`);
+  }
+  memoryMode = mode;
+  if (typeof window === "undefined")
+    return;
+  try {
+    window.localStorage.setItem(THEME_STORAGE_KEY, mode);
+  } catch {
+  }
+  window.dispatchEvent(new CustomEvent(THEME_CHANGE_EVENT, { detail: mode }));
+}
+function subscribeThemePreference(notify) {
+  if (typeof window === "undefined")
+    return () => void 0;
+  const handleThemeChange = (event) => {
+    memoryMode = parseStoredZlooksThemeMode(event.detail);
+    notify();
+  };
+  const handleStorage = (event) => {
+    if (event.key !== THEME_STORAGE_KEY)
+      return;
+    memoryMode = parseStoredZlooksThemeMode(event.newValue);
+    notify();
+  };
+  window.addEventListener(THEME_CHANGE_EVENT, handleThemeChange);
+  window.addEventListener("storage", handleStorage);
+  return () => {
+    window.removeEventListener(THEME_CHANGE_EVENT, handleThemeChange);
+    window.removeEventListener("storage", handleStorage);
+  };
+}
+
+// ../ui/dist/provider.js
+var App = moduleDefault(App_default);
+var ConfigProvider = moduleDefault(config_provider_default);
+var antdTheme = moduleDefault(theme_default);
+function ZlooksUiProvider({ children, theme: theme2 }) {
+  const preference = useZlooksTheme();
+  const { resolvedMode, resolvedTheme } = useZlooksThemeRuntime(theme2 ?? preference.mode);
+  return jsx(ConfigProvider, { button: { autoInsertSpace: false }, theme: resolvedTheme, children: jsx(App, { children: jsx("div", { className: "zlooks-ui-theme", "data-zlooks-theme": resolvedMode, children }) }) });
+}
+function useZlooksThemeRuntime(theme2) {
+  const systemDark = useSystemDarkTheme(theme2 === "default");
+  const resolvedMode = theme2 === "default" ? systemDark ? "dark" : "light" : theme2;
+  const resolvedTheme = useMemo(() => ({
+    ...zlooksTheme,
+    algorithm: resolvedMode === "dark" ? antdTheme.darkAlgorithm : antdTheme.defaultAlgorithm,
+    cssVar: { key: `zlooks-${resolvedMode}` },
+    hashed: false,
+    zeroRuntime: true
+  }), [resolvedMode]);
+  return { resolvedMode, resolvedTheme };
+}
+function useSystemDarkTheme(enabled) {
+  const [dark, setDark] = useState(false);
+  useEffect(() => {
+    if (!enabled)
+      return;
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const update = () => setDark(media.matches);
+    update();
+    media.addEventListener("change", update);
+    return () => media.removeEventListener("change", update);
+  }, [enabled]);
+  return dark;
+}
+function moduleDefault(value) {
+  return value && typeof value === "object" && "default" in value ? value.default : value;
+}
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/avatar/AvatarContext.js
+var AvatarContext = /* @__PURE__ */ createContext({});
+var AvatarContext_default = AvatarContext;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/avatar/style/index.js
+var genBaseStyle = (token) => {
+  const {
+    antCls,
+    componentCls,
+    iconCls,
+    avatarBg,
+    avatarColor,
+    containerSize,
+    containerSizeLG,
+    containerSizeSM,
+    textFontSize,
+    textFontSizeLG,
+    textFontSizeSM,
+    iconFontSize,
+    iconFontSizeLG,
+    iconFontSizeSM,
+    borderRadius,
+    borderRadiusLG,
+    borderRadiusSM,
+    lineWidth,
+    lineType
+  } = token;
+  const avatarSizeStyle = (size, fontSize, iconFontSize2, radius) => ({
+    width: size,
+    height: size,
+    borderRadius: "50%",
+    fontSize,
+    [`&${componentCls}-square`]: {
+      borderRadius: radius
+    },
+    [`&${componentCls}-icon`]: {
+      fontSize: iconFontSize2,
+      [`> ${iconCls}`]: {
+        margin: 0
+      }
+    }
+  });
+  return {
+    [componentCls]: {
+      ...resetComponent(token),
+      position: "relative",
+      display: "inline-flex",
+      justifyContent: "center",
+      alignItems: "center",
+      overflow: "hidden",
+      color: avatarColor,
+      whiteSpace: "nowrap",
+      textAlign: "center",
+      verticalAlign: "middle",
+      background: avatarBg,
+      border: `${unit(lineWidth)} ${lineType} transparent`,
+      "&-image": {
+        background: "transparent"
+      },
+      [`${antCls}-image-img`]: {
+        display: "block"
+      },
+      ...avatarSizeStyle(containerSize, textFontSize, iconFontSize, borderRadius),
+      "&-lg": {
+        ...avatarSizeStyle(containerSizeLG, textFontSizeLG, iconFontSizeLG, borderRadiusLG)
+      },
+      "&-sm": {
+        ...avatarSizeStyle(containerSizeSM, textFontSizeSM, iconFontSizeSM, borderRadiusSM)
+      },
+      "> img": {
+        display: "block",
+        width: "100%",
+        height: "100%",
+        objectFit: "cover"
+      }
+    }
+  };
+};
+var genGroupStyle = (token) => {
+  const {
+    componentCls,
+    groupBorderColor,
+    groupOverlapping,
+    groupSpace
+  } = token;
+  return {
+    [`${componentCls}-group`]: {
+      display: "inline-flex",
+      [componentCls]: {
+        borderColor: groupBorderColor
+      },
+      "> *:not(:first-child)": {
+        marginInlineStart: groupOverlapping
+      }
+    },
+    [`${componentCls}-group-popover`]: {
+      [`${componentCls} + ${componentCls}`]: {
+        marginInlineStart: groupSpace
+      }
+    }
+  };
+};
+var prepareComponentToken = (token) => {
+  const {
+    controlHeight,
+    controlHeightLG,
+    controlHeightSM,
+    fontSize,
+    fontSizeLG,
+    fontSizeXL,
+    fontSizeHeading3,
+    marginXS,
+    marginXXS,
+    colorBorderBg
+  } = token;
+  return {
+    containerSize: controlHeight,
+    containerSizeLG: controlHeightLG,
+    containerSizeSM: controlHeightSM,
+    textFontSize: fontSize,
+    textFontSizeLG: fontSize,
+    textFontSizeSM: fontSize,
+    iconFontSize: Math.round((fontSizeLG + fontSizeXL) / 2),
+    iconFontSizeLG: fontSizeHeading3,
+    iconFontSizeSM: fontSize,
+    groupSpace: marginXXS,
+    groupOverlapping: -marginXS,
+    groupBorderColor: colorBorderBg
+  };
+};
+var style_default = genStyleHooks("Avatar", (token) => {
+  const {
+    colorTextLightSolid,
+    colorTextPlaceholder
+  } = token;
+  const avatarToken = merge(token, {
+    avatarBg: colorTextPlaceholder,
+    avatarColor: colorTextLightSolid
+  });
+  return [genBaseStyle(avatarToken), genGroupStyle(avatarToken)];
+}, prepareComponentToken);
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/avatar/Avatar.js
+var Avatar = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    shape,
+    size: customSize,
+    src,
+    srcSet,
+    icon,
+    className,
+    rootClassName,
+    style,
+    alt,
+    draggable,
+    children,
+    crossOrigin,
+    gap = 4,
+    onError,
+    ...others
+  } = props;
+  const [scale, setScale] = useState(1);
+  const [mounted, setMounted] = useState(false);
+  const [isImgExist, setIsImgExist] = useState(true);
+  const avatarNodeRef = useRef(null);
+  const avatarChildrenRef = useRef(null);
+  const avatarNodeMergedRef = composeRef(ref, avatarNodeRef);
+  const {
+    getPrefixCls,
+    className: contextClassName,
+    style: contextStyle
+  } = useComponentConfig("avatar");
+  const avatarCtx = useContext(AvatarContext_default);
+  const setScaleParam = () => {
+    if (!avatarChildrenRef.current || !avatarNodeRef.current) {
+      return;
+    }
+    const childrenWidth = avatarChildrenRef.current.offsetWidth;
+    const nodeWidth = avatarNodeRef.current.offsetWidth;
+    if (childrenWidth !== 0 && nodeWidth !== 0) {
+      if (gap * 2 < nodeWidth) {
+        setScale(nodeWidth - gap * 2 < childrenWidth ? (nodeWidth - gap * 2) / childrenWidth : 1);
+      }
+    }
+  };
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+  useEffect(() => {
+    setIsImgExist(true);
+    setScale(1);
+  }, [src]);
+  useEffect(setScaleParam, [gap]);
+  const handleImgLoadError = () => {
+    const errorFlag = onError?.();
+    if (errorFlag !== false) {
+      setIsImgExist(false);
+    }
+  };
+  const size = useSize_default((ctxSize) => customSize ?? avatarCtx?.size ?? ctxSize ?? "medium");
+  const needResponsive = Object.keys(isPlainObject(size) ? size || {} : {}).some((key) => responsiveArray.includes(key));
+  const screens = useBreakpoint_default(needResponsive);
+  const responsiveSizeStyle = useMemo(() => {
+    if (!isPlainObject(size)) {
+      return {};
+    }
+    const currentBreakpoint = responsiveArray.find((screen) => screens[screen]);
+    const currentSize = size[currentBreakpoint];
+    return currentSize ? {
+      width: currentSize,
+      height: currentSize,
+      fontSize: currentSize && (icon || children) ? currentSize / 2 : 18
+    } : {};
+  }, [screens, size, icon, children]);
+  if (true) {
+    const warning = devUseWarning("Avatar");
+    true ? warning(!(typeof icon === "string" && icon.length > 2), "breaking", `\`icon\` is using ReactNode instead of string naming in v4. Please check \`${icon}\` at https://ant.design/components/icon`) : void 0;
+  }
+  const prefixCls = getPrefixCls("avatar", customizePrefixCls);
+  const rootCls = useCSSVarCls_default(prefixCls);
+  const [hashId, cssVarCls] = style_default(prefixCls, rootCls);
+  const sizeCls = clsx({
+    [`${prefixCls}-lg`]: size === "large",
+    [`${prefixCls}-sm`]: size === "small"
+  });
+  const hasImageElement = /* @__PURE__ */ isValidElement(src);
+  const mergedShape = shape || avatarCtx?.shape || "circle";
+  const classString = clsx(prefixCls, sizeCls, contextClassName, `${prefixCls}-${mergedShape}`, {
+    [`${prefixCls}-image`]: hasImageElement || src && isImgExist,
+    [`${prefixCls}-icon`]: !!icon
+  }, cssVarCls, rootCls, className, rootClassName, hashId);
+  const sizeStyle = isNumber(size) ? {
+    width: size,
+    height: size,
+    fontSize: icon ? size / 2 : 18
+  } : {};
+  let childrenToRender;
+  if (typeof src === "string" && isImgExist) {
+    childrenToRender = /* @__PURE__ */ createElement("img", {
+      src,
+      draggable,
+      srcSet,
+      onError: handleImgLoadError,
+      alt,
+      crossOrigin
+    });
+  } else if (hasImageElement) {
+    childrenToRender = src;
+  } else if (icon) {
+    childrenToRender = icon;
+  } else if (mounted || scale !== 1) {
+    const transformString = `scale(${scale})`;
+    const childrenStyle = {
+      msTransform: transformString,
+      WebkitTransform: transformString,
+      transform: transformString
+    };
+    childrenToRender = /* @__PURE__ */ createElement(es_default, {
+      onResize: setScaleParam
+    }, /* @__PURE__ */ createElement("span", {
+      className: `${prefixCls}-string`,
+      ref: avatarChildrenRef,
+      style: childrenStyle
+    }, children));
+  } else {
+    childrenToRender = /* @__PURE__ */ createElement("span", {
+      className: `${prefixCls}-string`,
+      style: {
+        opacity: 0
+      },
+      ref: avatarChildrenRef
+    }, children);
+  }
+  return /* @__PURE__ */ createElement("span", {
+    ...others,
+    style: {
+      ...sizeStyle,
+      ...responsiveSizeStyle,
+      ...contextStyle,
+      ...style
+    },
+    className: classString,
+    ref: avatarNodeMergedRef
+  }, childrenToRender);
+});
+if (true) {
+  Avatar.displayName = "Avatar";
+}
+var Avatar_default = Avatar;
+
+// ../../node_modules/.pnpm/@ant-design+icons@6.3.2_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@ant-design/icons/es/icons/EditOutlined.js
+var import_EditOutlined = __toESM(require_EditOutlined());
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+var EditOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends({}, props, {
+  ref,
+  icon: import_EditOutlined.default
+}));
+var RefIcon = /* @__PURE__ */ forwardRef(EditOutlined);
+if (true) {
+  RefIcon.displayName = "EditOutlined";
+}
+var EditOutlined_default = RefIcon;
+
+// ../../node_modules/.pnpm/@ant-design+icons@6.3.2_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@ant-design/icons/es/icons/EnterOutlined.js
+var import_EnterOutlined = __toESM(require_EnterOutlined());
+function _extends2() {
+  _extends2 = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends2.apply(this, arguments);
+}
+var EnterOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends2({}, props, {
+  ref,
+  icon: import_EnterOutlined.default
+}));
+var RefIcon2 = /* @__PURE__ */ forwardRef(EnterOutlined);
+if (true) {
+  RefIcon2.displayName = "EnterOutlined";
+}
+var EnterOutlined_default = RefIcon2;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/style/mixins.js
+var getTitleStyle = (fontSize, lineHeight, color, token) => {
+  const {
+    titleMarginBottom,
+    fontWeightStrong
+  } = token;
+  return {
+    marginBottom: titleMarginBottom,
+    color,
+    fontWeight: fontWeightStrong,
+    fontSize,
+    lineHeight
+  };
+};
+var getTitleStyles = (token) => {
+  const headings = [1, 2, 3, 4, 5];
+  const styles = {};
+  headings.forEach((headingLevel) => {
+    styles[`
+      h${headingLevel}&,
+      div&-h${headingLevel},
+      div&-h${headingLevel} > textarea,
+      h${headingLevel}
+    `] = getTitleStyle(token[`fontSizeHeading${headingLevel}`], token[`lineHeightHeading${headingLevel}`], token.colorTextHeading, token);
+  });
+  return styles;
+};
+var getLinkStyles = (token) => {
+  const {
+    componentCls
+  } = token;
+  const linkCls = `${componentCls}-link`;
+  return {
+    [`&${linkCls}`]: {
+      ...operationUnit(token),
+      userSelect: "text",
+      [`&[disabled], &${componentCls}-disabled`]: {
+        color: token.colorTextDisabled,
+        cursor: "not-allowed",
+        "&:active, &:hover": {
+          color: token.colorTextDisabled
+        },
+        "&:active": {
+          pointerEvents: "none",
+          // Action buttons (copy, edit, expand) must remain interactive even when
+          // the disabled link is being clicked, otherwise their click events get
+          // swallowed by the parent's pointer-events: none during :active.
+          [`${componentCls}-actions`]: {
+            pointerEvents: "auto"
+          }
+        }
+      }
+    }
+  };
+};
+var getResetStyles = (token) => ({
+  code: {
+    margin: "0 0.2em",
+    paddingInline: "0.4em",
+    paddingBlock: "0.2em 0.1em",
+    fontSize: "85%",
+    fontFamily: token.fontFamilyCode,
+    background: "rgba(150, 150, 150, 0.1)",
+    border: `${unit(token.lineWidth)} ${token.lineType} rgba(100, 100, 100, 0.2)`,
+    borderRadius: 3
+  },
+  kbd: {
+    margin: "0 0.2em",
+    paddingInline: "0.4em",
+    paddingBlock: "0.15em 0.1em",
+    fontSize: "90%",
+    fontFamily: token.fontFamilyCode,
+    background: "rgba(150, 150, 150, 0.06)",
+    border: `${unit(token.lineWidth)} ${token.lineType} rgba(100, 100, 100, 0.2)`,
+    borderBottomWidth: 2,
+    borderRadius: 3
+  },
+  mark: {
+    padding: 0,
+    // FIXME hardcode in v4
+    backgroundColor: gold[2]
+  },
+  "u, ins": {
+    textDecoration: "underline",
+    textDecorationSkipInk: "auto"
+  },
+  "s, del": {
+    textDecoration: "line-through"
+  },
+  strong: {
+    fontWeight: token.fontWeightStrong
+  },
+  // list
+  "ul, ol": {
+    marginInline: 0,
+    marginBlock: "0 1em",
+    padding: 0,
+    li: {
+      marginInline: "20px 0",
+      marginBlock: 0,
+      paddingInline: "4px 0",
+      paddingBlock: 0
+    }
+  },
+  ul: {
+    listStyleType: "circle",
+    ul: {
+      listStyleType: "disc"
+    }
+  },
+  ol: {
+    listStyleType: "decimal"
+  },
+  // pre & block
+  "pre, blockquote": {
+    margin: "1em 0"
+  },
+  pre: {
+    padding: "0.4em 0.6em",
+    whiteSpace: "pre-wrap",
+    wordWrap: "break-word",
+    background: "rgba(150, 150, 150, 0.1)",
+    border: `${unit(token.lineWidth)} ${token.lineType} rgba(100, 100, 100, 0.2)`,
+    borderRadius: 3,
+    fontFamily: token.fontFamilyCode,
+    // Compatible for marked
+    code: {
+      display: "inline",
+      margin: 0,
+      padding: 0,
+      fontSize: "inherit",
+      fontFamily: "inherit",
+      background: "transparent",
+      border: 0
+    }
+  },
+  blockquote: {
+    paddingInline: "0.6em 0",
+    paddingBlock: 0,
+    borderInlineStart: "4px solid rgba(100, 100, 100, 0.2)",
+    opacity: 0.85
+  },
+  // table - Follow Table component default style
+  table: {
+    width: "100%",
+    textAlign: "start",
+    borderCollapse: "separate",
+    borderSpacing: 0,
+    marginBlock: "1em",
+    "th, td": {
+      padding: unit(token.padding),
+      overflowWrap: "break-word",
+      borderBottom: `${unit(token.lineWidth)} ${token.lineType} ${token.colorSplit}`
+    },
+    "thead > tr:first-child > th:first-child": {
+      borderStartStartRadius: token.borderRadiusLG
+    },
+    "thead > tr:first-child > th:last-child": {
+      borderStartEndRadius: token.borderRadiusLG
+    },
+    "thead > tr > th": {
+      textAlign: "start",
+      position: "relative",
+      color: token.colorTextHeading,
+      fontWeight: token.fontWeightStrong,
+      backgroundColor: token.colorFillAlter,
+      transition: `background-color ${token.motionDurationMid} ease`,
+      "&:not(:last-child)::before": {
+        position: "absolute",
+        top: "50%",
+        insetInlineEnd: 0,
+        width: 1,
+        height: "1.6em",
+        backgroundColor: token.colorSplit,
+        transform: "translateY(-50%)",
+        content: '""'
+      }
+    },
+    "tbody > tr": {
+      "> th, > td": {
+        transition: `background-color ${token.motionDurationMid} ease`
+      },
+      "&:hover > th, &:hover > td": {
+        backgroundColor: token.colorFillAlter
+      }
+    }
+  }
+});
+var getEditableStyles = (token) => {
+  const {
+    componentCls,
+    paddingSM
+  } = token;
+  const inputShift = paddingSM;
+  return {
+    "&-edit-content": {
+      position: "relative",
+      "div&": {
+        insetInlineStart: token.calc(token.paddingSM).mul(-1).equal(),
+        insetBlockStart: token.calc(inputShift).div(-2).add(1).equal(),
+        marginBottom: token.calc(inputShift).div(2).sub(2).equal()
+      },
+      [`${componentCls}-edit-content-confirm`]: {
+        position: "absolute",
+        insetInlineEnd: token.calc(token.marginXS).add(2).equal(),
+        insetBlockEnd: token.marginXS,
+        color: token.colorIcon,
+        // default style
+        fontWeight: "normal",
+        fontSize: token.fontSize,
+        fontStyle: "normal",
+        pointerEvents: "none"
+      },
+      // Double the `-edit-content` class to raise this selector's specificity
+      // above Input's own `textarea.ant-input { line-height: token.lineHeight }`
+      // rule. Both otherwise share the same (0,1,1) specificity and Input is
+      // injected after Typography, so on the raw TextArea path the Input rule
+      // would win the cascade and the inherited font props below (notably
+      // `line-height`) would not apply.
+      [`&${componentCls}-edit-content textarea`]: {
+        margin: "0!important",
+        // Inherit the edited element's typography so the editing textarea
+        // matches the rendered text (including customized heading tokens such
+        // as `fontSizeHeading1` and the strong heading weight), keeping editing
+        // WYSIWYG. Browsers do not inherit font properties for form controls by
+        // default, so they are set explicitly here.
+        fontSize: "inherit",
+        lineHeight: "inherit",
+        fontFamily: "inherit",
+        fontWeight: "inherit",
+        // Fix Editable Textarea flash in Firefox
+        MozTransition: "none",
+        height: "1em"
+      }
+    }
+  };
+};
+var getCopyableStyles = (token) => ({
+  [`${token.componentCls}-copy-success`]: {
+    "&, &:hover, &:focus": {
+      color: token.colorSuccess
+    }
+  },
+  [`${token.componentCls}-copy-icon-only`]: {
+    marginInlineStart: 0
+  }
+});
+var getEllipsisStyles = () => ({
+  "a&-ellipsis, span&-ellipsis": {
+    display: "inline-block",
+    maxWidth: "100%"
+  },
+  "&-ellipsis-single-line": {
+    ...textEllipsis,
+    // https://blog.csdn.net/iefreer/article/details/50421025
+    "a&, span&": {
+      verticalAlign: "bottom"
+    },
+    "> code": {
+      paddingBlock: 0,
+      maxWidth: "calc(100% - 1.2em)",
+      display: "inline-block",
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      verticalAlign: "bottom",
+      // https://github.com/ant-design/ant-design/issues/45953
+      boxSizing: "content-box"
+    }
+  },
+  "&-ellipsis-multiple-line": {
+    display: "-webkit-box",
+    overflow: "hidden",
+    WebkitLineClamp: 3,
+    WebkitBoxOrient: "vertical"
+  }
+});
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/style/index.js
+var genTypographyStyle = (token) => {
+  const {
+    componentCls,
+    titleMarginTop
+  } = token;
+  return {
+    [componentCls]: {
+      color: token.colorText,
+      wordBreak: "break-word",
+      lineHeight: token.lineHeight,
+      [`&${componentCls}-secondary, &${componentCls}-link${componentCls}-secondary`]: {
+        color: token.colorTextDescription
+      },
+      [`&${componentCls}-success, &${componentCls}-link${componentCls}-success`]: {
+        color: token.colorSuccessText
+      },
+      [`&${componentCls}-warning, &${componentCls}-link${componentCls}-warning`]: {
+        color: token.colorWarningText
+      },
+      [`&${componentCls}-danger, &${componentCls}-link${componentCls}-danger`]: {
+        color: token.colorErrorText,
+        [`&${componentCls}-link:active, &${componentCls}-link:focus`]: {
+          color: token.colorErrorTextActive
+        },
+        [`&${componentCls}-link:hover`]: {
+          color: token.colorErrorTextHover
+        }
+      },
+      [`&${componentCls}-disabled`]: {
+        color: token.colorTextDisabled,
+        cursor: "not-allowed",
+        userSelect: "none"
+      },
+      "div&, p": {
+        marginBottom: "1em"
+      },
+      ...getTitleStyles(token),
+      [`& + h1${componentCls}, & + h2${componentCls}, & + h3${componentCls}, & + h4${componentCls}, & + h5${componentCls}`]: {
+        marginTop: titleMarginTop
+      },
+      "div, ul, li, p, h1, h2, h3, h4, h5": {
+        "+ h1, + h2, + h3, + h4, + h5": {
+          marginTop: titleMarginTop
+        }
+      },
+      ...getResetStyles(token),
+      ...getLinkStyles(token),
+      // Operation
+      [`${componentCls}-actions`]: {
+        display: "inline"
+      },
+      [`
+        ${componentCls}-expand,
+        ${componentCls}-collapse,
+        ${componentCls}-edit,
+        ${componentCls}-copy
+      `]: {
+        ...operationUnit(token),
+        marginInlineStart: token.marginXXS
+      },
+      [`${componentCls}-actions-start`]: {
+        [`
+          ${componentCls}-expand,
+          ${componentCls}-collapse,
+          ${componentCls}-edit,
+          ${componentCls}-copy:not(${componentCls}-copy-icon-only)
+        `]: {
+          marginInlineStart: 0,
+          marginInlineEnd: token.marginXXS
+        }
+      },
+      ...getEditableStyles(token),
+      ...getCopyableStyles(token),
+      ...getEllipsisStyles(),
+      "&-rtl": {
+        direction: "rtl"
+      }
+    }
+  };
+};
+var prepareComponentToken2 = () => ({
+  titleMarginTop: "1.2em",
+  titleMarginBottom: "0.5em"
+});
+var style_default2 = genStyleHooks("Typography", genTypographyStyle, prepareComponentToken2);
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Editable.js
+var Editable = (props) => {
+  const {
+    prefixCls,
+    "aria-label": ariaLabel,
+    className,
+    style,
+    classNames,
+    styles,
+    direction,
+    maxLength,
+    autoSize = true,
+    value,
+    onSave,
+    onCancel,
+    onEnd,
+    component,
+    enterIcon = /* @__PURE__ */ createElement(EnterOutlined_default, null)
+  } = props;
+  const ref = useRef(null);
+  const inCompositionRef = useRef(false);
+  const lastKeyCodeRef = useRef(null);
+  const [current, setCurrent] = useState(value);
+  useEffect(() => {
+    setCurrent(value);
+  }, [value]);
+  useEffect(() => {
+    if (ref.current?.resizableTextArea) {
+      const {
+        textArea
+      } = ref.current.resizableTextArea;
+      textArea.focus();
+      const {
+        length
+      } = textArea.value;
+      textArea.setSelectionRange(length, length);
+    }
+  }, []);
+  const onChange = ({
+    target
+  }) => {
+    setCurrent(target.value.replace(/[\n\r]/g, ""));
+  };
+  const onCompositionStart = () => {
+    inCompositionRef.current = true;
+  };
+  const onCompositionEnd = () => {
+    inCompositionRef.current = false;
+  };
+  const onKeyDown = ({
+    keyCode
+  }) => {
+    if (inCompositionRef.current) {
+      return;
+    }
+    lastKeyCodeRef.current = keyCode;
+  };
+  const confirmChange = () => {
+    onSave(current.trim());
+  };
+  const onKeyUp = ({
+    keyCode,
+    ctrlKey,
+    altKey,
+    metaKey,
+    shiftKey
+  }) => {
+    if (lastKeyCodeRef.current !== keyCode || inCompositionRef.current || ctrlKey || altKey || metaKey || shiftKey) {
+      return;
+    }
+    if (keyCode === KeyCode_default.ENTER) {
+      confirmChange();
+      onEnd?.();
+    } else if (keyCode === KeyCode_default.ESC) {
+      onCancel();
+    }
+  };
+  const onBlur = () => {
+    confirmChange();
+  };
+  const [hashId, cssVarCls] = style_default2(prefixCls);
+  const textAreaClassName = clsx(prefixCls, `${prefixCls}-edit-content`, {
+    [`${prefixCls}-rtl`]: direction === "rtl",
+    [`${prefixCls}-${component}`]: !!component
+  }, className, classNames.root, hashId, cssVarCls);
+  return /* @__PURE__ */ createElement("div", {
+    className: textAreaClassName,
+    style: {
+      ...styles.root,
+      ...style
+    }
+  }, /* @__PURE__ */ createElement(TextArea_default, {
+    ref,
+    maxLength,
+    value: current,
+    onChange,
+    onKeyDown,
+    onKeyUp,
+    onCompositionStart,
+    onCompositionEnd,
+    onBlur,
+    "aria-label": ariaLabel,
+    rows: 1,
+    autoSize,
+    className: classNames.textarea,
+    style: styles.textarea
+  }), enterIcon !== null ? cloneElement(enterIcon, {
+    className: `${prefixCls}-edit-content-confirm`
+  }) : null);
+};
+var Editable_default = Editable;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/_util/copy.js
+var execCopy = (text, isHtmlFormat) => {
+  let copySuccess = false;
+  const onCopy = (event) => {
+    event.stopPropagation();
+    event.preventDefault();
+    event.clipboardData?.clearData();
+    event.clipboardData?.setData("text/plain", text);
+    if (isHtmlFormat) {
+      event.clipboardData?.setData("text/html", text);
+    }
+    copySuccess = true;
+  };
+  try {
+    document.addEventListener("copy", onCopy, {
+      capture: true
+    });
+    document.execCommand("copy");
+    return copySuccess;
+  } catch {
+    return false;
+  } finally {
+    document.removeEventListener("copy", onCopy, {
+      capture: true
+    });
+  }
+};
+var asyncCopy = async (text, isHtmlFormat) => {
+  try {
+    if (isHtmlFormat) {
+      await navigator.clipboard.write([new ClipboardItem({
+        "text/html": new Blob([text], {
+          type: "text/html"
+        }),
+        "text/plain": new Blob([text], {
+          type: "text/plain"
+        })
+      })]);
+    } else {
+      await navigator.clipboard.writeText(text);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function copy(text, config) {
+  if (typeof text !== "string") {
+    true ? warning_default(false, "The clipboard content must be of string type", "") : void 0;
+    return false;
+  }
+  const isHtmlFormat = config?.format === "text/html";
+  if (await asyncCopy(text, isHtmlFormat)) {
+    return true;
+  }
+  if (execCopy(text, isHtmlFormat)) {
+    return true;
+  }
+  return false;
+}
+var copy_default = copy;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/_util/toList.js
+var toList = (val, config = {}) => {
+  if (!isNonNullable(val) && config?.skipEmpty) {
+    return [];
+  }
+  return Array.isArray(val) ? val : [val];
+};
+var toList_default = toList;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/hooks/useCopyClick.js
+var useCopyClick = ({
+  copyConfig,
+  children
+}) => {
+  const [copied, setCopied] = useDelayState(false);
+  const [copyLoading, setCopyLoading] = useState(false);
+  const copyOptions = {};
+  if (copyConfig.format) {
+    copyOptions.format = copyConfig.format;
+  }
+  const onClick = useEvent_default(async (e) => {
+    e?.preventDefault();
+    e?.stopPropagation();
+    setCopyLoading(true);
+    try {
+      const text = isFunction(copyConfig.text) ? await copyConfig.text() : copyConfig.text;
+      await copy_default(text || toList_default(children, {
+        skipEmpty: true
+      }).join("") || "", copyOptions);
+      setCopyLoading(false);
+      setCopied(true, true);
+      setCopied(false, {
+        ms: 3e3
+      });
+      copyConfig.onCopy?.(e);
+    } catch (error) {
+      setCopyLoading(false);
+      throw error;
+    }
+  });
+  return {
+    copied,
+    copyLoading,
+    onClick
+  };
+};
+var useCopyClick_default = useCopyClick;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/hooks/useMergedConfig.js
+var useMergedConfig = (propConfig, templateConfig) => {
+  const support = Boolean(propConfig);
+  return useMemo(() => {
+    const config = {
+      ...templateConfig,
+      ...support && isPlainObject(propConfig) ? propConfig : null
+    };
+    return [support, config];
+  }, [support, propConfig, templateConfig]);
+};
+var useMergedConfig_default = useMergedConfig;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/hooks/usePrevious.js
+var usePrevious = (value) => {
+  const ref = useRef(void 0);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+};
+var usePrevious_default = usePrevious;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/hooks/useTooltipProps.js
+var useTooltipProps = (tooltip, editConfigText, children) => useMemo(() => {
+  if (tooltip === true) {
+    return {
+      title: editConfigText ?? children
+    };
+  }
+  if (/* @__PURE__ */ isValidElement(tooltip)) {
+    return {
+      title: tooltip
+    };
+  }
+  if (isPlainObject(tooltip)) {
+    return {
+      title: editConfigText ?? children,
+      ...tooltip
+    };
+  }
+  return {
+    title: tooltip
+  };
+}, [tooltip, editConfigText, children]);
+var useTooltipProps_default = useTooltipProps;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/hooks/useTypographySemantic.js
+var useTypographySemantic = (customizePrefixCls, classNames, styles, typographyDirection, props) => {
+  const {
+    getPrefixCls,
+    direction: contextDirection,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles
+  } = useComponentConfig("typography");
+  const direction = typographyDirection ?? contextDirection;
+  const prefixCls = getPrefixCls("typography", customizePrefixCls);
+  const mergedProps = {
+    ...props,
+    prefixCls,
+    direction
+  };
+  const contextClassNamesObject = useMemo(() => ({
+    root: contextClassName
+  }), [contextClassName]);
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNamesObject, contextClassNames, classNames], [contextStyles, contextStyleRoot, styles], {
+    props: mergedProps
+  });
+  return [mergedClassNames, mergedStyles, prefixCls, direction];
+};
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Typography.js
+var InternalTypography = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    component: Component = "article",
+    className,
+    rootClassName,
+    children,
+    direction,
+    style,
+    classNames,
+    styles,
+    prefixCls,
+    ...restProps
+  } = props;
+  const [hashId, cssVarCls] = style_default2(prefixCls);
+  const componentClassName = clsx(prefixCls, {
+    [`${prefixCls}-rtl`]: direction === "rtl"
+  }, className, rootClassName, hashId, cssVarCls, classNames?.root);
+  const mergedStyle = {
+    ...styles?.root,
+    ...style
+  };
+  return /* @__PURE__ */ createElement(Component, {
+    ...restProps,
+    className: componentClassName,
+    style: mergedStyle,
+    ref
+  }, children);
+});
+if (true) {
+  InternalTypography.displayName = "InternalTypography";
+}
+var Typography = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    rootClassName,
+    direction: typographyDirection,
+    classNames,
+    styles,
+    ...restProps
+  } = props;
+  const [mergedClassNames, mergedStyles, mergedPrefixCls, mergedDirection] = useTypographySemantic(customizePrefixCls, classNames, styles, typographyDirection, props);
+  return /* @__PURE__ */ createElement(InternalTypography, {
+    ref,
+    className: clsx(className, rootClassName),
+    direction: mergedDirection,
+    classNames: mergedClassNames,
+    styles: mergedStyles,
+    prefixCls: mergedPrefixCls,
+    ...restProps
+  });
+});
+if (true) {
+  Typography.displayName = "Typography";
+}
+
+// ../../node_modules/.pnpm/@ant-design+icons@6.3.2_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@ant-design/icons/es/icons/CheckOutlined.js
+var import_CheckOutlined = __toESM(require_CheckOutlined());
+function _extends3() {
+  _extends3 = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends3.apply(this, arguments);
+}
+var CheckOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends3({}, props, {
+  ref,
+  icon: import_CheckOutlined.default
+}));
+var RefIcon3 = /* @__PURE__ */ forwardRef(CheckOutlined);
+if (true) {
+  RefIcon3.displayName = "CheckOutlined";
+}
+var CheckOutlined_default = RefIcon3;
+
+// ../../node_modules/.pnpm/@ant-design+icons@6.3.2_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@ant-design/icons/es/icons/CopyOutlined.js
+var import_CopyOutlined = __toESM(require_CopyOutlined());
+function _extends4() {
+  _extends4 = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends4.apply(this, arguments);
+}
+var CopyOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends4({}, props, {
+  ref,
+  icon: import_CopyOutlined.default
+}));
+var RefIcon4 = /* @__PURE__ */ forwardRef(CopyOutlined);
+if (true) {
+  RefIcon4.displayName = "CopyOutlined";
+}
+var CopyOutlined_default = RefIcon4;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Base/util.js
+var toCopyConfigList = (val) => {
+  if (val === false) {
+    return [false, false];
+  }
+  return toList_default(val);
+};
+function getNode(dom, defaultNode, needDom) {
+  if (dom === true || dom === void 0) {
+    return defaultNode;
+  }
+  return dom || needDom && defaultNode;
+}
+function isEleEllipsis(ele) {
+  const childDiv = document.createElement("em");
+  ele.appendChild(childDiv);
+  if (true) {
+    childDiv.className = "ant-typography-css-ellipsis-content-measure";
+  }
+  const rect = ele.getBoundingClientRect();
+  const childRect = childDiv.getBoundingClientRect();
+  ele.removeChild(childDiv);
+  return (
+    // Horizontal out of range
+    rect.left > childRect.left || childRect.right > rect.right || // Vertical out of range
+    rect.top > childRect.top || childRect.bottom > rect.bottom
+  );
+}
+var isValidText = (val) => ["string", "number"].includes(typeof val);
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Base/CopyBtn.js
+var CopyBtn = (props) => {
+  const {
+    prefixCls,
+    copied,
+    locale,
+    iconOnly,
+    tooltips,
+    icon,
+    tabIndex,
+    onCopy,
+    loading: btnLoading,
+    className,
+    style
+  } = props;
+  const tooltipNodes = toCopyConfigList(tooltips);
+  const iconNodes = toCopyConfigList(icon);
+  const {
+    copied: copiedText,
+    copy: copyText
+  } = locale ?? {};
+  const systemStr = copied ? copiedText : copyText;
+  const copyTitle = getNode(tooltipNodes[copied ? 1 : 0], systemStr);
+  const ariaLabel = typeof copyTitle === "string" ? copyTitle : systemStr;
+  return /* @__PURE__ */ createElement(tooltip_default, {
+    title: copyTitle
+  }, /* @__PURE__ */ createElement("button", {
+    type: "button",
+    className: clsx(`${prefixCls}-copy`, className, {
+      [`${prefixCls}-copy-success`]: copied,
+      [`${prefixCls}-copy-icon-only`]: iconOnly
+    }),
+    style,
+    onClick: onCopy,
+    "aria-label": ariaLabel,
+    tabIndex
+  }, copied ? getNode(iconNodes[1], /* @__PURE__ */ createElement(CheckOutlined_default, null), true) : getNode(iconNodes[0], btnLoading ? /* @__PURE__ */ createElement(LoadingOutlined_default, null) : /* @__PURE__ */ createElement(CopyOutlined_default, null), true)));
+};
+var CopyBtn_default = CopyBtn;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Base/Ellipsis.js
+var MeasureText = /* @__PURE__ */ forwardRef(({
+  style,
+  children
+}, ref) => {
+  const spanRef = useRef(null);
+  useImperativeHandle(ref, () => ({
+    isExceed: () => {
+      const span = spanRef.current;
+      return span.scrollHeight > span.clientHeight;
+    },
+    getHeight: () => spanRef.current.clientHeight
+  }));
+  return /* @__PURE__ */ createElement("span", {
+    "aria-hidden": true,
+    ref: spanRef,
+    style: {
+      position: "fixed",
+      display: "block",
+      left: 0,
+      top: 0,
+      pointerEvents: "none",
+      backgroundColor: "rgba(255, 0, 0, 0.65)",
+      ...style
+    }
+  }, children);
+});
+var getNodesLen = (nodeList) => nodeList.reduce((totalLen, node) => totalLen + (isValidText(node) ? String(node).length : 1), 0);
+function sliceNodes(nodeList, len) {
+  let currLen = 0;
+  const currentNodeList = [];
+  for (let i = 0; i < nodeList.length; i += 1) {
+    if (currLen === len) {
+      return currentNodeList;
+    }
+    const node = nodeList[i];
+    const canCut = isValidText(node);
+    const nodeLen = canCut ? String(node).length : 1;
+    const nextLen = currLen + nodeLen;
+    if (nextLen > len) {
+      const restLen = len - currLen;
+      currentNodeList.push(String(node).slice(0, restLen));
+      return currentNodeList;
+    }
+    currentNodeList.push(node);
+    currLen = nextLen;
+  }
+  return nodeList;
+}
+var STATUS_MEASURE_NONE = 0;
+var STATUS_MEASURE_PREPARE = 1;
+var STATUS_MEASURE_START = 2;
+var STATUS_MEASURE_NEED_ELLIPSIS = 3;
+var STATUS_MEASURE_NO_NEED_ELLIPSIS = 4;
+var lineClipStyle = {
+  display: "-webkit-box",
+  overflow: "hidden",
+  WebkitBoxOrient: "vertical"
+};
+function EllipsisMeasure(props) {
+  const {
+    enableMeasure,
+    width,
+    text,
+    children,
+    rows,
+    expanded,
+    measureDeps,
+    miscDeps,
+    onEllipsis
+  } = props;
+  const nodeList = useMemo(() => toArray(text), [text]);
+  const nodeLen = useMemo(() => getNodesLen(nodeList), [text]);
+  const fullContent = useMemo(() => children(nodeList, false), [text].concat(_toConsumableArray(measureDeps)));
+  const [ellipsisCutIndex, setEllipsisCutIndex] = useState(null);
+  const cutMidRef = useRef(null);
+  const measureWhiteSpaceRef = useRef(null);
+  const needEllipsisRef = useRef(null);
+  const descRowsEllipsisRef = useRef(null);
+  const symbolRowEllipsisRef = useRef(null);
+  const [canEllipsis, setCanEllipsis] = useState(false);
+  const [needEllipsis, setNeedEllipsis] = useState(STATUS_MEASURE_NONE);
+  const [ellipsisHeight, setEllipsisHeight] = useState(0);
+  const [parentWhiteSpace, setParentWhiteSpace] = useState(null);
+  useLayoutEffect_default(() => {
+    if (enableMeasure && width && nodeLen) {
+      setNeedEllipsis(STATUS_MEASURE_PREPARE);
+    } else {
+      setNeedEllipsis(STATUS_MEASURE_NONE);
+    }
+  }, [width, text, rows, enableMeasure, nodeList].concat(_toConsumableArray(measureDeps)));
+  useLayoutEffect_default(() => {
+    if (needEllipsis === STATUS_MEASURE_PREPARE) {
+      setNeedEllipsis(STATUS_MEASURE_START);
+      const nextWhiteSpace = measureWhiteSpaceRef.current && getComputedStyle(measureWhiteSpaceRef.current).whiteSpace;
+      setParentWhiteSpace(nextWhiteSpace);
+    } else if (needEllipsis === STATUS_MEASURE_START) {
+      const isOverflow = !!needEllipsisRef.current?.isExceed();
+      setNeedEllipsis(isOverflow ? STATUS_MEASURE_NEED_ELLIPSIS : STATUS_MEASURE_NO_NEED_ELLIPSIS);
+      setEllipsisCutIndex(isOverflow ? [0, nodeLen] : null);
+      setCanEllipsis(isOverflow);
+      const baseRowsEllipsisHeight = needEllipsisRef.current?.getHeight() || 0;
+      const descRowsEllipsisHeight = rows === 1 ? 0 : descRowsEllipsisRef.current?.getHeight() || 0;
+      const symbolRowEllipsisHeight = symbolRowEllipsisRef.current?.getHeight() || 0;
+      const maxRowsHeight = Math.max(
+        baseRowsEllipsisHeight,
+        // height of rows with ellipsis
+        descRowsEllipsisHeight + symbolRowEllipsisHeight
+      );
+      setEllipsisHeight(maxRowsHeight + 1);
+      onEllipsis(isOverflow);
+    }
+  }, [needEllipsis]);
+  const cutMidIndex = ellipsisCutIndex ? Math.ceil((ellipsisCutIndex[0] + ellipsisCutIndex[1]) / 2) : 0;
+  useLayoutEffect_default(() => {
+    const [minIndex, maxIndex] = ellipsisCutIndex || [0, 0];
+    if (minIndex !== maxIndex) {
+      const midHeight = cutMidRef.current?.getHeight() || 0;
+      const isOverflow = midHeight > ellipsisHeight;
+      let targetMidIndex = cutMidIndex;
+      if (maxIndex - minIndex === 1) {
+        targetMidIndex = isOverflow ? minIndex : maxIndex;
+      }
+      setEllipsisCutIndex(isOverflow ? [minIndex, targetMidIndex] : [targetMidIndex, maxIndex]);
+    }
+  }, [ellipsisCutIndex, cutMidIndex]);
+  const finalContent = useMemo(() => {
+    if (!enableMeasure) {
+      return children(nodeList, false);
+    }
+    if (needEllipsis !== STATUS_MEASURE_NEED_ELLIPSIS || !ellipsisCutIndex || ellipsisCutIndex[0] !== ellipsisCutIndex[1]) {
+      const content = children(nodeList, false);
+      if ([STATUS_MEASURE_NO_NEED_ELLIPSIS, STATUS_MEASURE_NONE].includes(needEllipsis)) {
+        return content;
+      }
+      return /* @__PURE__ */ createElement("span", {
+        style: {
+          ...lineClipStyle,
+          WebkitLineClamp: rows
+        }
+      }, content);
+    }
+    return children(expanded ? nodeList : sliceNodes(nodeList, ellipsisCutIndex[0]), canEllipsis);
+  }, [expanded, needEllipsis, ellipsisCutIndex, nodeList].concat(_toConsumableArray(miscDeps)));
+  const measureStyle = {
+    width,
+    margin: 0,
+    padding: 0,
+    whiteSpace: parentWhiteSpace === "nowrap" ? "normal" : "inherit"
+  };
+  return /* @__PURE__ */ createElement(Fragment, null, finalContent, needEllipsis === STATUS_MEASURE_START && /* @__PURE__ */ createElement(Fragment, null, /* @__PURE__ */ createElement(MeasureText, {
+    style: {
+      ...measureStyle,
+      ...lineClipStyle,
+      WebkitLineClamp: rows
+    },
+    ref: needEllipsisRef
+  }, fullContent), /* @__PURE__ */ createElement(MeasureText, {
+    style: {
+      ...measureStyle,
+      ...lineClipStyle,
+      WebkitLineClamp: rows - 1
+    },
+    ref: descRowsEllipsisRef
+  }, fullContent), /* @__PURE__ */ createElement(MeasureText, {
+    style: {
+      ...measureStyle,
+      ...lineClipStyle,
+      WebkitLineClamp: 1
+    },
+    ref: symbolRowEllipsisRef
+  }, children([], true))), needEllipsis === STATUS_MEASURE_NEED_ELLIPSIS && ellipsisCutIndex && ellipsisCutIndex[0] !== ellipsisCutIndex[1] && /* @__PURE__ */ createElement(MeasureText, {
+    style: {
+      ...measureStyle,
+      top: 400
+    },
+    ref: cutMidRef
+  }, children(sliceNodes(nodeList, cutMidIndex), true)), needEllipsis === STATUS_MEASURE_PREPARE && /* @__PURE__ */ createElement("span", {
+    style: {
+      whiteSpace: "inherit"
+    },
+    ref: measureWhiteSpaceRef
+  }));
+}
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Base/EllipsisTooltip.js
+var EllipsisTooltip = ({
+  enableEllipsis,
+  isEllipsis,
+  disabled,
+  children,
+  tooltipProps
+}) => {
+  if (!tooltipProps?.title || !enableEllipsis) {
+    return children;
+  }
+  return /* @__PURE__ */ createElement(tooltip_default, {
+    ...tooltipProps,
+    disabled: !isEllipsis || disabled
+  }, children);
+};
+if (true) {
+  EllipsisTooltip.displayName = "EllipsisTooltip";
+}
+var EllipsisTooltip_default = EllipsisTooltip;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Base/index.js
+function wrapperDecorations({
+  mark,
+  code,
+  underline,
+  delete: del,
+  strong,
+  keyboard,
+  italic
+}, content) {
+  let currentContent = content;
+  function wrap(tag, needed) {
+    if (!needed) {
+      return;
+    }
+    currentContent = /* @__PURE__ */ createElement(tag, {}, currentContent);
+  }
+  wrap("strong", strong);
+  wrap("u", underline);
+  wrap("del", del);
+  wrap("code", code);
+  wrap("mark", mark);
+  wrap("kbd", keyboard);
+  wrap("i", italic);
+  return currentContent;
+}
+var ELLIPSIS_STR = "...";
+var DECORATION_PROPS = ["delete", "mark", "code", "underline", "strong", "keyboard", "italic"];
+var Base = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    style,
+    classNames,
+    styles,
+    direction: typographyDirection,
+    type,
+    disabled,
+    children,
+    ellipsis,
+    editable,
+    copyable,
+    actions,
+    component,
+    title,
+    onMouseEnter,
+    onMouseLeave,
+    ...restProps
+  } = props;
+  const [textLocale] = useLocale_default("Text");
+  const typographyRef = useRef(null);
+  const editIconRef = useRef(null);
+  const [mergedClassNames, mergedStyles, prefixCls, direction] = useTypographySemantic(customizePrefixCls, classNames, styles, typographyDirection, props);
+  const textProps = omit(restProps, DECORATION_PROPS);
+  const [enableEdit, editConfig] = useMergedConfig_default(editable);
+  const [editing, setEditing] = useControlledState(false, editConfig.editing);
+  const {
+    triggerType = ["icon"]
+  } = editConfig;
+  const triggerEdit = (edit) => {
+    if (edit) {
+      editConfig.onStart?.();
+    }
+    setEditing(edit);
+  };
+  const prevEditing = usePrevious_default(editing);
+  useLayoutEffect_default(() => {
+    if (!editing && prevEditing) {
+      editIconRef.current?.focus();
+    }
+  }, [editing]);
+  const onEditClick = (e) => {
+    e?.preventDefault();
+    triggerEdit(true);
+  };
+  const onEditChange = (value) => {
+    editConfig.onChange?.(value);
+    triggerEdit(false);
+  };
+  const onEditCancel = () => {
+    editConfig.onCancel?.();
+    triggerEdit(false);
+  };
+  const [enableCopy, copyConfig] = useMergedConfig_default(copyable);
+  const {
+    placement = "end"
+  } = actions ?? {};
+  const {
+    copied,
+    copyLoading,
+    onClick: onCopyClick
+  } = useCopyClick_default({
+    copyConfig,
+    children
+  });
+  const [isLineClampSupport, setIsLineClampSupport] = useState(false);
+  const [isTextOverflowSupport, setIsTextOverflowSupport] = useState(false);
+  const [isJsEllipsis, setIsJsEllipsis] = useState(false);
+  const [isNativeEllipsis, setIsNativeEllipsis] = useState(false);
+  const [isNativeVisible, setIsNativeVisible] = useState(true);
+  const [enableEllipsis, ellipsisConfig] = useMergedConfig_default(ellipsis, {
+    expandable: false,
+    symbol: (isExpanded) => isExpanded ? textLocale?.collapse : textLocale?.expand
+  });
+  const [expanded, setExpanded] = useControlledState(ellipsisConfig.defaultExpanded || false, ellipsisConfig.expanded);
+  const mergedEnableEllipsis = enableEllipsis && (!expanded || ellipsisConfig.expandable === "collapsible");
+  const {
+    rows = 1
+  } = ellipsisConfig;
+  const needMeasureEllipsis = useMemo(() => (
+    // Disable ellipsis
+    mergedEnableEllipsis && // Provide suffix
+    (ellipsisConfig.suffix !== void 0 || ellipsisConfig.onEllipsis || // Can't use css ellipsis since we need to provide the place for button
+    ellipsisConfig.expandable || enableEdit || enableCopy)
+  ), [mergedEnableEllipsis, ellipsisConfig, enableEdit, enableCopy]);
+  useLayoutEffect_default(() => {
+    if (enableEllipsis && !needMeasureEllipsis) {
+      setIsLineClampSupport(isStyleSupport("webkitLineClamp"));
+      setIsTextOverflowSupport(isStyleSupport("textOverflow"));
+    }
+  }, [needMeasureEllipsis, enableEllipsis]);
+  const [cssEllipsis, setCssEllipsis] = useState(mergedEnableEllipsis);
+  const canUseCssEllipsis = useMemo(() => {
+    if (needMeasureEllipsis) {
+      return false;
+    }
+    if (rows === 1) {
+      return isTextOverflowSupport;
+    }
+    return isLineClampSupport;
+  }, [needMeasureEllipsis, rows, isLineClampSupport, isTextOverflowSupport]);
+  useLayoutEffect_default(() => {
+    setCssEllipsis(canUseCssEllipsis && mergedEnableEllipsis);
+  }, [canUseCssEllipsis, mergedEnableEllipsis]);
+  const tooltipProps = useTooltipProps_default(ellipsisConfig.tooltip, editConfig.text, children);
+  const needNativeEllipsisMeasure = cssEllipsis && !!tooltipProps.title;
+  const isMergedEllipsis = mergedEnableEllipsis && (cssEllipsis ? needNativeEllipsisMeasure && isNativeEllipsis : isJsEllipsis);
+  const cssTextOverflow = mergedEnableEllipsis && rows === 1 && cssEllipsis;
+  const cssLineClamp = mergedEnableEllipsis && rows > 1 && cssEllipsis;
+  const onExpandClick = (e, info) => {
+    setExpanded(info.expanded);
+    ellipsisConfig.onExpand?.(e, info);
+  };
+  const [ellipsisWidth, setEllipsisWidth] = useState(0);
+  const [isHoveringOperations, setIsHoveringOperations] = useDelayState(false);
+  const isHoveringTypographyRef = useRef(false);
+  const onResize = ({
+    offsetWidth
+  }) => {
+    setEllipsisWidth(offsetWidth);
+  };
+  const onJsEllipsis = (jsEllipsis) => {
+    setIsJsEllipsis(jsEllipsis);
+    if (isJsEllipsis !== jsEllipsis) {
+      ellipsisConfig.onEllipsis?.(jsEllipsis);
+    }
+  };
+  const measureNativeEllipsis = useCallback(() => {
+    const textEle = typographyRef.current;
+    if (enableEllipsis && needNativeEllipsisMeasure && textEle) {
+      const currentEllipsis = isEleEllipsis(textEle);
+      setIsNativeEllipsis((prev) => prev === currentEllipsis ? prev : currentEllipsis);
+    }
+  }, [enableEllipsis, needNativeEllipsisMeasure]);
+  useEffect(() => {
+    if (isHoveringTypographyRef.current) {
+      measureNativeEllipsis();
+    }
+  }, [measureNativeEllipsis, children, cssLineClamp, isNativeVisible, ellipsisWidth]);
+  useEffect(() => {
+    const textEle = typographyRef.current;
+    if (typeof IntersectionObserver === "undefined" || !textEle || !needNativeEllipsisMeasure || !mergedEnableEllipsis) {
+      return;
+    }
+    const observer = new IntersectionObserver(() => {
+      setIsNativeVisible(!!textEle.offsetParent);
+    });
+    observer.observe(textEle);
+    return () => {
+      observer.disconnect();
+    };
+  }, [needNativeEllipsisMeasure, mergedEnableEllipsis]);
+  const topAriaLabel = useMemo(() => {
+    if (!enableEllipsis || cssEllipsis) {
+      return void 0;
+    }
+    return [editConfig.text, children, title, tooltipProps.title].find(isValidText);
+  }, [enableEllipsis, cssEllipsis, title, tooltipProps.title, isMergedEllipsis, editConfig.text]);
+  if (editing) {
+    return /* @__PURE__ */ createElement(Editable_default, {
+      value: editConfig.text ?? (typeof children === "string" ? children : ""),
+      onSave: onEditChange,
+      onCancel: onEditCancel,
+      onEnd: editConfig.onEnd,
+      prefixCls,
+      className,
+      style,
+      direction,
+      component,
+      maxLength: editConfig.maxLength,
+      autoSize: editConfig.autoSize,
+      enterIcon: editConfig.enterIcon,
+      classNames: mergedClassNames,
+      styles: mergedStyles
+    });
+  }
+  const renderExpand = () => {
+    const {
+      expandable,
+      symbol
+    } = ellipsisConfig;
+    return expandable ? /* @__PURE__ */ createElement("button", {
+      type: "button",
+      key: "expand",
+      className: clsx(`${prefixCls}-${expanded ? "collapse" : "expand"}`, mergedClassNames.action),
+      style: mergedStyles.action,
+      onClick: (e) => onExpandClick(e, {
+        expanded: !expanded
+      }),
+      "aria-label": expanded ? textLocale.collapse : textLocale?.expand
+    }, isFunction(symbol) ? symbol(expanded) : symbol) : null;
+  };
+  const renderEdit = () => {
+    if (!enableEdit) {
+      return;
+    }
+    const {
+      icon,
+      tooltip,
+      tabIndex
+    } = editConfig;
+    const editTitle = toArray(tooltip)[0] || textLocale?.edit;
+    const ariaLabel = typeof editTitle === "string" ? editTitle : "";
+    return triggerType.includes("icon") ? /* @__PURE__ */ createElement(tooltip_default, {
+      key: "edit",
+      title: tooltip === false ? "" : editTitle
+    }, /* @__PURE__ */ createElement("button", {
+      type: "button",
+      ref: editIconRef,
+      className: clsx(`${prefixCls}-edit`, mergedClassNames.action),
+      style: mergedStyles.action,
+      onClick: onEditClick,
+      "aria-label": ariaLabel,
+      tabIndex
+    }, icon || /* @__PURE__ */ createElement(EditOutlined_default, {
+      role: "button"
+    }))) : null;
+  };
+  const renderCopy = () => {
+    if (!enableCopy) {
+      return null;
+    }
+    return /* @__PURE__ */ createElement(CopyBtn_default, {
+      key: "copy",
+      ...copyConfig,
+      prefixCls,
+      copied,
+      locale: textLocale,
+      onCopy: onCopyClick,
+      loading: copyLoading,
+      iconOnly: !isReactRenderable(children),
+      className: mergedClassNames.action,
+      style: mergedStyles.action
+    });
+  };
+  const renderOperations = (canEllipsis) => {
+    const expandNode = canEllipsis && renderExpand();
+    const editNode = renderEdit();
+    const copyNode = renderCopy();
+    if (!expandNode && !editNode && !copyNode) {
+      return null;
+    }
+    return /* @__PURE__ */ createElement("span", {
+      key: "operations",
+      className: clsx(`${prefixCls}-actions`, mergedClassNames.actions, {
+        [`${prefixCls}-actions-start`]: placement === "start"
+      }),
+      style: mergedStyles.actions,
+      onMouseEnter: () => setIsHoveringOperations(true, true),
+      onMouseLeave: () => setIsHoveringOperations(false, {
+        // Delay 500ms for better user experience
+        ms: 500
+      })
+    }, expandNode, editNode, copyNode);
+  };
+  const renderEllipsis = (canEllipsis) => [canEllipsis && !expanded && /* @__PURE__ */ createElement("span", {
+    "aria-hidden": true,
+    key: "ellipsis"
+  }, ELLIPSIS_STR), ellipsisConfig.suffix];
+  return /* @__PURE__ */ createElement(es_default, {
+    onResize,
+    disabled: !mergedEnableEllipsis
+  }, (resizeRef) => /* @__PURE__ */ createElement(EllipsisTooltip_default, {
+    tooltipProps,
+    enableEllipsis: mergedEnableEllipsis,
+    isEllipsis: isMergedEllipsis,
+    disabled: isHoveringOperations
+  }, /* @__PURE__ */ createElement(InternalTypography, {
+    onMouseEnter: (e) => {
+      isHoveringTypographyRef.current = true;
+      measureNativeEllipsis();
+      onMouseEnter?.(e);
+    },
+    onMouseLeave: (e) => {
+      isHoveringTypographyRef.current = false;
+      onMouseLeave?.(e);
+    },
+    className: clsx({
+      [`${prefixCls}-${type}`]: type,
+      [`${prefixCls}-disabled`]: disabled,
+      [`${prefixCls}-ellipsis`]: enableEllipsis,
+      [`${prefixCls}-ellipsis-single-line`]: cssTextOverflow,
+      [`${prefixCls}-ellipsis-multiple-line`]: cssLineClamp,
+      [`${prefixCls}-link`]: component === "a"
+    }, className),
+    classNames: mergedClassNames,
+    styles: mergedStyles,
+    prefixCls,
+    style: {
+      ...style,
+      WebkitLineClamp: cssLineClamp ? rows : void 0
+    },
+    component,
+    ref: composeRef(resizeRef, typographyRef, ref),
+    direction,
+    onClick: triggerType.includes("text") ? onEditClick : void 0,
+    "aria-label": topAriaLabel?.toString(),
+    title,
+    ...textProps
+  }, /* @__PURE__ */ createElement(EllipsisMeasure, {
+    enableMeasure: mergedEnableEllipsis && !cssEllipsis,
+    text: children,
+    rows,
+    width: ellipsisWidth,
+    onEllipsis: onJsEllipsis,
+    expanded,
+    measureDeps: [placement],
+    miscDeps: [copied, expanded, copyLoading, enableEdit, enableCopy, placement, textLocale].concat(_toConsumableArray(DECORATION_PROPS.map((key) => props[key])))
+  }, (node, canEllipsis) => wrapperDecorations(props, /* @__PURE__ */ createElement(Fragment, null, placement === "start" ? renderOperations(canEllipsis) : null, node.length > 0 && canEllipsis && !expanded && topAriaLabel ? /* @__PURE__ */ createElement("span", {
+    key: "show-content",
+    "aria-hidden": true
+  }, node) : node, renderEllipsis(canEllipsis), placement === "start" ? null : renderOperations(canEllipsis)))))));
+});
+var Base_default = Base;
+
+// ../../node_modules/.pnpm/antd@6.6.1_luxon@3.7.2_moment@2.30.1_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/antd/es/typography/Text.js
+var Text = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    ellipsis,
+    children,
+    ...restProps
+  } = props;
+  const mergedEllipsis = useMemo(() => {
+    if (isPlainObject(ellipsis)) {
+      return omit(ellipsis, ["expandable", "rows"]);
+    }
+    return ellipsis;
+  }, [ellipsis]);
+  if (true) {
+    const warning = devUseWarning("Typography.Text");
+    true ? warning(!isPlainObject(ellipsis) || !("expandable" in ellipsis) && !("rows" in ellipsis), "usage", "`ellipsis` do not support `expandable` or `rows` props.") : void 0;
+  }
+  return /* @__PURE__ */ createElement(Base_default, {
+    ref,
+    ...restProps,
+    ellipsis: mergedEllipsis,
+    component: "span"
+  }, children);
+});
+var Text_default = Text;
+
+// ../ui/dist/client-navigation.js
+function shouldUseClientNavigation(event) {
+  return !event.defaultPrevented && event.button === 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey;
+}
+
+// ../ui/dist/button.js
+var ZlooksButton = moduleDefault2(Button_default);
+function moduleDefault2(value) {
+  return value && typeof value === "object" && "default" in value ? value.default : value;
+}
+
+// ../ui/dist/navigation.js
+function selectZlooksNavigation(input) {
+  return [
+    { key: "gateway:home", label: "\u9996\u9875", href: "/", order: -1 },
+    ...input.navigation
+  ].map((item) => ({
+    ...item,
+    active: item.href === "/" ? input.pathname === "/" : input.pathname === item.href || input.pathname.startsWith(`${item.href}/`)
+  }));
+}
+
+// ../ui/dist/shell-provider.js
+var ShellContext = createContext(void 0);
+function ZlooksShellProvider({ children, initialContext }) {
+  return jsx(ShellContext, { value: initialContext, children });
+}
+function useZlooksNavigation() {
+  const context = useZlooksShellContext();
+  return useMemo(() => selectZlooksNavigation(context), [context]);
+}
+function useZlooksShellContext() {
+  const context = useContext(ShellContext);
+  if (!context)
+    throw new Error("ZlooksShellProvider is required");
+  return context;
+}
+
+// ../ui/dist/theme-internal.js
+var zlooksUserAccessComponents = deepFreeze({
+  Button: {
+    textActiveBg: "transparent",
+    textHoverBg: "transparent"
+  }
+});
+
+// ../ui/dist/shell.js
+var Avatar2 = moduleDefault3(Avatar_default);
+var ConfigProvider2 = moduleDefault3(config_provider_default);
+var Divider = moduleDefault3(divider_default);
+var Empty = moduleDefault3(empty_default);
+var Flex = moduleDefault3(flex_default);
+var Modal = moduleDefault3(Modal_default);
+var Popover = moduleDefault3(popover_default);
+var Space = moduleDefault3(space_default);
+var Text2 = moduleDefault3(Text_default);
+function moduleDefault3(value) {
+  return value && typeof value === "object" && "default" in value ? value.default : value;
+}
+function ZlooksUserAccess({ className, classNames = {}, style, size = "middle", shape = "round", variant = "compact", onNavigate, onLogout }) {
+  const view = useZlooksShellContext().user;
+  const [accountOpen, setAccountOpen] = useState(false);
+  const [loginOpen, setLoginOpen] = useState(false);
+  const { message, modal } = useZlooksApp();
+  const triggerClassName = mergeClassNames("zlooks-user-access-trigger", className, classNames.trigger);
+  const avatarClassName = mergeClassNames("zlooks-user-access-avatar", classNames.avatar);
+  const labelClassName = mergeClassNames("zlooks-user-access-label", classNames.label);
+  const avatarOnly = variant === "avatar";
+  const triggerAvatarSize = resolveTriggerAvatarSize(size, avatarOnly);
+  const triggerShape = avatarOnly ? "circle" : shape;
+  const triggerAvatarShape = avatarOnly ? "circle" : "square";
+  const triggerStyle = avatarOnly ? {
+    height: triggerAvatarSize,
+    minWidth: triggerAvatarSize,
+    padding: 0,
+    width: triggerAvatarSize,
+    ...style
+  } : style;
+  async function logout(logoutHref, close) {
+    try {
+      await onLogout(logoutHref);
+      close();
+      setAccountOpen(false);
+    } catch (cause) {
+      if (!isRequestError(cause))
+        void message.error("\u9000\u51FA\u767B\u5F55\u5931\u8D25");
+    }
+  }
+  function confirmLogout(logoutHref) {
+    modal.confirm({
+      title: "\u786E\u8BA4\u9000\u51FA\u767B\u5F55\uFF1F",
+      content: "\u9000\u51FA\u540E\uFF0C\u9700\u8981\u91CD\u65B0\u767B\u5F55\u624D\u80FD\u8BBF\u95EE\u4E2A\u4EBA\u8D26\u6237\u3002",
+      okText: "\u9000\u51FA\u767B\u5F55",
+      okButtonProps: { danger: true },
+      cancelText: "\u53D6\u6D88",
+      onOk(close) {
+        void logout(logoutHref, close);
+      }
+    });
+  }
+  function navigate(event, href, close) {
+    if (!onNavigate || !shouldUseClientNavigation(event))
+      return;
+    event.preventDefault();
+    close();
+    onNavigate(href);
+  }
+  if (view.status === "unavailable") {
+    return jsx(UserAccessTheme, { children: jsx(ZlooksButton, { "aria-label": "\u8D26\u6237\u670D\u52A1\u6682\u4E0D\u53EF\u7528", className: triggerClassName, disabled: true, shape: triggerShape, size, style: triggerStyle, type: "text", children: jsxs(Space, { align: "center", size: 6, children: [jsx(Avatar2, { className: avatarClassName, shape: triggerAvatarShape, size: triggerAvatarSize, style: {
+      background: "var(--ant-color-fill-secondary)",
+      border: avatarOnly ? "none" : void 0,
+      borderRadius: avatarOnly ? "50%" : 9,
+      boxShadow: avatarOnly ? "none" : void 0,
+      color: "var(--ant-color-text-tertiary)",
+      fontSize: 12,
+      fontWeight: 750
+    }, children: "Z" }), variant === "compact" ? jsx(Text2, { type: "secondary", children: "\u6682\u4E0D\u53EF\u7528" }) : null] }) }) });
+  }
+  if (view.status === "authenticated") {
+    return jsx(UserAccessTheme, { children: jsx(Popover, { arrow: false, destroyOnHidden: true, onOpenChange: setAccountOpen, open: accountOpen, placement: "bottomRight", styles: {
+      container: {
+        border: "1px solid var(--ant-color-border-secondary)",
+        borderRadius: 16,
+        boxShadow: "0 18px 48px rgb(15 23 42 / 14%)",
+        overflow: "hidden",
+        padding: 0
+      },
+      content: {
+        maxWidth: "calc(100vw - 32px)",
+        width: 280
+      }
+    }, trigger: "click", content: jsxs(Flex, { "aria-label": "\u8D26\u6237\u4FE1\u606F", className: classNames.popup, role: "dialog", style: {
+      background: "var(--ant-color-bg-elevated)"
+    }, vertical: true, children: [jsxs(Flex, { align: "center", gap: 12, style: {
+      background: [
+        "linear-gradient(color-mix(in srgb, var(--ant-color-fill-quaternary) 48%, transparent) 1px, transparent 1px)",
+        "linear-gradient(90deg, color-mix(in srgb, var(--ant-color-fill-quaternary) 48%, transparent) 1px, transparent 1px)",
+        "var(--ant-color-bg-elevated)"
+      ].join(", "),
+      backgroundSize: "28px 28px",
+      padding: 16
+    }, children: [jsx(Avatar2, { className: avatarClassName, shape: "square", size: 44, src: view.user.avatarUrl, style: {
+      background: "var(--ant-color-text)",
+      borderRadius: 12,
+      color: "var(--ant-color-bg-container)",
+      fontSize: 16,
+      fontWeight: 700
+    }, children: view.user.avatarText }), jsxs(Flex, { style: { flex: 1, minWidth: 0 }, vertical: true, children: [jsx(Text2, { strong: true, ellipsis: true, style: { fontSize: 15, lineHeight: 1.4 }, children: view.user.label }), view.user.secondary ? jsx(Text2, { ellipsis: { tooltip: view.user.secondary }, style: { display: "block" }, type: "secondary", children: view.user.secondary }) : null] }), jsx("span", { "aria-label": "\u5DF2\u767B\u5F55", role: "status", style: {
+      background: "var(--ant-color-success)",
+      borderRadius: 999,
+      boxShadow: "0 0 0 3px var(--ant-color-success-bg)",
+      flex: "0 0 auto",
+      height: 7,
+      width: 7
+    } })] }), jsx(Divider, { style: { margin: 0 } }), jsxs(Flex, { gap: 2, style: { padding: 8 }, vertical: true, children: [jsx(ZlooksButton, { block: true, href: view.accountHref, size: "large", style: {
+      fontWeight: 600,
+      height: 44,
+      paddingInline: 12
+    }, type: "text", onClick: (event) => navigate(event, view.accountHref, () => setAccountOpen(false)), children: jsxs(Flex, { justify: "space-between", style: { width: "100%" }, children: [jsx("span", { children: "\u4E2A\u4EBA\u8D44\u6599" }), jsx(Text2, { "aria-hidden": "true", type: "secondary", children: "\u2192" })] }) }), jsx(ZlooksButton, { block: true, danger: true, size: "large", style: { height: 44, justifyContent: "flex-start", paddingInline: 12 }, type: "text", onClick: () => confirmLogout(view.logoutHref), children: "\u9000\u51FA\u767B\u5F55" })] })] }), children: jsx(ZlooksButton, { "aria-expanded": accountOpen, "aria-haspopup": "dialog", "aria-label": `\u6253\u5F00${view.user.label}\u7684\u8D26\u6237\u4FE1\u606F`, className: triggerClassName, shape: triggerShape, size, style: triggerStyle, type: "text", children: jsxs(Space, { align: "center", size: 6, children: [jsx(Avatar2, { className: avatarClassName, shape: triggerAvatarShape, size: triggerAvatarSize, src: view.user.avatarUrl, style: {
+      background: avatarOnly ? "var(--ant-color-fill-secondary)" : "var(--ant-color-text)",
+      border: avatarOnly ? "none" : void 0,
+      borderRadius: avatarOnly ? "50%" : 9,
+      boxShadow: avatarOnly ? "none" : void 0,
+      color: avatarOnly ? "var(--ant-color-text)" : "var(--ant-color-bg-container)",
+      fontSize: 12,
+      fontWeight: 700
+    }, children: view.user.avatarText }), variant === "compact" ? jsx(Text2, { className: labelClassName, ellipsis: true, style: { fontSize: 13, fontWeight: 650, maxWidth: 120 }, children: view.user.label }) : null] }) }) }) });
+  }
+  return jsxs(UserAccessTheme, { children: [jsx(ZlooksButton, { "aria-expanded": loginOpen, "aria-haspopup": "dialog", "aria-label": "\u767B\u5F55", className: triggerClassName, shape: triggerShape, size, style: triggerStyle, type: "text", onClick: () => setLoginOpen(true), children: jsxs(Space, { align: "center", size: 6, children: [jsx(Avatar2, { className: avatarClassName, shape: triggerAvatarShape, size: triggerAvatarSize, style: {
+    background: "var(--ant-color-primary-bg)",
+    border: avatarOnly ? "none" : "1px solid var(--ant-color-primary-border)",
+    borderRadius: avatarOnly ? "50%" : 9,
+    boxShadow: avatarOnly ? "none" : void 0,
+    color: "var(--ant-color-primary)",
+    fontSize: 12,
+    fontWeight: 750
+  }, children: "Z" }), variant === "compact" ? jsx(Text2, { className: labelClassName, style: { fontSize: 13, fontWeight: 650 }, children: "\u767B\u5F55" }) : null] }) }), jsx(Modal, { centered: true, destroyOnHidden: true, footer: null, open: loginOpen, rootClassName: mergeClassNames("zlooks-user-access-modal", classNames.popup), styles: {
+    body: { paddingTop: 4 },
+    container: {
+      border: "1px solid var(--ant-color-border-secondary)",
+      borderRadius: 22,
+      boxShadow: "0 28px 80px rgb(15 23 42 / 18%)",
+      overflow: "hidden",
+      padding: 24
+    },
+    header: { marginBottom: 22 }
+  }, title: jsxs(Space, { align: "center", size: "middle", children: [jsx(Avatar2, { shape: "square", size: 44, style: {
+    background: "var(--ant-color-text)",
+    borderRadius: 12,
+    color: "var(--ant-color-bg-container)",
+    fontWeight: 750
+  }, children: "Z" }), jsxs(Flex, { vertical: true, children: [jsx(Text2, { strong: true, style: { fontSize: 17 }, children: "\u6B22\u8FCE\u56DE\u6765" }), jsx(Text2, { type: "secondary", children: "\u9009\u62E9\u4E00\u79CD\u65B9\u5F0F\u7EE7\u7EED" })] })] }), width: 480, onCancel: () => setLoginOpen(false), children: jsxs(Flex, { gap: 12, vertical: true, children: [view.loginMethods.length === 0 ? jsx(Empty, { description: "\u6682\u65F6\u65E0\u6CD5\u767B\u5F55\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5", image: Empty.PRESENTED_IMAGE_SIMPLE, style: { paddingBlock: 24 } }) : view.loginMethods.map((method, index) => jsx(ZlooksButton, { block: true, href: method.href, onClick: (event) => navigate(event, method.href, () => setLoginOpen(false)), style: {
+    height: "auto",
+    minHeight: 72,
+    padding: "10px 14px",
+    textAlign: "left"
+  }, children: jsxs(Flex, { align: "center", gap: 14, justify: "space-between", style: { width: "100%" }, children: [jsxs(Flex, { align: "center", gap: 12, style: { minWidth: 0 }, children: [jsx(Avatar2, { shape: "square", size: 40, style: {
+    background: "var(--ant-color-primary-bg)",
+    borderRadius: 11,
+    color: "var(--ant-color-primary)",
+    fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+    fontSize: 11,
+    fontWeight: 700
+  }, children: String(index + 1).padStart(2, "0") }), jsxs(Flex, { style: { minWidth: 0 }, vertical: true, children: [jsx(Text2, { strong: true, children: method.label }), jsx(Text2, { ellipsis: true, type: "secondary", children: "\u7EE7\u7EED\u8BBF\u95EE\u4F60\u7684\u4E2A\u4EBA\u7A7A\u95F4" })] })] }), jsx(Text2, { "aria-hidden": "true", style: { color: "var(--ant-color-primary)" }, children: "\u2192" })] }) }, method.id)), jsx(Text2, { style: { fontSize: 12, marginTop: 6, textAlign: "center" }, type: "secondary", children: "\u767B\u5F55\u4FE1\u606F\u4EC5\u7528\u4E8E\u8BC6\u522B\u4F60\u7684\u8D26\u6237" })] }) })] });
+}
+function UserAccessTheme({ children }) {
+  const { mode } = useZlooksTheme();
+  const { resolvedMode, resolvedTheme } = useZlooksThemeRuntime(mode);
+  const userAccessTheme = useMemo(() => ({
+    ...resolvedTheme,
+    cssVar: { key: `zlooks-user-access-${resolvedMode}` },
+    components: {
+      ...resolvedTheme.components,
+      Button: {
+        ...resolvedTheme.components?.Button,
+        ...zlooksUserAccessComponents.Button
+      }
+    }
+  }), [resolvedMode, resolvedTheme]);
+  return jsx(ConfigProvider2, { theme: userAccessTheme, children });
+}
+function mergeClassNames(...values) {
+  return values.filter(Boolean).join(" ");
+}
+function resolveTriggerAvatarSize(size, avatarOnly) {
+  if (avatarOnly && size === "small")
+    return 32;
+  if (avatarOnly && size === "large")
+    return 48;
+  if (avatarOnly)
+    return 40;
+  if (size === "small")
+    return 20;
+  if (size === "large")
+    return 28;
+  return 24;
+}
+
+// ../ui/dist/site-config.js
+var SitePresentationContext = createContext(void 0);
+function ZlooksSiteConfigProvider({ children, initialConfig }) {
+  return jsx(SitePresentationContext, { value: initialConfig, children });
+}
+function useSitePresentation() {
+  return useSitePresentationSnapshot().value;
+}
+function useSitePresentationSnapshot() {
+  const snapshot = useContext(SitePresentationContext);
+  if (!snapshot)
+    throw new Error("ZlooksSiteConfigProvider is required");
+  return snapshot;
+}
+
+// src/plugin/page-frame.module.css
+var page_frame_default = {
+  page: "page_frame_page",
+  headerWrap: "page_frame_headerWrap",
+  header: "page_frame_header",
+  brand: "page_frame_brand",
+  brandMark: "page_frame_brandMark",
+  brandLogo: "page_frame_brandLogo",
+  navigation: "page_frame_navigation",
+  actions: "page_frame_actions",
+  content: "page_frame_content",
+  footer: "page_frame_footer"
+};
+
+// src/plugin/page-frame.tsx
+function PasswordPageFrame({
+  children,
+  shell,
+  site
+}) {
+  return /* @__PURE__ */ jsx(ZlooksUiProvider, { children: /* @__PURE__ */ jsx(ZlooksShellProvider, { initialContext: shell, children: /* @__PURE__ */ jsx(ZlooksSiteConfigProvider, { initialConfig: site, children: /* @__PURE__ */ jsx(FrameContent, { children }) }) }) });
+}
+function FrameContent({ children }) {
+  const navigation = useZlooksNavigation();
+  const site = useSitePresentation();
+  const request = useRequest();
+  const rscNavigation = useRscNavigation();
+  async function logout(href) {
+    await request(href, { method: "POST", credentials: "same-origin" }, {
+      errorMessage: "\u9000\u51FA\u767B\u5F55\u5931\u8D25"
+    });
+    rscNavigation.refresh();
+  }
+  return /* @__PURE__ */ jsxs("div", { className: page_frame_default.page, "data-shared-page-frame": true, children: [
+    /* @__PURE__ */ jsx("div", { className: page_frame_default.headerWrap, children: /* @__PURE__ */ jsxs("header", { className: page_frame_default.header, children: [
+      /* @__PURE__ */ jsxs(RscLink, { className: page_frame_default.brand, href: site.identity.homeHref, children: [
+        site.identity.logoUrl ? /* @__PURE__ */ jsx("img", { alt: "", className: page_frame_default.brandLogo, src: site.identity.logoUrl }) : /* @__PURE__ */ jsx("span", { className: page_frame_default.brandMark, "aria-hidden": "true", children: "Z" }),
+        /* @__PURE__ */ jsx("span", { children: site.identity.name })
+      ] }),
+      /* @__PURE__ */ jsx("nav", { "aria-label": "\u4E3B\u5BFC\u822A", className: page_frame_default.navigation, children: navigation.map((item) => /* @__PURE__ */ jsx(RscLink, { "aria-current": item.active ? "page" : void 0, href: item.href, children: item.label }, item.key)) }),
+      /* @__PURE__ */ jsx("div", { className: page_frame_default.actions, children: /* @__PURE__ */ jsx(
+        ZlooksUserAccess,
+        {
+          size: "middle",
+          shape: "round",
+          variant: "avatar",
+          onLogout: logout,
+          onNavigate: rscNavigation.push
+        }
+      ) })
+    ] }) }),
+    /* @__PURE__ */ jsx("main", { className: page_frame_default.content, children }),
+    /* @__PURE__ */ jsxs("footer", { className: page_frame_default.footer, children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("strong", { children: site.identity.name }),
+        /* @__PURE__ */ jsx("span", { children: "\u4FDD\u6301\u597D\u5947\uFF0C\u8BA4\u771F\u751F\u6D3B\u3002" })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        site.legal.registrations.map((registration) => registration.verificationUrl ? /* @__PURE__ */ jsx(RscLink, { href: registration.verificationUrl, children: registration.number }, registration.id) : /* @__PURE__ */ jsx("span", { children: registration.number }, registration.id)),
+        site.legal.copyright ? /* @__PURE__ */ jsx("small", { children: site.legal.copyright }) : null
+      ] })
+    ] })
+  ] });
+}
+export {
+  PasswordPageFrame as default
+};