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

package/.hile-rsc/build-mtsn68qv-a841a566/client-browser/src-plugin-password-form-3bd63d69e5-G5UQAB5W.js

@@ -0,0 +1,4494 @@
+"use client";
+import {
+  AntdIconLight_default,
+  App_default,
+  Button_default,
+  CSSMotionList_default,
+  CheckCircleFilled_default,
+  CloseCircleFilled_default,
+  Compact_default,
+  ConfigContext,
+  DisabledContextProvider,
+  DisabledContext_default,
+  ExclamationCircleFilled_default,
+  FieldContext_default,
+  Field_default,
+  FormContext,
+  FormItemInputContext,
+  FormItemPrefixContext,
+  FormProvider,
+  Fragment,
+  Input_default,
+  ListContext_default,
+  List_default,
+  LoadingOutlined_default,
+  NoFormStyle,
+  NoStyleItemContext,
+  RscLink,
+  SizeContext_default,
+  TextArea_default,
+  USER_SESSION_COOKIE,
+  VariantContext,
+  __commonJS,
+  __toESM,
+  _toConsumableArray,
+  browserApiDispatchResponseSchema,
+  browserApiResponseSchema,
+  cloneElement,
+  clsx,
+  collapse_default,
+  composeRef,
+  createContext,
+  createElement,
+  devUseWarning,
+  en_US_default,
+  es_default,
+  es_default3 as es_default2,
+  external_exports,
+  fallbackProp,
+  forwardRef,
+  genCssVar,
+  genFocusOutline,
+  genFocusStyle,
+  genStyleHooks,
+  genSubStyleComponent,
+  get,
+  getDOM,
+  getMergedStatus,
+  getNodeRef,
+  initComponentToken,
+  initInputToken,
+  isBrowserApiFailure,
+  isFunction,
+  isNonNullable,
+  isNumber,
+  isPlainObject,
+  isReactRenderable,
+  isString,
+  isValidElement,
+  isVisible_default,
+  jsx,
+  jsxs,
+  memo,
+  merge,
+  motion_default,
+  omit,
+  pickAttrs,
+  raf_default,
+  resetComponent,
+  responsiveArray,
+  responsiveArrayReversed,
+  set,
+  space_default,
+  style_default,
+  supportRef,
+  textEllipsis,
+  toArray,
+  tooltip_default,
+  unit,
+  useApp_default,
+  useBreakpoint_default,
+  useCSSVarCls_default,
+  useColStyle,
+  useCompactItemContext,
+  useComponentConfig,
+  useContext,
+  useControlledState,
+  useDelayState,
+  useDevWarning,
+  useEffect,
+  useEvent_default,
+  useForm_default,
+  useId_default,
+  useImperativeHandle,
+  useLayoutEffect_default,
+  useLocale_default,
+  useMemo,
+  useMergeSemantic,
+  useOrientation,
+  useRef,
+  useRemovePasswordTimeout,
+  useRequest,
+  useRowStyle,
+  useRscNavigation,
+  useSemanticRootStyle,
+  useSize_default,
+  useState,
+  useState_default,
+  useVariants_default,
+  useWatch_default,
+  validateMessagesContext_default,
+  version,
+  warning_default,
+  zoomIn
+} from "./chunks/chunk-CZF5VGOJ.js";
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/SearchOutlined.js
+var require_SearchOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/SearchOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var SearchOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M909.6 854.5L649.9 594.8C690.2 542.7 712 479 712 412c0-80.2-31.3-155.4-87.9-212.1-56.6-56.7-132-87.9-212.1-87.9s-155.5 31.3-212.1 87.9C143.2 256.5 112 331.8 112 412c0 80.1 31.3 155.5 87.9 212.1C256.5 680.8 331.8 712 412 712c67 0 130.6-21.8 182.7-62l259.7 259.6a8.2 8.2 0 0011.6 0l43.6-43.5a8.2 8.2 0 000-11.6zM570.4 570.4C528 612.7 471.8 636 412 636s-116-23.3-158.4-65.6C211.3 528 188 471.8 188 412s23.3-116.1 65.6-158.4C296 211.3 352.2 188 412 188s116.1 23.2 158.4 65.6S636 352.2 636 412s-23.3 116.1-65.6 158.4z" } }] }, "name": "search", "theme": "outlined" };
+    exports.default = SearchOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/QuestionCircleOutlined.js
+var require_QuestionCircleOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/QuestionCircleOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var QuestionCircleOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" } }, { "tag": "path", "attrs": { "d": "M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420v7.6c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V420c0-44.1 43.1-80 96-80s96 35.9 96 80c0 31.1-22 59.6-56.1 72.7-21.2 8.1-39.2 22.3-52.1 40.9-13.1 19-19.9 41.8-19.9 64.9V620c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-22.7a48.3 48.3 0 0130.9-44.8c59-22.7 97.1-74.7 97.1-132.5.1-39.3-17.1-76-48.3-103.3zM472 732a40 40 0 1080 0 40 40 0 10-80 0z" } }] }, "name": "question-circle", "theme": "outlined" };
+    exports.default = QuestionCircleOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EyeInvisibleOutlined.js
+var require_EyeInvisibleOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EyeInvisibleOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EyeInvisibleOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M942.2 486.2Q889.47 375.11 816.7 305l-50.88 50.88C807.31 395.53 843.45 447.4 874.7 512 791.5 684.2 673.4 766 512 766q-72.67 0-133.87-22.38L323 798.75Q408 838 512 838q288.3 0 430.2-300.3a60.29 60.29 0 000-51.5zm-63.57-320.64L836 122.88a8 8 0 00-11.32 0L715.31 232.2Q624.86 186 512 186q-288.3 0-430.2 300.3a60.3 60.3 0 000 51.5q56.69 119.4 136.5 191.41L112.48 835a8 8 0 000 11.31L155.17 889a8 8 0 0011.31 0l712.15-712.12a8 8 0 000-11.32zM149.3 512C232.6 339.8 350.7 258 512 258c54.54 0 104.13 9.36 149.12 28.39l-70.3 70.3a176 176 0 00-238.13 238.13l-83.42 83.42C223.1 637.49 183.3 582.28 149.3 512zm246.7 0a112.11 112.11 0 01146.2-106.69L401.31 546.2A112 112 0 01396 512z" } }, { "tag": "path", "attrs": { "d": "M508 624c-3.46 0-6.87-.16-10.25-.47l-52.82 52.82a176.09 176.09 0 00227.42-227.42l-52.82 52.82c.31 3.38.47 6.79.47 10.25a111.94 111.94 0 01-112 112z" } }] }, "name": "eye-invisible", "theme": "outlined" };
+    exports.default = EyeInvisibleOutlined2;
+  }
+});
+
+// ../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EyeOutlined.js
+var require_EyeOutlined = __commonJS({
+  "../../node_modules/.pnpm/@ant-design+icons-svg@4.5.0/node_modules/@ant-design/icons-svg/lib/asn/EyeOutlined.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EyeOutlined2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M942.2 486.2C847.4 286.5 704.1 186 512 186c-192.2 0-335.4 100.5-430.2 300.3a60.3 60.3 0 000 51.5C176.6 737.5 319.9 838 512 838c192.2 0 335.4-100.5 430.2-300.3 7.7-16.2 7.7-35 0-51.5zM512 766c-161.3 0-279.4-81.8-362.7-254C232.6 339.8 350.7 258 512 258c161.3 0 279.4 81.8 362.7 254C791.5 684.2 673.4 766 512 766zm-4-430c-97.2 0-176 78.8-176 176s78.8 176 176 176 176-78.8 176-176-78.8-176-176-176zm0 288c-61.9 0-112-50.1-112-112s50.1-112 112-112 112 50.1 112 112-50.1 112-112 112z" } }] }, "name": "eye", "theme": "outlined" };
+    exports.default = EyeOutlined2;
+  }
+});
+
+// ../user-shared/dist/identity.js
+var USER_SERVICE_NAMESPACE = "cn.zlooks.user.server";
+
+// ../user-shared/dist/events/snapshots.js
+var userSessionRevocationReasonSchema = external_exports.enum([
+  "logout",
+  "user-request",
+  "family-limit",
+  "credential-recovery"
+]);
+var displayNameSchema = external_exports.string().refine((value) => value === value.trim().normalize("NFKC"), "Display name must be normalized").refine((value) => Array.from(value).length >= 1 && Array.from(value).length <= 160, "Display name must contain 1 to 160 Unicode code points");
+var bioSchema = external_exports.string().refine((value) => value === value.trim().normalize("NFKC"), "Bio must be normalized").refine((value) => Array.from(value).length >= 1 && Array.from(value).length <= 500, "Bio must contain 1 to 500 Unicode code points");
+var httpUrlSchema = external_exports.url().max(2048).refine((value) => {
+  const protocol = new URL(value).protocol;
+  return protocol === "http:" || protocol === "https:";
+}, "URL must use HTTP or HTTPS").refine((value) => value === new URL(value).toString(), "URL must be canonical");
+var emailSchema = external_exports.email().max(320).refine((value) => value === value.toLocaleLowerCase("en-US"), "Email must be lowercase");
+var userEventSnapshotSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  displayName: displayNameSchema.nullable(),
+  avatar: httpUrlSchema.nullable(),
+  homepage: httpUrlSchema.nullable(),
+  bio: bioSchema.nullable(),
+  email: emailSchema.nullable(),
+  emailVerified: external_exports.boolean(),
+  status: external_exports.enum(["active", "disabled", "deleted"]),
+  createdAt: external_exports.iso.datetime({ offset: true }),
+  updatedAt: external_exports.iso.datetime({ offset: true }),
+  version: external_exports.number().int().positive()
+}).superRefine((user, context) => {
+  if (user.emailVerified && user.email === null) {
+    context.addIssue({
+      code: "custom",
+      message: "A verified user snapshot must include its email",
+      path: ["email"]
+    });
+  }
+  if (Date.parse(user.updatedAt) < Date.parse(user.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "User updated time must not precede creation time",
+      path: ["updatedAt"]
+    });
+  }
+}).readonly();
+var userSessionFamilyEventSnapshotSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  userId: external_exports.uuid(),
+  createdAt: external_exports.iso.datetime({ offset: true }),
+  expiresAt: external_exports.iso.datetime({ offset: true }),
+  lastSeenAt: external_exports.iso.datetime({ offset: true }),
+  revokedAt: external_exports.iso.datetime({ offset: true }).nullable(),
+  revokeReason: userSessionRevocationReasonSchema.nullable()
+}).superRefine((session, context) => {
+  const createdAt = Date.parse(session.createdAt);
+  if (session.revokedAt === null !== (session.revokeReason === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "Session revocation time and reason must be present together",
+      path: ["revokedAt"]
+    });
+  }
+  if (Date.parse(session.expiresAt) <= createdAt) {
+    context.addIssue({
+      code: "custom",
+      message: "Session expiry must follow creation time",
+      path: ["expiresAt"]
+    });
+  }
+  const lastSeenAt = Date.parse(session.lastSeenAt);
+  if (lastSeenAt < createdAt || lastSeenAt > Date.parse(session.expiresAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Session last-seen time must fall within its lifetime",
+      path: ["lastSeenAt"]
+    });
+  }
+  if (session.revokedAt !== null && Date.parse(session.revokedAt) < createdAt) {
+    context.addIssue({
+      code: "custom",
+      message: "Session revoked time must not precede creation time",
+      path: ["revokedAt"]
+    });
+  }
+}).readonly();
+
+// ../event-bus/dist/index.js
+var eventType = external_exports.string().max(256).regex(/^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9-]*)+\.v[1-9][0-9]*$/);
+var serviceNamespace = external_exports.string().max(256).regex(/^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)+$/);
+var aggregateType = external_exports.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
+var aggregateId = external_exports.string().trim().min(1).max(256);
+var eventEnvelopeSchema = external_exports.strictObject({
+  protocol: external_exports.literal("zlooks.event"),
+  protocolVersion: external_exports.literal(1),
+  eventId: external_exports.uuid(),
+  type: eventType,
+  producer: serviceNamespace,
+  aggregate: external_exports.strictObject({
+    type: aggregateType,
+    id: aggregateId
+  }).readonly(),
+  occurredAt: external_exports.iso.datetime({ offset: true }),
+  data: external_exports.unknown()
+}).readonly();
+function defineEvent(type, dataSchema5) {
+  const parsedType = eventType.parse(type);
+  return Object.freeze({
+    type: parsedType,
+    parse(value) {
+      const envelope = eventEnvelopeSchema.parse(value);
+      if (envelope.type !== parsedType) {
+        throw new TypeError(`Expected event type ${parsedType}`);
+      }
+      return Object.freeze({
+        ...envelope,
+        type: parsedType,
+        aggregate: Object.freeze({ ...envelope.aggregate }),
+        data: dataSchema5.parse(envelope.data)
+      });
+    }
+  });
+}
+
+// ../user-shared/dist/events/definition.js
+function defineUserEvent(type, aggregateType2, dataSchema5, aggregateId2) {
+  const base = defineEvent(type, dataSchema5);
+  return Object.freeze({
+    type: base.type,
+    parse(input) {
+      const event = base.parse(input);
+      if (event.producer !== USER_SERVICE_NAMESPACE) {
+        throw new TypeError(`Expected event producer ${USER_SERVICE_NAMESPACE}`);
+      }
+      if (event.aggregate.type !== aggregateType2 || event.aggregate.id !== aggregateId2(event.data)) {
+        throw new TypeError(`${type} aggregate does not identify its event data`);
+      }
+      return event;
+    }
+  });
+}
+
+// ../user-shared/dist/events/user-registered.js
+var USER_REGISTERED_EVENT_TYPE = "cn.zlooks.user.registered.v1";
+var userRegisteredDataSchema = external_exports.strictObject({
+  user: userEventSnapshotSchema
+}).refine((data) => data.user.status === "active", {
+  message: "A registered user snapshot must be active",
+  path: ["user", "status"]
+}).readonly();
+var userRegisteredEvent = defineUserEvent(USER_REGISTERED_EVENT_TYPE, "user", userRegisteredDataSchema, (data) => data.user.id);
+
+// ../user-shared/dist/events/user-email-verified.js
+var USER_EMAIL_VERIFIED_EVENT_TYPE = "cn.zlooks.user.email-verified.v1";
+var dataSchema = external_exports.strictObject({ user: userEventSnapshotSchema }).refine((data) => data.user.email !== null && data.user.emailVerified, {
+  message: "An email-verified event must contain a verified email snapshot",
+  path: ["user", "emailVerified"]
+}).readonly();
+var userEmailVerifiedEvent = defineUserEvent(USER_EMAIL_VERIFIED_EVENT_TYPE, "user", dataSchema, (data) => data.user.id);
+
+// ../user-shared/dist/events/user-profile-updated.js
+var USER_PROFILE_UPDATED_EVENT_TYPE = "cn.zlooks.user.profile-updated.v1";
+var userProfileFieldSchema = external_exports.enum(["displayName", "avatar", "homepage", "bio"]);
+var dataSchema2 = external_exports.strictObject({
+  user: userEventSnapshotSchema,
+  changedFields: external_exports.array(userProfileFieldSchema).min(1).max(4).refine((fields) => new Set(fields).size === fields.length, "Profile fields must be unique").readonly()
+}).readonly();
+var userProfileUpdatedEvent = defineUserEvent(USER_PROFILE_UPDATED_EVENT_TYPE, "user", dataSchema2, (data) => data.user.id);
+
+// ../user-shared/dist/events/user-session-created.js
+var USER_SESSION_CREATED_EVENT_TYPE = "cn.zlooks.user.session-created.v1";
+var dataSchema3 = external_exports.strictObject({
+  user: userEventSnapshotSchema,
+  sessionFamily: userSessionFamilyEventSnapshotSchema,
+  intent: external_exports.enum(["login", "registration", "recovery"])
+}).superRefine((data, context) => {
+  if (data.sessionFamily.userId !== data.user.id) {
+    context.addIssue({
+      code: "custom",
+      message: "Session and user snapshots must identify the same user",
+      path: ["sessionFamily", "userId"]
+    });
+  }
+  if (data.sessionFamily.revokedAt !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "A created session snapshot must be active",
+      path: ["sessionFamily", "revokedAt"]
+    });
+  }
+  if (data.user.status !== "active") {
+    context.addIssue({
+      code: "custom",
+      message: "A session-created event must contain an active user snapshot",
+      path: ["user", "status"]
+    });
+  }
+}).readonly();
+var userSessionCreatedEvent = defineUserEvent(USER_SESSION_CREATED_EVENT_TYPE, "session-family", dataSchema3, (data) => data.sessionFamily.id);
+
+// ../user-shared/dist/events/user-session-revoked.js
+var USER_SESSION_REVOKED_EVENT_TYPE = "cn.zlooks.user.session-revoked.v1";
+var dataSchema4 = external_exports.strictObject({
+  user: userEventSnapshotSchema,
+  sessionFamily: userSessionFamilyEventSnapshotSchema
+}).superRefine((data, context) => {
+  if (data.sessionFamily.userId !== data.user.id) {
+    context.addIssue({
+      code: "custom",
+      message: "Session and user snapshots must identify the same user",
+      path: ["sessionFamily", "userId"]
+    });
+  }
+  if (data.sessionFamily.revokedAt === null) {
+    context.addIssue({
+      code: "custom",
+      message: "A revoked session snapshot must include its revocation",
+      path: ["sessionFamily", "revokedAt"]
+    });
+  }
+}).readonly();
+var userSessionRevokedEvent = defineUserEvent(USER_SESSION_REVOKED_EVENT_TYPE, "session-family", dataSchema4, (data) => data.sessionFamily.id);
+
+// ../user-shared/dist/index.js
+var USER_BROWSER_API_PUBLIC_ROUTES = Object.freeze([
+  Object.freeze({
+    exact: "/api/auth/methods",
+    methods: Object.freeze(["GET"]),
+    forwardCookieNames: Object.freeze([])
+  }),
+  Object.freeze({
+    exact: "/api/user/shell",
+    methods: Object.freeze(["GET"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  }),
+  Object.freeze({
+    exact: "/api/user",
+    methods: Object.freeze(["GET", "PATCH"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  }),
+  Object.freeze({
+    exact: "/api/user/sessions",
+    methods: Object.freeze(["GET"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  }),
+  Object.freeze({
+    exact: "/api/auth/transactions",
+    methods: Object.freeze(["POST"]),
+    forwardCookieNames: Object.freeze([])
+  }),
+  Object.freeze({
+    prefix: "/api/auth/transactions/",
+    methods: Object.freeze(["POST"]),
+    forwardCookieNames: Object.freeze([])
+  }),
+  Object.freeze({
+    exact: "/api/auth/logout",
+    methods: Object.freeze(["POST"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  }),
+  Object.freeze({
+    exact: "/api/auth/session/refresh",
+    methods: Object.freeze(["POST"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  }),
+  Object.freeze({
+    prefix: "/api/user/sessions/",
+    methods: Object.freeze(["POST"]),
+    forwardCookieNames: Object.freeze([USER_SESSION_COOKIE])
+  })
+]);
+var USER_ACCOUNT_HREF = "/user.account/account";
+var USER_BROWSER_API_ERROR_CODES = Object.freeze({
+  crossOriginRejected: 1001,
+  requestRejected: 1002,
+  authenticationRequired: 1003,
+  sessionExpired: 1004,
+  authenticationDenied: 1005,
+  authenticationPending: 1006,
+  routeNotFound: 1007,
+  accountNotFound: 1008,
+  accountAlreadyExists: 1009,
+  invalidVerificationCode: 1010,
+  verificationRateLimited: 1011,
+  emailDeliveryFailed: 1012,
+  serviceUnavailable: 1013
+});
+var absolutePath = external_exports.string().min(1).max(2048).regex(/^\/(?!\/)[^?#]*$/);
+var userShellViewSchema = external_exports.discriminatedUnion("status", [
+  external_exports.strictObject({
+    status: external_exports.literal("anonymous"),
+    loginMethods: external_exports.array(external_exports.strictObject({
+      id: external_exports.string().min(1).max(128),
+      label: external_exports.string().min(1).max(80),
+      href: absolutePath
+    })).max(64)
+  }),
+  external_exports.strictObject({
+    status: external_exports.literal("authenticated"),
+    user: external_exports.strictObject({
+      label: external_exports.string().min(1).max(160),
+      secondary: external_exports.string().min(1).max(320).optional(),
+      avatarText: external_exports.string().min(1).max(8),
+      avatarUrl: external_exports.url({ protocol: /^https?$/ }).max(2048).optional()
+    }),
+    accountHref: absolutePath,
+    logoutHref: absolutePath
+  })
+]).readonly();
+var sessionCookieSchema = external_exports.discriminatedUnion("action", [
+  external_exports.strictObject({
+    action: external_exports.literal("set"),
+    value: external_exports.string().min(1).max(4096),
+    expiresAt: external_exports.iso.datetime({ offset: true })
+  }),
+  external_exports.strictObject({ action: external_exports.literal("clear") })
+]);
+var userCurrentUserRequestSchema = external_exports.strictObject({}).readonly();
+var userPublicProfileSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  displayName: external_exports.string().trim().min(1).max(160).nullable(),
+  avatar: external_exports.url({ protocol: /^https?$/ }).max(2048).nullable(),
+  homepage: external_exports.url({ protocol: /^https?$/ }).max(2048).nullable().optional(),
+  bio: external_exports.string().trim().min(1).max(500).nullable().optional()
+}).readonly();
+var userCurrentUserSchema = userPublicProfileSchema;
+var userCurrentUserResponseSchema = external_exports.discriminatedUnion("authenticated", [
+  external_exports.strictObject({ authenticated: external_exports.literal(false) }),
+  external_exports.strictObject({
+    authenticated: external_exports.literal(true),
+    user: userCurrentUserSchema
+  })
+]).readonly();
+var userPublicProfilesRequestSchema = external_exports.strictObject({
+  userIds: external_exports.array(external_exports.uuid()).min(1).max(100).refine((userIds) => new Set(userIds).size === userIds.length, { message: "User IDs must be unique" }).readonly()
+}).readonly();
+var userPublicProfilesResponseSchema = external_exports.strictObject({
+  users: external_exports.array(userPublicProfileSchema).max(100).refine((users) => new Set(users.map((user) => user.id)).size === users.length, { message: "Public user profiles must be unique" }).readonly()
+}).readonly();
+var userBrowserApiRequestSchema = external_exports.strictObject({
+  method: external_exports.enum(["GET", "POST", "PATCH"]),
+  path: absolutePath,
+  origin: external_exports.string().max(2048).optional(),
+  clientKey: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  body: external_exports.unknown().optional()
+}).readonly();
+var userBrowserApiProviderRequestSchema = external_exports.strictObject({
+  method: external_exports.enum(["GET", "POST", "PATCH"]),
+  path: absolutePath,
+  origin: external_exports.string().max(2048).optional(),
+  clientKey: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  body: external_exports.unknown().optional()
+}).readonly();
+var userBrowserApiProviderResponseSchema = browserApiDispatchResponseSchema.superRefine((response, context) => {
+  for (const [index, effect] of (response.cookieEffects ?? []).entries()) {
+    if (effect.name === USER_SESSION_COOKIE)
+      continue;
+    context.addIssue({
+      code: "custom",
+      message: "User Browser API may only mutate its declared session cookie",
+      path: ["cookieEffects", index, "name"]
+    });
+  }
+}).readonly();
+var userBrowserApiResponseSchema = external_exports.strictObject({
+  status: external_exports.number().int().min(200).max(599).refine((status) => status < 300 || status >= 400),
+  body: browserApiResponseSchema,
+  sessionCookie: sessionCookieSchema.optional()
+}).superRefine((response, context) => {
+  const httpSucceeded = response.status >= 200 && response.status < 300;
+  if (httpSucceeded === !isBrowserApiFailure(response.body))
+    return;
+  context.addIssue({
+    code: "custom",
+    message: "HTTP status and browser API response code disagree",
+    path: ["body", "code"]
+  });
+}).readonly();
+var userCredentialLifecycleEventSchema = external_exports.strictObject({
+  protocol: external_exports.literal("zlooks.user.credential-lifecycle"),
+  kind: external_exports.enum(["registration", "recovery"]),
+  authenticationTransactionId: external_exports.uuid(),
+  extensionId: external_exports.string().regex(/^[a-z][a-z0-9._-]{0,127}$/),
+  methodId: external_exports.string().regex(/^[a-z][a-z0-9._-]{0,127}$/),
+  subject: external_exports.string().trim().min(1).max(512),
+  email: external_exports.email().max(320),
+  occurredAt: external_exports.iso.datetime({ offset: true })
+}).readonly();
+var userCredentialLifecycleResponseSchema = external_exports.strictObject({
+  acknowledged: external_exports.literal(true)
+}).readonly();
+
+// ../../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/getReactMajorVersionCanDelMe.js
+function getReactMajorVersion() {
+  const majorVersion = Number.parseInt(version.split(".")[0], 10);
+  return majorVersion;
+}
+
+// ../../node_modules/.pnpm/compute-scroll-into-view@3.1.1/node_modules/compute-scroll-into-view/dist/index.js
+var t = (t2) => "object" == typeof t2 && null != t2 && 1 === t2.nodeType;
+var e = (t2, e3) => (!e3 || "hidden" !== t2) && ("visible" !== t2 && "clip" !== t2);
+var n = (t2, n2) => {
+  if (t2.clientHeight < t2.scrollHeight || t2.clientWidth < t2.scrollWidth) {
+    const o3 = getComputedStyle(t2, null);
+    return e(o3.overflowY, n2) || e(o3.overflowX, n2) || ((t3) => {
+      const e3 = ((t4) => {
+        if (!t4.ownerDocument || !t4.ownerDocument.defaultView) return null;
+        try {
+          return t4.ownerDocument.defaultView.frameElement;
+        } catch (t5) {
+          return null;
+        }
+      })(t3);
+      return !!e3 && (e3.clientHeight < t3.scrollHeight || e3.clientWidth < t3.scrollWidth);
+    })(t2);
+  }
+  return false;
+};
+var o = (t2, e3, n2, o3, l2, r2, i, s) => r2 < t2 && i > e3 || r2 > t2 && i < e3 ? 0 : r2 <= t2 && s <= n2 || i >= e3 && s >= n2 ? r2 - t2 - o3 : i > e3 && s < n2 || r2 < t2 && s > n2 ? i - e3 + l2 : 0;
+var l = (t2) => {
+  const e3 = t2.parentElement;
+  return null == e3 ? t2.getRootNode().host || null : e3;
+};
+var r = (e3, r2) => {
+  var i, s, d, h;
+  if ("undefined" == typeof document) return [];
+  const { scrollMode: c, block: f, inline: u, boundary: a, skipOverflowHiddenElements: g } = r2, p = "function" == typeof a ? a : (t2) => t2 !== a;
+  if (!t(e3)) throw new TypeError("Invalid target");
+  const m = document.scrollingElement || document.documentElement, w = [];
+  let W = e3;
+  for (; t(W) && p(W); ) {
+    if (W = l(W), W === m) {
+      w.push(W);
+      break;
+    }
+    null != W && W === document.body && n(W) && !n(document.documentElement) || null != W && n(W, g) && w.push(W);
+  }
+  const b = null != (s = null == (i = window.visualViewport) ? void 0 : i.width) ? s : innerWidth, H = null != (h = null == (d = window.visualViewport) ? void 0 : d.height) ? h : innerHeight, { scrollX: y, scrollY: M } = window, { height: v, width: E, top: x, right: C, bottom: I, left: R } = e3.getBoundingClientRect(), { top: T, right: B, bottom: F, left: V } = ((t2) => {
+    const e4 = window.getComputedStyle(t2);
+    return { top: parseFloat(e4.scrollMarginTop) || 0, right: parseFloat(e4.scrollMarginRight) || 0, bottom: parseFloat(e4.scrollMarginBottom) || 0, left: parseFloat(e4.scrollMarginLeft) || 0 };
+  })(e3);
+  let k = "start" === f || "nearest" === f ? x - T : "end" === f ? I + F : x + v / 2 - T + F, D = "center" === u ? R + E / 2 - V + B : "end" === u ? C + B : R - V;
+  const L = [];
+  for (let t2 = 0; t2 < w.length; t2++) {
+    const e4 = w[t2], { height: l2, width: r3, top: i2, right: s2, bottom: d2, left: h2 } = e4.getBoundingClientRect();
+    if ("if-needed" === c && x >= 0 && R >= 0 && I <= H && C <= b && (e4 === m && !n(e4) || x >= i2 && I <= d2 && R >= h2 && C <= s2)) return L;
+    const a2 = getComputedStyle(e4), g2 = parseInt(a2.borderLeftWidth, 10), p2 = parseInt(a2.borderTopWidth, 10), W2 = parseInt(a2.borderRightWidth, 10), T2 = parseInt(a2.borderBottomWidth, 10);
+    let B2 = 0, F2 = 0;
+    const V2 = "offsetWidth" in e4 ? e4.offsetWidth - e4.clientWidth - g2 - W2 : 0, S = "offsetHeight" in e4 ? e4.offsetHeight - e4.clientHeight - p2 - T2 : 0, X = "offsetWidth" in e4 ? 0 === e4.offsetWidth ? 0 : r3 / e4.offsetWidth : 0, Y = "offsetHeight" in e4 ? 0 === e4.offsetHeight ? 0 : l2 / e4.offsetHeight : 0;
+    if (m === e4) B2 = "start" === f ? k : "end" === f ? k - H : "nearest" === f ? o(M, M + H, H, p2, T2, M + k, M + k + v, v) : k - H / 2, F2 = "start" === u ? D : "center" === u ? D - b / 2 : "end" === u ? D - b : o(y, y + b, b, g2, W2, y + D, y + D + E, E), B2 = Math.max(0, B2 + M), F2 = Math.max(0, F2 + y);
+    else {
+      B2 = "start" === f ? k - i2 - p2 : "end" === f ? k - d2 + T2 + S : "nearest" === f ? o(i2, d2, l2, p2, T2 + S, k, k + v, v) : k - (i2 + l2 / 2) + S / 2, F2 = "start" === u ? D - h2 - g2 : "center" === u ? D - (h2 + r3 / 2) + V2 / 2 : "end" === u ? D - s2 + W2 + V2 : o(h2, s2, r3, g2, W2 + V2, D, D + E, E);
+      const { scrollLeft: t3, scrollTop: n2 } = e4;
+      B2 = 0 === Y ? 0 : Math.max(0, Math.min(n2 + B2 / Y, e4.scrollHeight - l2 / Y + S)), F2 = 0 === X ? 0 : Math.max(0, Math.min(t3 + F2 / X, e4.scrollWidth - r3 / X + V2)), k += n2 - B2, D += t3 - F2;
+    }
+    L.push({ el: e4, top: B2, left: F2 });
+  }
+  return L;
+};
+
+// ../../node_modules/.pnpm/scroll-into-view-if-needed@3.1.0/node_modules/scroll-into-view-if-needed/dist/index.js
+var o2 = (t2) => false === t2 ? { block: "end", inline: "nearest" } : ((t3) => t3 === Object(t3) && 0 !== Object.keys(t3).length)(t2) ? t2 : { block: "start", inline: "nearest" };
+function e2(e3, r2) {
+  if (!e3.isConnected || !((t2) => {
+    let o3 = t2;
+    for (; o3 && o3.parentNode; ) {
+      if (o3.parentNode === document) return true;
+      o3 = o3.parentNode instanceof ShadowRoot ? o3.parentNode.host : o3.parentNode;
+    }
+    return false;
+  })(e3)) return;
+  const n2 = ((t2) => {
+    const o3 = window.getComputedStyle(t2);
+    return { top: parseFloat(o3.scrollMarginTop) || 0, right: parseFloat(o3.scrollMarginRight) || 0, bottom: parseFloat(o3.scrollMarginBottom) || 0, left: parseFloat(o3.scrollMarginLeft) || 0 };
+  })(e3);
+  if (((t2) => "object" == typeof t2 && "function" == typeof t2.behavior)(r2)) return r2.behavior(r(e3, r2));
+  const l2 = "boolean" == typeof r2 || null == r2 ? void 0 : r2.behavior;
+  for (const { el: a, top: i, left: s } of r(e3, o2(r2))) {
+    const t2 = i - n2.top + n2.bottom, o3 = s - n2.left + n2.right;
+    a.scroll({ top: t2, left: o3, behavior: l2 });
+  }
+}
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n2) {
+    for (var e3 = 1; e3 < arguments.length; e3++) {
+      var t2 = arguments[e3];
+      for (var r2 in t2) ({}).hasOwnProperty.call(t2, r2) && (n2[r2] = t2[r2]);
+    }
+    return n2;
+  }, _extends.apply(null, arguments);
+}
+
+// ../../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/app/index.js
+var App = App_default;
+App.useApp = useApp_default;
+var app_default = App;
+
+// ../../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/SearchOutlined.js
+var import_SearchOutlined = __toESM(require_SearchOutlined());
+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 SearchOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends2({}, props, {
+  ref,
+  icon: import_SearchOutlined.default
+}));
+var RefIcon = /* @__PURE__ */ forwardRef(SearchOutlined);
+if (true) {
+  RefIcon.displayName = "SearchOutlined";
+}
+var SearchOutlined_default = RefIcon;
+
+// ../../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/button/index.js
+var button_default = Button_default;
+
+// ../../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/form/util.js
+var formItemNameBlackList = ["parentNode"];
+var defaultItemNamePrefixCls = "form_item";
+function toArray2(candidate) {
+  if (candidate === void 0 || candidate === false) {
+    return [];
+  }
+  return Array.isArray(candidate) ? candidate : [candidate];
+}
+function getFieldId(namePath, formName) {
+  if (!namePath.length) {
+    return void 0;
+  }
+  const mergedId = namePath.join("_");
+  if (formName) {
+    return `${formName}_${mergedId}`;
+  }
+  const isIllegalName = formItemNameBlackList.includes(mergedId);
+  return isIllegalName ? `${defaultItemNamePrefixCls}_${mergedId}` : mergedId;
+}
+function getStatus(errors, warnings, meta, defaultValidateStatus, hasFeedback, validateStatus) {
+  let status = defaultValidateStatus;
+  if (validateStatus !== void 0) {
+    status = validateStatus;
+  } else if (meta.validating) {
+    status = "validating";
+  } else if (errors.length) {
+    status = "error";
+  } else if (warnings.length) {
+    status = "warning";
+  } else if (meta.touched || hasFeedback && meta.validated) {
+    status = "success";
+  }
+  return status;
+}
+
+// ../../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/form/hooks/useForm.js
+function toNamePathStr(name) {
+  const namePath = toArray2(name);
+  return namePath.join("_");
+}
+function getFieldDOMNode(name, wrapForm) {
+  const field = wrapForm.getFieldInstance(name);
+  const fieldDom = getDOM(field);
+  if (fieldDom) {
+    return fieldDom;
+  }
+  const fieldId = getFieldId(toArray2(name), wrapForm.__INTERNAL__.name);
+  if (fieldId) {
+    return document.getElementById(fieldId);
+  }
+}
+function useForm(form) {
+  const [rcForm] = useForm_default();
+  const itemsRef = useRef({});
+  const wrapForm = useMemo(() => form ?? {
+    ...rcForm,
+    __INTERNAL__: {
+      itemRef: (name) => (node) => {
+        const namePathStr = toNamePathStr(name);
+        if (node) {
+          itemsRef.current[namePathStr] = node;
+        } else {
+          delete itemsRef.current[namePathStr];
+        }
+      }
+    },
+    scrollToField: (name, options = {}) => {
+      const {
+        focus,
+        ...restOpt
+      } = options;
+      const node = getFieldDOMNode(name, wrapForm);
+      if (node) {
+        e2(node, {
+          scrollMode: "if-needed",
+          block: "nearest",
+          ...restOpt
+        });
+        if (focus) {
+          wrapForm.focusField(name);
+        }
+      }
+    },
+    focusField: (name) => {
+      const itemRef = wrapForm.getFieldInstance(name);
+      if (isFunction(itemRef?.focus)) {
+        itemRef.focus();
+      } else {
+        getFieldDOMNode(name, wrapForm)?.focus?.();
+      }
+    },
+    getFieldInstance: (name) => {
+      const namePathStr = toNamePathStr(name);
+      return itemsRef.current[namePathStr];
+    }
+  }, [form, rcForm]);
+  return [wrapForm];
+}
+
+// ../../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/grid/RowContext.js
+var RowContext = /* @__PURE__ */ createContext({});
+var RowContext_default = RowContext;
+
+// ../../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/grid/col.js
+function parseFlex(flex) {
+  if (flex === "auto") {
+    return "1 1 auto";
+  }
+  if (isNumber(flex)) {
+    return `${flex} ${flex} auto`;
+  }
+  if (/^\d+(\.\d+)?(px|em|rem|%)$/.test(flex)) {
+    return `0 0 ${flex}`;
+  }
+  return flex;
+}
+var Col = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    getPrefixCls,
+    direction
+  } = useContext(ConfigContext);
+  const {
+    gutter,
+    wrap
+  } = useContext(RowContext_default);
+  const {
+    prefixCls: customizePrefixCls,
+    span,
+    order,
+    offset,
+    push,
+    pull,
+    className,
+    children,
+    flex,
+    style,
+    ...others
+  } = props;
+  const prefixCls = getPrefixCls("col", customizePrefixCls);
+  const rootPrefixCls = getPrefixCls();
+  const [hashId, cssVarCls] = useColStyle(prefixCls);
+  const [varName] = genCssVar(rootPrefixCls, "col");
+  const sizeStyle = {};
+  let sizeClassObj = {};
+  responsiveArrayReversed.forEach((size) => {
+    let sizeProps = {};
+    const propSize = props[size];
+    if (isNumber(propSize)) {
+      sizeProps.span = propSize;
+    } else if (isPlainObject(propSize)) {
+      sizeProps = propSize || {};
+    }
+    delete others[size];
+    sizeClassObj = {
+      ...sizeClassObj,
+      [`${prefixCls}-${size}-${sizeProps.span}`]: isNonNullable(sizeProps.span),
+      [`${prefixCls}-${size}-order-${sizeProps.order}`]: sizeProps.order || sizeProps.order === 0,
+      [`${prefixCls}-${size}-offset-${sizeProps.offset}`]: sizeProps.offset || sizeProps.offset === 0,
+      [`${prefixCls}-${size}-push-${sizeProps.push}`]: sizeProps.push || sizeProps.push === 0,
+      [`${prefixCls}-${size}-pull-${sizeProps.pull}`]: sizeProps.pull || sizeProps.pull === 0,
+      [`${prefixCls}-rtl`]: direction === "rtl"
+    };
+    if (sizeProps.flex || sizeProps.flex === 0) {
+      sizeClassObj[`${prefixCls}-${size}-flex`] = true;
+      sizeStyle[varName(`${size}-flex`)] = parseFlex(sizeProps.flex);
+    }
+  });
+  const classes = clsx(prefixCls, {
+    [`${prefixCls}-${span}`]: span !== void 0,
+    [`${prefixCls}-order-${order}`]: order,
+    [`${prefixCls}-offset-${offset}`]: offset,
+    [`${prefixCls}-push-${push}`]: push,
+    [`${prefixCls}-pull-${pull}`]: pull
+  }, className, sizeClassObj, hashId, cssVarCls);
+  const mergedStyle = {};
+  if (gutter?.[0]) {
+    const horizontalGutter = isNumber(gutter[0]) ? `${gutter[0] / 2}px` : `calc(${gutter[0]} / 2)`;
+    mergedStyle.paddingInline = horizontalGutter;
+  }
+  if (flex || flex === 0) {
+    mergedStyle.flex = parseFlex(flex);
+    if (wrap === false && !mergedStyle.minWidth) {
+      mergedStyle.minWidth = 0;
+    }
+  }
+  return /* @__PURE__ */ createElement("div", {
+    ...others,
+    style: {
+      ...mergedStyle,
+      ...style,
+      ...sizeStyle
+    },
+    className: classes,
+    ref
+  }, children);
+});
+if (true) {
+  Col.displayName = "Col";
+}
+var col_default = Col;
+
+// ../../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/grid/hooks/useGutter.js
+function useGutter(gutter, screens) {
+  const results = [void 0, void 0];
+  const normalizedGutter = Array.isArray(gutter) ? gutter : [gutter, void 0];
+  const mergedScreens = screens || {
+    xs: true,
+    sm: true,
+    md: true,
+    lg: true,
+    xl: true,
+    xxl: true,
+    xxxl: true
+  };
+  normalizedGutter.forEach((g, index) => {
+    if (isPlainObject(g)) {
+      for (let i = 0; i < responsiveArray.length; i++) {
+        const breakpoint = responsiveArray[i];
+        if (mergedScreens[breakpoint] && g[breakpoint] !== void 0) {
+          results[index] = g[breakpoint];
+          break;
+        }
+      }
+    } else {
+      results[index] = g;
+    }
+  });
+  return results;
+}
+
+// ../../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/grid/row.js
+var useMergedPropByScreen = (oriProp, screen) => {
+  const [prop, setProp] = useState(() => isString(oriProp) ? oriProp : "");
+  const calcMergedAlignOrJustify = () => {
+    if (isString(oriProp)) {
+      setProp(oriProp);
+    }
+    if (!isPlainObject(oriProp)) {
+      return;
+    }
+    for (let i = 0; i < responsiveArray.length; i++) {
+      const breakpoint = responsiveArray[i];
+      if (!screen || !screen[breakpoint]) {
+        continue;
+      }
+      const curVal = oriProp[breakpoint];
+      if (curVal !== void 0) {
+        setProp(curVal);
+        return;
+      }
+    }
+  };
+  useEffect(() => {
+    calcMergedAlignOrJustify();
+  }, [JSON.stringify(oriProp), screen]);
+  return prop;
+};
+var Row = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    justify,
+    align,
+    className,
+    style,
+    children,
+    gutter = 0,
+    wrap,
+    ...others
+  } = props;
+  const {
+    getPrefixCls,
+    direction
+  } = useContext(ConfigContext);
+  const screens = useBreakpoint_default(true, null);
+  const mergedAlign = useMergedPropByScreen(align, screens);
+  const mergedJustify = useMergedPropByScreen(justify, screens);
+  const prefixCls = getPrefixCls("row", customizePrefixCls);
+  const [hashId, cssVarCls] = useRowStyle(prefixCls);
+  const gutters = useGutter(gutter, screens);
+  const classes = clsx(prefixCls, {
+    [`${prefixCls}-no-wrap`]: wrap === false,
+    [`${prefixCls}-${mergedJustify}`]: mergedJustify,
+    [`${prefixCls}-${mergedAlign}`]: mergedAlign,
+    [`${prefixCls}-rtl`]: direction === "rtl"
+  }, className, hashId, cssVarCls);
+  const rowStyle = {};
+  if (gutters?.[0]) {
+    const horizontalGutter = isNumber(gutters[0]) ? `${gutters[0] / -2}px` : `calc(${gutters[0]} / -2)`;
+    rowStyle.marginInline = horizontalGutter;
+  }
+  const [gutterH, gutterV] = gutters;
+  rowStyle.rowGap = gutterV;
+  const rowContext = useMemo(() => ({
+    gutter: [gutterH, gutterV],
+    wrap
+  }), [gutterH, gutterV, wrap]);
+  return /* @__PURE__ */ createElement(RowContext_default.Provider, {
+    value: rowContext
+  }, /* @__PURE__ */ createElement("div", {
+    ...others,
+    className: classes,
+    style: {
+      ...rowStyle,
+      ...style
+    },
+    ref
+  }, children));
+});
+if (true) {
+  Row.displayName = "Row";
+}
+var row_default = Row;
+
+// ../../node_modules/.pnpm/@rc-component+segmented@1.3.0_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@rc-component/segmented/es/MotionThumb.js
+var calcThumbStyle = (targetElement, vertical) => {
+  if (!targetElement) return null;
+  const style = {
+    left: targetElement.offsetLeft,
+    right: targetElement.parentElement.clientWidth - targetElement.clientWidth - targetElement.offsetLeft,
+    width: targetElement.clientWidth,
+    top: targetElement.offsetTop,
+    bottom: targetElement.parentElement.clientHeight - targetElement.clientHeight - targetElement.offsetTop,
+    height: targetElement.clientHeight
+  };
+  if (vertical) {
+    return {
+      left: 0,
+      right: 0,
+      width: 0,
+      top: style.top,
+      bottom: style.bottom,
+      height: style.height
+    };
+  }
+  return {
+    left: style.left,
+    right: style.right,
+    width: style.width,
+    top: 0,
+    bottom: 0,
+    height: 0
+  };
+};
+var toPX = (value) => value !== void 0 ? `${value}px` : void 0;
+function MotionThumb(props) {
+  const {
+    prefixCls,
+    containerRef,
+    value,
+    getValueIndex,
+    motionName,
+    onMotionStart,
+    onMotionEnd,
+    direction,
+    vertical = false
+  } = props;
+  const thumbRef = useRef(null);
+  const [prevValue, setPrevValue] = useState(value);
+  const findValueElement = (val) => {
+    const index = getValueIndex(val);
+    const ele = containerRef.current?.querySelectorAll(`.${prefixCls}-item`)[index];
+    return ele?.offsetParent && ele;
+  };
+  const [prevStyle, setPrevStyle] = useState(null);
+  const [nextStyle, setNextStyle] = useState(null);
+  useLayoutEffect_default(() => {
+    if (prevValue !== value) {
+      const prev = findValueElement(prevValue);
+      const next = findValueElement(value);
+      const calcPrevStyle = calcThumbStyle(prev, vertical);
+      const calcNextStyle = calcThumbStyle(next, vertical);
+      setPrevValue(value);
+      setPrevStyle(calcPrevStyle);
+      setNextStyle(calcNextStyle);
+      if (prev && next) {
+        onMotionStart();
+      } else {
+        onMotionEnd();
+      }
+    }
+  }, [value]);
+  const thumbStart = useMemo(() => {
+    if (vertical) {
+      return toPX(prevStyle?.top ?? 0);
+    }
+    if (direction === "rtl") {
+      return toPX(-prevStyle?.right);
+    }
+    return toPX(prevStyle?.left);
+  }, [vertical, direction, prevStyle]);
+  const thumbActive = useMemo(() => {
+    if (vertical) {
+      return toPX(nextStyle?.top ?? 0);
+    }
+    if (direction === "rtl") {
+      return toPX(-nextStyle?.right);
+    }
+    return toPX(nextStyle?.left);
+  }, [vertical, direction, nextStyle]);
+  const onAppearStart = () => {
+    if (vertical) {
+      return {
+        transform: "translateY(var(--thumb-start-top))",
+        height: "var(--thumb-start-height)"
+      };
+    }
+    return {
+      transform: "translateX(var(--thumb-start-left))",
+      width: "var(--thumb-start-width)"
+    };
+  };
+  const onAppearActive = () => {
+    if (vertical) {
+      return {
+        transform: "translateY(var(--thumb-active-top))",
+        height: "var(--thumb-active-height)"
+      };
+    }
+    return {
+      transform: "translateX(var(--thumb-active-left))",
+      width: "var(--thumb-active-width)"
+    };
+  };
+  const onVisibleChanged = () => {
+    setPrevStyle(null);
+    setNextStyle(null);
+    onMotionEnd();
+  };
+  if (!prevStyle || !nextStyle) {
+    return null;
+  }
+  return /* @__PURE__ */ createElement(es_default, {
+    visible: true,
+    motionName,
+    motionAppear: true,
+    onAppearStart,
+    onAppearActive,
+    onVisibleChanged
+  }, ({
+    className: motionClassName,
+    style: motionStyle
+  }, ref) => {
+    const mergedStyle = {
+      ...motionStyle,
+      "--thumb-start-left": thumbStart,
+      "--thumb-start-width": toPX(prevStyle?.width),
+      "--thumb-active-left": thumbActive,
+      "--thumb-active-width": toPX(nextStyle?.width),
+      "--thumb-start-top": thumbStart,
+      "--thumb-start-height": toPX(prevStyle?.height),
+      "--thumb-active-top": thumbActive,
+      "--thumb-active-height": toPX(nextStyle?.height)
+    };
+    const motionProps = {
+      ref: composeRef(thumbRef, ref),
+      style: mergedStyle,
+      className: clsx(`${prefixCls}-thumb`, motionClassName)
+    };
+    if (false) {
+      motionProps["data-test-style"] = JSON.stringify(mergedStyle);
+    }
+    return /* @__PURE__ */ createElement("div", motionProps);
+  });
+}
+
+// ../../node_modules/.pnpm/@rc-component+segmented@1.3.0_react-dom@19.2.8_react@19.2.8__react@19.2.8/node_modules/@rc-component/segmented/es/index.js
+function getValidTitle(option) {
+  if (typeof option.title !== "undefined") {
+    return option.title;
+  }
+  if (typeof option.label !== "object") {
+    return option.label?.toString();
+  }
+}
+function normalizeOptions(options) {
+  return options.map((option) => {
+    if (typeof option === "object" && option !== null) {
+      const validTitle = getValidTitle(option);
+      return {
+        ...option,
+        title: validTitle
+      };
+    }
+    return {
+      label: option?.toString(),
+      title: option?.toString(),
+      value: option
+    };
+  });
+}
+var InternalSegmentedOption = ({
+  prefixCls,
+  className,
+  style,
+  styles,
+  classNames: segmentedClassNames,
+  data,
+  disabled,
+  checked,
+  label,
+  title,
+  value,
+  name,
+  onChange,
+  onFocus,
+  onBlur,
+  onKeyDown,
+  onKeyUp,
+  onMouseDown,
+  itemRender = (node) => node
+}) => {
+  const handleChange = (event) => {
+    if (disabled) {
+      return;
+    }
+    onChange(event, value);
+  };
+  const itemContent = /* @__PURE__ */ createElement("label", {
+    className: clsx(className, {
+      [`${prefixCls}-item-disabled`]: disabled
+    }),
+    style,
+    onMouseDown
+  }, /* @__PURE__ */ createElement("input", {
+    name,
+    className: `${prefixCls}-item-input`,
+    type: "radio",
+    disabled,
+    checked,
+    onChange: handleChange,
+    onFocus,
+    onBlur,
+    onKeyDown,
+    onKeyUp
+  }), /* @__PURE__ */ createElement("div", {
+    className: clsx(`${prefixCls}-item-label`, segmentedClassNames?.label),
+    title,
+    style: styles?.label
+  }, label));
+  return itemRender(itemContent, {
+    item: data
+  });
+};
+var Segmented = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls = "rc-segmented",
+    direction,
+    vertical,
+    options = [],
+    disabled,
+    defaultValue,
+    value,
+    name,
+    onChange,
+    className = "",
+    style,
+    styles,
+    classNames: segmentedClassNames,
+    motionName = "thumb-motion",
+    itemRender,
+    ...restProps
+  } = props;
+  const containerRef = useRef(null);
+  const mergedRef = useMemo(() => composeRef(containerRef, ref), [containerRef, ref]);
+  const segmentedOptions = useMemo(() => {
+    return normalizeOptions(options);
+  }, [options]);
+  const [rawValue, setRawValue] = useControlledState(defaultValue ?? segmentedOptions[0]?.value, value);
+  const [thumbShow, setThumbShow] = useState(false);
+  const handleChange = (event, val) => {
+    setRawValue(val);
+    onChange?.(val);
+  };
+  const divProps = omit(restProps, ["children"]);
+  const [isKeyboard, setIsKeyboard] = useState(false);
+  const [isFocused, setIsFocused] = useState(false);
+  const handleFocus = () => {
+    setIsFocused(true);
+  };
+  const handleBlur = () => {
+    setIsFocused(false);
+  };
+  const handleMouseDown = () => {
+    setIsKeyboard(false);
+  };
+  const handleKeyUp = (event) => {
+    if (event.key === "Tab") {
+      setIsKeyboard(true);
+    }
+  };
+  const onOffset = (offset) => {
+    const currentIndex = segmentedOptions.findIndex((option) => option.value === rawValue);
+    const total = segmentedOptions.length;
+    const nextIndex = (currentIndex + offset + total) % total;
+    const nextOption = segmentedOptions[nextIndex];
+    if (nextOption) {
+      setRawValue(nextOption.value);
+      onChange?.(nextOption.value);
+    }
+  };
+  const handleKeyDown = (event) => {
+    switch (event.key) {
+      case "ArrowLeft":
+      case "ArrowUp":
+        onOffset(-1);
+        break;
+      case "ArrowRight":
+      case "ArrowDown":
+        onOffset(1);
+        break;
+    }
+  };
+  const renderOption = (segmentedOption) => {
+    const {
+      value: optionValue,
+      disabled: optionDisabled
+    } = segmentedOption;
+    return /* @__PURE__ */ createElement(InternalSegmentedOption, _extends({}, segmentedOption, {
+      name,
+      data: segmentedOption,
+      itemRender,
+      key: optionValue,
+      prefixCls,
+      className: clsx(segmentedOption.className, `${prefixCls}-item`, segmentedClassNames?.item, {
+        [`${prefixCls}-item-selected`]: optionValue === rawValue && !thumbShow,
+        [`${prefixCls}-item-focused`]: isFocused && isKeyboard && optionValue === rawValue
+      }),
+      style: styles?.item,
+      classNames: segmentedClassNames,
+      styles,
+      checked: optionValue === rawValue,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onKeyDown: handleKeyDown,
+      onKeyUp: handleKeyUp,
+      onMouseDown: handleMouseDown,
+      disabled: !!disabled || !!optionDisabled
+    }));
+  };
+  return /* @__PURE__ */ createElement("div", _extends({
+    role: "radiogroup",
+    "aria-label": "segmented control",
+    tabIndex: disabled ? void 0 : 0,
+    "aria-orientation": vertical ? "vertical" : "horizontal",
+    style
+  }, divProps, {
+    className: clsx(prefixCls, {
+      [`${prefixCls}-rtl`]: direction === "rtl",
+      [`${prefixCls}-disabled`]: disabled,
+      [`${prefixCls}-vertical`]: vertical
+    }, className),
+    ref: mergedRef
+  }), /* @__PURE__ */ createElement("div", {
+    className: `${prefixCls}-group`
+  }, /* @__PURE__ */ createElement(MotionThumb, {
+    vertical,
+    prefixCls,
+    value: rawValue,
+    containerRef,
+    motionName: `${prefixCls}-${motionName}`,
+    direction,
+    getValueIndex: (val) => segmentedOptions.findIndex((n2) => n2.value === val),
+    onMotionStart: () => {
+      setThumbShow(true);
+    },
+    onMotionEnd: () => {
+      setThumbShow(false);
+    }
+  }), segmentedOptions.map(renderOption)));
+});
+if (true) {
+  Segmented.displayName = "Segmented";
+}
+var TypedSegmented = Segmented;
+var es_default3 = TypedSegmented;
+
+// ../../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/segmented/style/index.js
+function getItemDisabledStyle(cls, token) {
+  return {
+    [`${cls}, ${cls}:hover, ${cls}:focus`]: {
+      color: token.colorTextDisabled,
+      cursor: "not-allowed"
+    }
+  };
+}
+var getItemSelectedStyle = (token) => {
+  return {
+    background: token.itemSelectedBg,
+    boxShadow: token.boxShadowTertiary
+  };
+};
+var segmentedTextEllipsisCss = {
+  overflow: "hidden",
+  // handle text ellipsis
+  ...textEllipsis
+};
+var genSegmentedStyle = (token) => {
+  const {
+    componentCls,
+    motionDurationSlow,
+    motionEaseInOut,
+    motionDurationMid
+  } = token;
+  const labelHeight = token.calc(token.controlHeight).sub(token.calc(token.trackPadding).mul(2)).equal();
+  const labelHeightLG = token.calc(token.controlHeightLG).sub(token.calc(token.trackPadding).mul(2)).equal();
+  const labelHeightSM = token.calc(token.controlHeightSM).sub(token.calc(token.trackPadding).mul(2)).equal();
+  return {
+    [componentCls]: {
+      ...resetComponent(token),
+      display: "inline-block",
+      padding: token.trackPadding,
+      color: token.itemColor,
+      background: token.trackBg,
+      borderRadius: token.borderRadius,
+      transition: `all ${motionDurationMid}`,
+      ...genFocusStyle(token),
+      [`${componentCls}-group`]: {
+        position: "relative",
+        display: "flex",
+        alignItems: "stretch",
+        justifyItems: "flex-start",
+        flexDirection: "row",
+        width: "100%"
+      },
+      // RTL styles
+      [`&${componentCls}-rtl`]: {
+        direction: "rtl"
+      },
+      [`&${componentCls}-vertical`]: {
+        [`${componentCls}-group`]: {
+          flexDirection: "column"
+        },
+        [`${componentCls}-thumb`]: {
+          width: "100%",
+          height: 0,
+          padding: `0 ${unit(token.paddingXXS)}`
+        }
+      },
+      // block styles
+      [`&${componentCls}-block`]: {
+        display: "flex"
+      },
+      [`&${componentCls}-block ${componentCls}-item`]: {
+        flex: 1,
+        minWidth: 0
+      },
+      // item styles
+      [`${componentCls}-item`]: {
+        position: "relative",
+        textAlign: "center",
+        cursor: "pointer",
+        transition: `color ${motionDurationMid}`,
+        borderRadius: token.borderRadiusSM,
+        // Fix Safari render bug
+        // https://github.com/ant-design/ant-design/issues/45250
+        transform: "translateZ(0)",
+        "&-selected": {
+          ...getItemSelectedStyle(token),
+          color: token.itemSelectedColor
+        },
+        "&-focused": genFocusOutline(token),
+        "&::after": {
+          content: '""',
+          position: "absolute",
+          zIndex: -1,
+          width: "100%",
+          height: "100%",
+          top: 0,
+          insetInlineStart: 0,
+          borderRadius: "inherit",
+          opacity: 0,
+          // This is mandatory to make it not clickable or hoverable
+          // Ref: https://github.com/ant-design/ant-design/issues/40888
+          pointerEvents: "none",
+          transition: ["opacity", "background-color"].map((prop) => `${prop} ${motionDurationMid}`).join(", ")
+        },
+        [`&:not(${componentCls}-item-selected):not(${componentCls}-item-disabled)`]: {
+          "&:hover, &:active": {
+            color: token.itemHoverColor
+          },
+          "&:hover::after": {
+            opacity: 1,
+            backgroundColor: token.itemHoverBg
+          },
+          "&:active::after": {
+            opacity: 1,
+            backgroundColor: token.itemActiveBg
+          }
+        },
+        "&-label": {
+          minHeight: labelHeight,
+          lineHeight: unit(labelHeight),
+          padding: `0 ${unit(token.segmentedPaddingHorizontal)}`,
+          ...segmentedTextEllipsisCss
+        },
+        // syntactic sugar to add `icon` for Segmented Item
+        "&-icon + *": {
+          marginInlineStart: token.calc(token.marginSM).div(2).equal()
+        },
+        // Icons from third-party libraries render as a bare `<svg>` inside the icon wrapper,
+        // which the `.anticon` reset never reaches. An `<svg>` has no baseline of its own, so it
+        // is aligned by its bottom margin edge (CSS 2.1 §10.8.1) and rides above the label.
+        // `display: inline-block` keeps it an atomic inline box so `vertical-align` still applies
+        // even under a CSS reset that forces `svg { display: block }` (e.g. Tailwind Preflight),
+        // which would otherwise drop the icon onto its own line. `vertical-align: middle` centres its
+        // margin box on the x-height line; `margin-block-end` then lifts it by half its own value onto
+        // the cap-height centre (capHeight − xHeight ≈ 0.2em across typical fonts), keeping it centred
+        // at any icon size.
+        // Only matches a bare `<svg>`: an `.anticon` keeps its `<svg>` one level deeper.
+        "&-icon > svg": {
+          display: "inline-block",
+          verticalAlign: "middle",
+          marginBlockEnd: "0.2em"
+        },
+        "&-input": {
+          position: "absolute",
+          insetBlockStart: 0,
+          insetInlineStart: 0,
+          width: 0,
+          height: 0,
+          opacity: 0,
+          pointerEvents: "none"
+        }
+      },
+      // thumb styles
+      [`${componentCls}-thumb`]: {
+        ...getItemSelectedStyle(token),
+        position: "absolute",
+        insetBlockStart: 0,
+        insetInlineStart: 0,
+        width: 0,
+        height: "100%",
+        padding: `${unit(token.paddingXXS)} 0`,
+        borderRadius: token.borderRadiusSM,
+        [`& ~ ${componentCls}-item:not(${componentCls}-item-selected):not(${componentCls}-item-disabled)::after`]: {
+          backgroundColor: "transparent"
+        }
+      },
+      // size styles
+      [`&${componentCls}-lg`]: {
+        borderRadius: token.borderRadiusLG,
+        [`${componentCls}-item-label`]: {
+          minHeight: labelHeightLG,
+          lineHeight: unit(labelHeightLG),
+          padding: `0 ${unit(token.segmentedPaddingHorizontal)}`,
+          fontSize: token.fontSizeLG
+        },
+        [`${componentCls}-item, ${componentCls}-thumb`]: {
+          borderRadius: token.borderRadius
+        }
+      },
+      [`&${componentCls}-sm`]: {
+        borderRadius: token.borderRadiusSM,
+        [`${componentCls}-item-label`]: {
+          minHeight: labelHeightSM,
+          lineHeight: unit(labelHeightSM),
+          padding: `0 ${unit(token.segmentedPaddingHorizontalSM)}`
+        },
+        [`${componentCls}-item, ${componentCls}-thumb`]: {
+          borderRadius: token.borderRadiusXS
+        }
+      },
+      // disabled styles
+      ...getItemDisabledStyle(`&-disabled ${componentCls}-item`, token),
+      ...getItemDisabledStyle(`${componentCls}-item-disabled`, token),
+      // transition effect when `appear-active`
+      [`${componentCls}-thumb-motion-appear-active`]: {
+        willChange: "transform, width",
+        transition: [`transform`, `width`].map((prop) => `${prop} ${motionDurationSlow} ${motionEaseInOut}`).join(", ")
+      },
+      [`&${componentCls}-shape-round`]: {
+        borderRadius: 9999,
+        [`${componentCls}-item, ${componentCls}-thumb`]: {
+          borderRadius: 9999
+        }
+      }
+    }
+  };
+};
+var prepareComponentToken = (token) => {
+  const {
+    colorTextLabel,
+    colorText,
+    colorFillSecondary,
+    colorBgElevated,
+    colorFill,
+    lineWidthBold,
+    colorBgLayout
+  } = token;
+  return {
+    trackPadding: lineWidthBold,
+    trackBg: colorBgLayout,
+    itemColor: colorTextLabel,
+    itemHoverColor: colorText,
+    itemHoverBg: colorFillSecondary,
+    itemSelectedBg: colorBgElevated,
+    itemActiveBg: colorFill,
+    itemSelectedColor: colorText
+  };
+};
+var style_default2 = genStyleHooks("Segmented", (token) => {
+  const {
+    lineWidth,
+    calc
+  } = token;
+  const segmentedToken = merge(token, {
+    segmentedPaddingHorizontal: calc(token.controlPaddingHorizontal).sub(lineWidth).equal(),
+    segmentedPaddingHorizontalSM: calc(token.controlPaddingHorizontalSM).sub(lineWidth).equal()
+  });
+  return genSegmentedStyle(segmentedToken);
+}, 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/segmented/index.js
+function isSegmentedLabeledOptionWithIcon(option) {
+  return isPlainObject(option) && !!option?.icon;
+}
+var InternalSegmented = /* @__PURE__ */ forwardRef((props, ref) => {
+  const defaultName = useId_default();
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    rootClassName,
+    block,
+    options = [],
+    size: customSize,
+    style,
+    vertical,
+    orientation,
+    shape = "default",
+    name = defaultName,
+    styles,
+    classNames,
+    ...restProps
+  } = props;
+  const {
+    getPrefixCls,
+    direction,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles
+  } = useComponentConfig("segmented");
+  const mergedProps = {
+    ...props,
+    options,
+    size: customSize,
+    shape
+  };
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const styleRoot = useSemanticRootStyle(style);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNames, classNames], [contextStyles, contextStyleRoot, styles, styleRoot], {
+    props: mergedProps
+  });
+  const prefixCls = getPrefixCls("segmented", customizePrefixCls);
+  const [hashId, cssVarCls] = style_default2(prefixCls);
+  const mergedSize = useSize_default(customSize);
+  const extendedOptions = useMemo(() => options.map((option) => {
+    if (isSegmentedLabeledOptionWithIcon(option)) {
+      const {
+        icon,
+        label,
+        ...restOption
+      } = option;
+      return {
+        ...restOption,
+        label: /* @__PURE__ */ createElement(Fragment, null, /* @__PURE__ */ createElement("span", {
+          className: clsx(`${prefixCls}-item-icon`, mergedClassNames.icon),
+          style: mergedStyles.icon
+        }, icon), label && /* @__PURE__ */ createElement("span", null, label))
+      };
+    }
+    return option;
+  }), [options, prefixCls, mergedClassNames.icon, mergedStyles.icon]);
+  const [, mergedVertical] = useOrientation(orientation, vertical);
+  const cls = clsx(className, rootClassName, contextClassName, mergedClassNames.root, {
+    [`${prefixCls}-block`]: block,
+    [`${prefixCls}-sm`]: mergedSize === "small",
+    [`${prefixCls}-lg`]: mergedSize === "large",
+    [`${prefixCls}-vertical`]: mergedVertical,
+    [`${prefixCls}-shape-${shape}`]: shape === "round"
+  }, hashId, cssVarCls);
+  const itemRender = (node, {
+    item
+  }) => {
+    if (!item.tooltip) {
+      return node;
+    }
+    const tooltipProps = isPlainObject(item.tooltip) ? item.tooltip : {
+      title: item.tooltip
+    };
+    return /* @__PURE__ */ createElement(tooltip_default, {
+      ...tooltipProps
+    }, node);
+  };
+  return /* @__PURE__ */ createElement(es_default3, {
+    ...restProps,
+    name,
+    className: cls,
+    style: mergedStyles.root,
+    classNames: mergedClassNames,
+    styles: mergedStyles,
+    itemRender,
+    options: extendedOptions,
+    ref,
+    prefixCls,
+    direction,
+    vertical: mergedVertical
+  });
+});
+var Segmented2 = InternalSegmented;
+if (true) {
+  Segmented2.displayName = "Segmented";
+}
+var segmented_default = Segmented2;
+
+// ../../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/convertToTooltipProps.js
+var convertToTooltipProps = (tooltip, context) => {
+  if (!isReactRenderable(tooltip)) {
+    return null;
+  }
+  if (isPlainObject(tooltip) && !/* @__PURE__ */ isValidElement(tooltip)) {
+    return {
+      ...context,
+      ...tooltip
+    };
+  }
+  return {
+    ...context,
+    title: tooltip
+  };
+};
+var convertToTooltipProps_default = convertToTooltipProps;
+
+// ../../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/form/hooks/useDebounce.js
+function useDebounce(value) {
+  const [cacheValue, setCacheValue] = useDelayState(value);
+  useEffect(() => {
+    setCacheValue(value, {
+      ms: value.length ? 0 : 10
+    });
+  }, [value]);
+  return cacheValue;
+}
+
+// ../../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/form/style/explain.js
+var genFormValidateMotionStyle = (token) => {
+  const {
+    componentCls,
+    motionDurationFast,
+    motionEaseInOut
+  } = token;
+  const helpCls = `${componentCls}-show-help`;
+  const helpItemCls = `${componentCls}-show-help-item`;
+  return {
+    [helpCls]: {
+      // Explain holder
+      transition: `opacity ${motionDurationFast} ${motionEaseInOut}`,
+      "&-appear, &-enter": {
+        opacity: 0,
+        "&-active": {
+          opacity: 1
+        }
+      },
+      "&-leave": {
+        opacity: 1,
+        "&-active": {
+          opacity: 0
+        }
+      },
+      // Explain
+      [helpItemCls]: {
+        overflow: "hidden",
+        transition: `${["height", "opacity", "transform"].map((prop) => `${prop} ${motionDurationFast} ${motionEaseInOut}`).join(", ")} !important`,
+        [`&${helpItemCls}-appear, &${helpItemCls}-enter`]: {
+          transform: `translateY(-5px)`,
+          opacity: 0,
+          "&-active": {
+            transform: "translateY(0)",
+            opacity: 1
+          }
+        },
+        [`&${helpItemCls}-leave-active`]: {
+          transform: `translateY(-5px)`
+        }
+      }
+    }
+  };
+};
+var explain_default = genFormValidateMotionStyle;
+
+// ../../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/form/style/index.js
+var resetForm = (token) => ({
+  legend: {
+    display: "block",
+    width: "100%",
+    marginBottom: token.marginLG,
+    padding: 0,
+    color: token.colorTextDescription,
+    fontSize: token.fontSizeLG,
+    lineHeight: "inherit",
+    border: 0,
+    borderBottom: `${unit(token.lineWidth)} ${token.lineType} ${token.colorBorder}`
+  },
+  'input[type="search"]': {
+    boxSizing: "border-box"
+  },
+  // Position radios and checkboxes better
+  'input[type="radio"], input[type="checkbox"]': {
+    lineHeight: "normal"
+  },
+  'input[type="file"]': {
+    display: "block"
+  },
+  // Make range inputs behave like textual form controls
+  'input[type="range"]': {
+    display: "block",
+    width: "100%"
+  },
+  // Make multiple select elements height not fixed
+  "select[multiple], select[size]": {
+    height: "auto"
+  },
+  // Focus for file, radio, and checkbox
+  "input[type='file']:focus, input[type='radio']:focus, input[type='checkbox']:focus": {
+    outline: 0,
+    boxShadow: `0 0 0 ${unit(token.controlOutlineWidth)} ${token.controlOutline}`
+  },
+  // Adjust output element
+  output: {
+    display: "block",
+    paddingTop: 15,
+    color: token.colorText,
+    fontSize: token.fontSize,
+    lineHeight: token.lineHeight
+  }
+});
+var genFormSize = (token, height) => {
+  const {
+    formItemCls
+  } = token;
+  return {
+    [formItemCls]: {
+      [`${formItemCls}-label > label`]: {
+        height
+      },
+      [`${formItemCls}-control-input`]: {
+        minHeight: height
+      }
+    }
+  };
+};
+var genFormStyle = (token) => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [componentCls]: {
+      ...resetComponent(token),
+      ...resetForm(token),
+      [`${componentCls}-text`]: {
+        display: "inline-block",
+        paddingInlineEnd: token.paddingSM
+      },
+      // ================================================================
+      // =                             Size                             =
+      // ================================================================
+      "&-small": {
+        ...genFormSize(token, token.controlHeightSM)
+      },
+      "&-large": {
+        ...genFormSize(token, token.controlHeightLG)
+      }
+    }
+  };
+};
+var genFormItemStyle = (token) => {
+  const {
+    formItemCls,
+    iconCls,
+    rootPrefixCls,
+    antCls,
+    labelRequiredMarkColor,
+    labelColor,
+    labelFontSize,
+    labelHeight,
+    labelColonMarginInlineStart,
+    labelColonMarginInlineEnd,
+    itemMarginBottom
+  } = token;
+  const [varName] = genCssVar(antCls, "grid");
+  return {
+    [formItemCls]: {
+      ...resetComponent(token),
+      marginBottom: itemMarginBottom,
+      verticalAlign: "top",
+      "&-with-help": {
+        transition: "none"
+      },
+      [`&-hidden,
+        &-hidden${antCls}-row`]: {
+        // https://github.com/ant-design/ant-design/issues/26141
+        display: "none"
+      },
+      // ==============================================================
+      // =                            Label                           =
+      // ==============================================================
+      [`${formItemCls}-label`]: {
+        flexGrow: 0,
+        overflow: "hidden",
+        whiteSpace: "nowrap",
+        textAlign: "end",
+        verticalAlign: "middle",
+        "&-left": {
+          textAlign: "start"
+        },
+        "&-wrap": {
+          overflow: "unset",
+          lineHeight: token.lineHeight,
+          whiteSpace: "unset",
+          "> label": {
+            verticalAlign: "middle",
+            textWrap: "balance"
+          }
+        },
+        "> label": {
+          position: "relative",
+          display: "inline-flex",
+          alignItems: "center",
+          maxWidth: "100%",
+          height: labelHeight,
+          color: labelColor,
+          fontSize: labelFontSize,
+          [`> ${iconCls}`]: {
+            fontSize: token.fontSize,
+            verticalAlign: "top"
+          },
+          [`&${formItemCls}-required`]: {
+            "&::before": {
+              display: "inline-block",
+              marginInlineEnd: token.marginXXS,
+              color: labelRequiredMarkColor,
+              fontSize: token.fontSize,
+              fontFamily: "sans-serif",
+              lineHeight: 1,
+              content: '"*"'
+            },
+            [`&${formItemCls}-required-mark-hidden, &${formItemCls}-required-mark-optional`]: {
+              "&::before": {
+                display: "none"
+              }
+            }
+          },
+          // Optional mark
+          [`${formItemCls}-optional`]: {
+            display: "inline-block",
+            marginInlineStart: token.marginXXS,
+            color: token.colorTextDescription,
+            [`&${formItemCls}-required-mark-hidden`]: {
+              display: "none"
+            }
+          },
+          // Optional mark
+          [`${formItemCls}-tooltip`]: {
+            color: token.colorTextDescription,
+            cursor: "help",
+            writingMode: "horizontal-tb",
+            marginInlineStart: token.marginXXS
+          },
+          "&::after": {
+            content: '":"',
+            position: "relative",
+            marginBlock: 0,
+            marginInlineStart: labelColonMarginInlineStart,
+            marginInlineEnd: labelColonMarginInlineEnd
+          },
+          [`&${formItemCls}-no-colon::after`]: {
+            content: '"\\a0"'
+          }
+        }
+      },
+      // ==============================================================
+      // =                            Input                           =
+      // ==============================================================
+      [`${formItemCls}-control`]: {
+        [varName("display")]: "flex",
+        flexDirection: "column",
+        flexGrow: 1,
+        [`&:first-child:not([class^="'${rootPrefixCls}-col-'"]):not([class*="' ${rootPrefixCls}-col-'"])`]: {
+          width: "100%"
+        },
+        "&-input": {
+          position: "relative",
+          display: "flex",
+          alignItems: "center",
+          minHeight: token.controlHeight,
+          "&-content": {
+            flex: "auto",
+            maxWidth: "100%",
+            // Fix https://github.com/ant-design/ant-design/issues/54042
+            // Remove impact of whitespaces
+            [`&:has(> ${antCls}-switch:only-child, > ${antCls}-rate:only-child)`]: {
+              display: "flex",
+              alignItems: "center"
+            }
+          }
+        }
+      },
+      // ==============================================================
+      // =                           Explain                          =
+      // ==============================================================
+      [formItemCls]: {
+        "&-additional": {
+          display: "flex",
+          flexDirection: "column"
+        },
+        "&-explain, &-extra": {
+          clear: "both",
+          color: token.colorTextDescription,
+          fontSize: token.fontSize,
+          lineHeight: token.lineHeight
+        },
+        "&-explain-connected": {
+          width: "100%"
+        },
+        "&-extra": {
+          minHeight: token.controlHeightSM,
+          transition: `color ${token.motionDurationMid} ${token.motionEaseOut}`
+          // sync input color transition
+        },
+        "&-explain": {
+          "&-error": {
+            color: token.colorError
+          },
+          "&-warning": {
+            color: token.colorWarning
+          }
+        }
+      },
+      [`&-with-help ${formItemCls}-explain`]: {
+        height: "auto",
+        opacity: 1
+      },
+      // ==============================================================
+      // =                        Feedback Icon                       =
+      // ==============================================================
+      [`${formItemCls}-feedback-icon`]: {
+        fontSize: token.fontSize,
+        textAlign: "center",
+        visibility: "visible",
+        animationName: zoomIn,
+        animationDuration: token.motionDurationMid,
+        animationTimingFunction: token.motionEaseOutBack,
+        pointerEvents: "none",
+        "&-success": {
+          color: token.colorSuccess
+        },
+        "&-error": {
+          color: token.colorError
+        },
+        "&-warning": {
+          color: token.colorWarning
+        },
+        "&-validating": {
+          color: token.colorPrimary
+        }
+      }
+    }
+  };
+};
+var makeVerticalLayoutLabelBase = (token) => ({
+  padding: token.verticalLabelPadding,
+  whiteSpace: "initial",
+  textAlign: "start",
+  "> label": {
+    margin: 0,
+    "&::after": {
+      // https://github.com/ant-design/ant-design/issues/43538
+      visibility: "hidden"
+    }
+  }
+});
+var makeVerticalLayoutLabel = (token) => ({
+  ...makeVerticalLayoutLabelBase(token),
+  margin: token.verticalLabelMargin
+});
+var makeVerticalLayoutLabelWithOffset = (token) => {
+  const [formVarName] = genCssVar(token.antCls, "form");
+  return {
+    ...makeVerticalLayoutLabelBase(token),
+    [formVarName("item-label-margin")]: token.verticalLabelMargin
+  };
+};
+var genHorizontalStyle = (token) => {
+  const {
+    antCls,
+    formItemCls
+  } = token;
+  return {
+    [`${formItemCls}-horizontal`]: {
+      [`${formItemCls}-label`]: {
+        flexGrow: 0
+      },
+      [`${formItemCls}-control`]: {
+        flex: "1 1 0",
+        // https://github.com/ant-design/ant-design/issues/32777
+        // https://github.com/ant-design/ant-design/issues/33773
+        minWidth: 0
+      },
+      // Do not change this to `ant-col-24`! `-24` match all the responsive rules
+      // https://github.com/ant-design/ant-design/issues/32980
+      // https://github.com/ant-design/ant-design/issues/34903
+      // https://github.com/ant-design/ant-design/issues/44538
+      [`${formItemCls}-label[class$='-24'], ${formItemCls}-label[class*='-24 ']`]: {
+        [`& + ${formItemCls}-control`]: {
+          minWidth: "unset"
+        }
+      },
+      [`> ${formItemCls}-row > ${antCls}-col-24${formItemCls}-label,
+        > ${formItemCls}-row > ${antCls}-col-xl-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+    }
+  };
+};
+var genInlineStyle = (token) => {
+  const {
+    componentCls,
+    formItemCls,
+    inlineItemMarginBottom
+  } = token;
+  return {
+    [`${componentCls}-inline`]: {
+      display: "flex",
+      flexWrap: "wrap",
+      [`${formItemCls}-inline`]: {
+        flex: "none",
+        marginInlineEnd: token.margin,
+        marginBottom: inlineItemMarginBottom,
+        "&-row": {
+          flexWrap: "nowrap"
+        },
+        [`> ${formItemCls}-label,
+        > ${formItemCls}-control`]: {
+          display: "inline-block",
+          verticalAlign: "top"
+        },
+        [`> ${formItemCls}-label`]: {
+          flex: "none"
+        },
+        [`${componentCls}-text`]: {
+          display: "inline-block"
+        },
+        [`${formItemCls}-has-feedback`]: {
+          display: "inline-block"
+        }
+      }
+    }
+  };
+};
+var makeVerticalLayout = (token) => {
+  const {
+    componentCls,
+    formItemCls,
+    rootPrefixCls
+  } = token;
+  return {
+    [`${formItemCls}:not(${formItemCls}-vertical) > ${formItemCls}-row > ${formItemCls}-label`]: makeVerticalLayoutLabel(token),
+    // ref: https://github.com/ant-design/ant-design/issues/45122
+    [`${componentCls}:not(${componentCls}-inline)`]: {
+      [formItemCls]: {
+        flexWrap: "wrap",
+        [`${formItemCls}-label, ${formItemCls}-control`]: {
+          // When developer pass `xs: { span }`,
+          // It should follow the `xs` screen config
+          // ref: https://github.com/ant-design/ant-design/issues/44386
+          [`&:not([class*=" ${rootPrefixCls}-col-xs"])`]: {
+            flex: "0 0 100%",
+            maxWidth: "100%"
+          }
+        }
+      }
+    }
+  };
+};
+var genVerticalStyle = (token) => {
+  const {
+    componentCls,
+    formItemCls,
+    antCls,
+    verticalLabelHeight
+  } = token;
+  const [formVarName, formVarRef] = genCssVar(antCls, "form");
+  return {
+    [formItemCls]: {
+      [formVarName("item-label-margin")]: "initial"
+    },
+    [`${formItemCls}-label`]: {
+      margin: formVarRef("item-label-margin")
+    },
+    [`${formItemCls}-vertical`]: {
+      [`${formItemCls}-row`]: {
+        flexDirection: "column"
+      },
+      [`${formItemCls}-label > label`]: {
+        height: verticalLabelHeight
+      },
+      [`${formItemCls}-control`]: {
+        width: "100%"
+      },
+      [`> ${formItemCls}-row > ${formItemCls}-label,
+        > ${formItemCls}-row > ${antCls}-col-24${formItemCls}-label,
+        > ${formItemCls}-row > ${antCls}-col-xl-24${formItemCls}-label`]: makeVerticalLayoutLabelWithOffset(token)
+    },
+    [`@media (max-width: ${unit(token.screenXSMax)})`]: [makeVerticalLayout(token), {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal):not(${formItemCls}-vertical)`]: {
+          [`> ${formItemCls}-row > ${antCls}-col-xs-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    }],
+    [`@media (max-width: ${unit(token.screenSMMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal):not(${formItemCls}-vertical)`]: {
+          [`> ${formItemCls}-row > ${antCls}-col-sm-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    },
+    [`@media (max-width: ${unit(token.screenMDMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal):not(${formItemCls}-vertical)`]: {
+          [`> ${formItemCls}-row > ${antCls}-col-md-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    },
+    [`@media (max-width: ${unit(token.screenLGMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal):not(${formItemCls}-vertical)`]: {
+          [`> ${formItemCls}-row > ${antCls}-col-lg-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    }
+  };
+};
+var prepareComponentToken2 = (token) => ({
+  labelRequiredMarkColor: token.colorError,
+  labelColor: token.colorTextHeading,
+  labelFontSize: token.fontSize,
+  labelHeight: token.controlHeight,
+  verticalLabelHeight: token.labelHeight ?? "auto",
+  labelColonMarginInlineStart: token.marginXXS / 2,
+  labelColonMarginInlineEnd: token.marginXS,
+  itemMarginBottom: token.marginLG,
+  verticalLabelPadding: `0 0 ${token.paddingXS}px`,
+  verticalLabelMargin: 0,
+  inlineItemMarginBottom: 0
+});
+var prepareToken = (token, rootPrefixCls) => {
+  const formToken = merge(token, {
+    formItemCls: `${token.componentCls}-item`,
+    rootPrefixCls
+  });
+  return formToken;
+};
+var style_default3 = genStyleHooks("Form", (token, {
+  rootPrefixCls
+}) => {
+  const formToken = prepareToken(token, rootPrefixCls);
+  return [genFormStyle(formToken), genFormItemStyle(formToken), explain_default(formToken), genHorizontalStyle(formToken), genInlineStyle(formToken), genVerticalStyle(formToken), collapse_default(formToken), zoomIn];
+}, prepareComponentToken2, {
+  // Let From style before the Grid
+  // ref https://github.com/ant-design/ant-design/issues/44386
+  order: -1e3
+});
+
+// ../../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/form/ErrorList.js
+var EMPTY_LIST = [];
+function toErrorEntity(error, prefix, errorStatus, index = 0) {
+  return {
+    key: typeof error === "string" ? error : `${prefix}-${index}`,
+    error,
+    errorStatus
+  };
+}
+var ErrorList = ({
+  help,
+  helpStatus,
+  errors = EMPTY_LIST,
+  warnings = EMPTY_LIST,
+  className: rootClassName,
+  fieldId,
+  onVisibleChanged
+}) => {
+  const {
+    prefixCls
+  } = useContext(FormItemPrefixContext);
+  const {
+    classNames: contextClassNames,
+    styles: contextStyles
+  } = useContext(FormContext);
+  const baseClassName = `${prefixCls}-item-explain`;
+  const rootCls = useCSSVarCls_default(prefixCls);
+  const [hashId, cssVarCls] = style_default3(prefixCls, rootCls);
+  const collapseMotion = useMemo(() => motion_default(prefixCls), [prefixCls]);
+  const debounceErrors = useDebounce(errors);
+  const debounceWarnings = useDebounce(warnings);
+  const hasHelp = isNonNullable(help);
+  const fullKeyList = useMemo(() => {
+    if (hasHelp) {
+      return [toErrorEntity(help, "help", helpStatus)];
+    }
+    return [].concat(_toConsumableArray(debounceErrors.map((error, index) => toErrorEntity(error, "error", "error", index))), _toConsumableArray(debounceWarnings.map((warning, index) => toErrorEntity(warning, "warning", "warning", index))));
+  }, [help, helpStatus, hasHelp, debounceErrors, debounceWarnings]);
+  const filledKeyFullKeyList = useMemo(() => {
+    const keysCount = {};
+    fullKeyList.forEach(({
+      key
+    }) => {
+      keysCount[key] = (keysCount[key] || 0) + 1;
+    });
+    return fullKeyList.map((entity, index) => ({
+      ...entity,
+      key: keysCount[entity.key] > 1 ? `${entity.key}-fallback-${index}` : entity.key
+    }));
+  }, [fullKeyList]);
+  const helpProps = {};
+  if (fieldId) {
+    helpProps.id = `${fieldId}_help`;
+  }
+  return /* @__PURE__ */ createElement(es_default, {
+    motionDeadline: collapseMotion.motionDeadline,
+    motionName: `${prefixCls}-show-help`,
+    visible: !!filledKeyFullKeyList.length,
+    onVisibleChanged
+  }, (holderProps) => {
+    const {
+      className: holderClassName,
+      style: holderStyle
+    } = holderProps;
+    return /* @__PURE__ */ createElement("div", {
+      ...helpProps,
+      className: clsx(baseClassName, holderClassName, contextClassNames?.help, cssVarCls, rootCls, rootClassName, hashId),
+      style: {
+        ...contextStyles?.help,
+        ...holderStyle
+      }
+    }, /* @__PURE__ */ createElement(CSSMotionList_default, {
+      keys: filledKeyFullKeyList,
+      ...motion_default(prefixCls),
+      motionName: `${prefixCls}-show-help-item`,
+      component: false
+    }, (itemProps) => {
+      const {
+        key,
+        error,
+        errorStatus,
+        className: itemClassName,
+        style: itemStyle
+      } = itemProps;
+      return /* @__PURE__ */ createElement("div", {
+        key,
+        className: clsx(itemClassName, contextClassNames?.helpItem, {
+          [`${baseClassName}-${errorStatus}`]: errorStatus
+        }),
+        style: {
+          ...contextStyles?.helpItem,
+          ...itemStyle
+        }
+      }, error);
+    }));
+  });
+};
+var ErrorList_default = ErrorList;
+
+// ../../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/form/hooks/useFormWarning.js
+var names = {};
+function useFormWarning({
+  name
+}) {
+  const warning = useDevWarning("Form");
+  useEffect(() => {
+    if (name) {
+      names[name] = (names[name] || 0) + 1;
+      true ? warning(names[name] <= 1, "usage", "There exist multiple Form with same `name`.") : void 0;
+      return () => {
+        names[name] -= 1;
+      };
+    }
+  }, [name]);
+}
+
+// ../../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/form/Form.js
+var InternalForm = (props, ref) => {
+  const contextDisabled = useContext(DisabledContext_default);
+  const {
+    getPrefixCls,
+    direction,
+    requiredMark: contextRequiredMark,
+    colon: contextColon,
+    scrollToFirstError: contextScrollToFirstError,
+    className: contextClassName,
+    style: contextStyle,
+    styles: contextStyles,
+    classNames: contextClassNames,
+    tooltip: contextTooltip,
+    labelAlign: contextLabelAlign,
+    labelWrap: contextLabelWrap
+  } = useComponentConfig("form");
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    rootClassName,
+    size,
+    disabled = contextDisabled,
+    form,
+    colon,
+    labelAlign,
+    labelWrap,
+    labelCol,
+    wrapperCol,
+    layout = "horizontal",
+    scrollToFirstError,
+    requiredMark,
+    onFinishFailed,
+    name,
+    style,
+    feedbackIcons,
+    variant,
+    classNames,
+    styles,
+    tooltip,
+    ...restFormProps
+  } = props;
+  const mergedSize = useSize_default(size);
+  const contextValidateMessages = useContext(validateMessagesContext_default);
+  if (true) {
+    useFormWarning(props);
+  }
+  const mergedRequiredMark = useMemo(() => {
+    if (requiredMark !== void 0) {
+      return requiredMark;
+    }
+    if (contextRequiredMark !== void 0) {
+      return contextRequiredMark;
+    }
+    return true;
+  }, [requiredMark, contextRequiredMark]);
+  const mergedColon = colon ?? contextColon;
+  const mergedLabelAlign = labelAlign ?? contextLabelAlign;
+  const mergedLabelWrap = labelWrap ?? contextLabelWrap;
+  const mergedTooltip = {
+    ...contextTooltip,
+    ...tooltip
+  };
+  const prefixCls = getPrefixCls("form", customizePrefixCls);
+  const rootCls = useCSSVarCls_default(prefixCls);
+  const [hashId, cssVarCls] = style_default3(prefixCls, rootCls);
+  const mergedProps = {
+    ...props,
+    size: mergedSize,
+    disabled,
+    layout,
+    colon: mergedColon,
+    requiredMark: mergedRequiredMark,
+    labelAlign: mergedLabelAlign,
+    labelWrap: mergedLabelWrap
+  };
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const styleRoot = useSemanticRootStyle(style);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNames, classNames], [contextStyles, contextStyleRoot, styles, styleRoot], {
+    props: mergedProps
+  });
+  const formClassName = clsx(prefixCls, `${prefixCls}-${layout}`, {
+    [`${prefixCls}-hide-required-mark`]: mergedRequiredMark === false,
+    // todo: remove in next major version
+    [`${prefixCls}-rtl`]: direction === "rtl",
+    [`${prefixCls}-large`]: mergedSize === "large",
+    [`${prefixCls}-small`]: mergedSize === "small"
+  }, cssVarCls, rootCls, hashId, contextClassName, className, rootClassName, mergedClassNames.root);
+  const [wrapForm] = useForm(form);
+  const {
+    __INTERNAL__
+  } = wrapForm;
+  __INTERNAL__.name = name;
+  const formContextValue = useMemo(() => ({
+    name,
+    labelAlign: mergedLabelAlign,
+    labelCol,
+    labelWrap: mergedLabelWrap,
+    wrapperCol,
+    layout,
+    colon: mergedColon,
+    requiredMark: mergedRequiredMark,
+    itemRef: __INTERNAL__.itemRef,
+    form: wrapForm,
+    feedbackIcons,
+    tooltip: mergedTooltip,
+    classNames: mergedClassNames,
+    styles: mergedStyles
+  }), [name, mergedLabelAlign, mergedLabelWrap, labelCol, wrapperCol, layout, mergedColon, mergedRequiredMark, wrapForm, feedbackIcons, mergedClassNames, mergedStyles, mergedTooltip]);
+  const nativeElementRef = useRef(null);
+  useImperativeHandle(ref, () => ({
+    ...wrapForm,
+    nativeElement: nativeElementRef.current?.nativeElement
+  }));
+  const scrollToField = (options, fieldName) => {
+    if (options) {
+      let defaultScrollToFirstError = {
+        block: "nearest"
+      };
+      if (isPlainObject(options)) {
+        defaultScrollToFirstError = {
+          ...defaultScrollToFirstError,
+          ...options
+        };
+      }
+      wrapForm.scrollToField(fieldName, defaultScrollToFirstError);
+    }
+  };
+  const onInternalFinishFailed = (errorInfo) => {
+    onFinishFailed?.(errorInfo);
+    if (errorInfo.errorFields.length) {
+      const fieldName = errorInfo.errorFields[0].name;
+      if (scrollToFirstError !== void 0) {
+        scrollToField(scrollToFirstError, fieldName);
+        return;
+      }
+      if (contextScrollToFirstError !== void 0) {
+        scrollToField(contextScrollToFirstError, fieldName);
+      }
+    }
+  };
+  return /* @__PURE__ */ createElement(VariantContext.Provider, {
+    value: variant
+  }, /* @__PURE__ */ createElement(DisabledContextProvider, {
+    disabled
+  }, /* @__PURE__ */ createElement(SizeContext_default.Provider, {
+    value: mergedSize
+  }, /* @__PURE__ */ createElement(FormProvider, {
+    // This is not list in API, we pass with spread
+    validateMessages: contextValidateMessages
+  }, /* @__PURE__ */ createElement(FormContext.Provider, {
+    value: formContextValue
+  }, /* @__PURE__ */ createElement(NoFormStyle, {
+    status: true
+  }, /* @__PURE__ */ createElement(es_default2, {
+    id: name,
+    ...restFormProps,
+    name,
+    onFinishFailed: onInternalFinishFailed,
+    form: wrapForm,
+    ref: nativeElementRef,
+    style: mergedStyles?.root,
+    className: formClassName
+  })))))));
+};
+var Form = /* @__PURE__ */ forwardRef(InternalForm);
+if (true) {
+  Form.displayName = "Form";
+}
+var Form_default = Form;
+
+// ../../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/form/hooks/useChildren.js
+var useChildren = (children) => {
+  if (isFunction(children)) {
+    return children;
+  }
+  const childList = toArray(children);
+  return childList.length <= 1 ? childList[0] : childList;
+};
+var useChildren_default = useChildren;
+
+// ../../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/form/hooks/useFormItemStatus.js
+var useFormItemStatus = () => {
+  const {
+    status,
+    errors = [],
+    warnings = []
+  } = useContext(FormItemInputContext);
+  if (true) {
+    const warning = useDevWarning("Form.Item");
+    true ? warning(status !== void 0, "usage", "Form.Item.useStatus should be used under Form.Item component. For more information: https://u.ant.design/form-item-usestatus") : void 0;
+  }
+  return {
+    status,
+    errors,
+    warnings
+  };
+};
+useFormItemStatus.Context = FormItemInputContext;
+var useFormItemStatus_default = useFormItemStatus;
+
+// ../../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/form/hooks/useFrameState.js
+function useFrameState(defaultValue) {
+  const [value, setValue] = useState(defaultValue);
+  const frameRef = useRef(null);
+  const batchRef = useRef([]);
+  const destroyRef = useRef(false);
+  useEffect(() => {
+    destroyRef.current = false;
+    return () => {
+      destroyRef.current = true;
+      raf_default.cancel(frameRef.current);
+      frameRef.current = null;
+    };
+  }, []);
+  function setFrameValue(updater) {
+    if (destroyRef.current) {
+      return;
+    }
+    if (frameRef.current === null) {
+      batchRef.current = [];
+      frameRef.current = raf_default(() => {
+        frameRef.current = null;
+        setValue((prevValue) => {
+          let current = prevValue;
+          batchRef.current.forEach((func) => {
+            current = func(current);
+          });
+          return current;
+        });
+      });
+    }
+    batchRef.current.push(updater);
+  }
+  return [value, setFrameValue];
+}
+
+// ../../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/form/hooks/useItemRef.js
+var useItemRef = () => {
+  const {
+    itemRef
+  } = useContext(FormContext);
+  const cacheRef = useRef({});
+  const getRef = (name, children) => {
+    const childrenRef = children && isPlainObject(children) && getNodeRef(children);
+    const nameStr = name.join("_");
+    if (cacheRef.current.name !== nameStr || cacheRef.current.originRef !== childrenRef) {
+      cacheRef.current.name = nameStr;
+      cacheRef.current.originRef = childrenRef;
+      cacheRef.current.ref = composeRef(itemRef(name), childrenRef);
+    }
+    return cacheRef.current.ref;
+  };
+  return getRef;
+};
+var useItemRef_default = useItemRef;
+
+// ../../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/form/style/fallbackCmp.js
+var genFallbackStyle = (token) => {
+  const {
+    formItemCls
+  } = token;
+  return {
+    "@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none)": {
+      // Fallback for IE, safe to remove we not support it anymore
+      [`${formItemCls}-control`]: {
+        display: "flex"
+      }
+    }
+  };
+};
+var fallbackCmp_default = genSubStyleComponent(["Form", "item-item"], (token, {
+  rootPrefixCls
+}) => {
+  const formToken = prepareToken(token, rootPrefixCls);
+  return genFallbackStyle(formToken);
+});
+
+// ../../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/form/FormItemInput.js
+var GRID_MAX = 24;
+var FormItemInput = (props) => {
+  const {
+    prefixCls,
+    status,
+    labelCol,
+    wrapperCol,
+    children,
+    errors,
+    warnings,
+    _internalItemRender: formItemRender,
+    extra,
+    help,
+    fieldId,
+    marginBottom,
+    onErrorVisibleChanged,
+    label
+  } = props;
+  const baseClassName = `${prefixCls}-item`;
+  const formContext = useContext(FormContext);
+  const {
+    classNames: contextClassNames,
+    styles: contextStyles
+  } = formContext;
+  const mergedWrapperCol = useMemo(() => {
+    let mergedWrapper = {
+      ...wrapperCol || formContext.wrapperCol || {}
+    };
+    if (label === null && !labelCol && !wrapperCol && formContext.labelCol) {
+      const list = [void 0].concat(_toConsumableArray(responsiveArrayReversed));
+      list.forEach((size) => {
+        const _size = size ? [size] : [];
+        const formLabel = get(formContext.labelCol, _size);
+        const formLabelObj = isPlainObject(formLabel) ? formLabel : {};
+        const wrapper = get(mergedWrapper, _size);
+        const wrapperObj = isPlainObject(wrapper) ? wrapper : {};
+        if ("span" in formLabelObj && !("offset" in wrapperObj) && formLabelObj.span < GRID_MAX) {
+          mergedWrapper = set(mergedWrapper, [].concat(_size, ["offset"]), formLabelObj.span);
+        }
+      });
+    }
+    return mergedWrapper;
+  }, [wrapperCol, formContext.wrapperCol, formContext.labelCol, label, labelCol]);
+  const className = clsx(`${baseClassName}-control`, mergedWrapperCol.className);
+  const subFormContext = useMemo(() => {
+    const {
+      labelCol: _labelCol,
+      wrapperCol: _wrapperCol,
+      ...rest
+    } = formContext;
+    return rest;
+  }, [formContext]);
+  const extraRef = useRef(null);
+  const [extraHeight, setExtraHeight] = useState(0);
+  useLayoutEffect_default(() => {
+    if (extra && extraRef.current) {
+      setExtraHeight(extraRef.current.clientHeight);
+    } else {
+      setExtraHeight(0);
+    }
+  }, [extra]);
+  const inputDom = /* @__PURE__ */ createElement("div", {
+    className: `${baseClassName}-control-input`
+  }, /* @__PURE__ */ createElement("div", {
+    className: clsx(`${baseClassName}-control-input-content`, contextClassNames?.content),
+    style: contextStyles?.content
+  }, children));
+  const formItemContext = useMemo(() => ({
+    prefixCls,
+    status
+  }), [prefixCls, status]);
+  const errorListDom = marginBottom !== null || errors.length || warnings.length ? /* @__PURE__ */ createElement(FormItemPrefixContext.Provider, {
+    value: formItemContext
+  }, /* @__PURE__ */ createElement(ErrorList_default, {
+    fieldId,
+    errors,
+    warnings,
+    help,
+    helpStatus: status,
+    className: `${baseClassName}-explain-connected`,
+    onVisibleChanged: onErrorVisibleChanged
+  })) : null;
+  const extraProps = {};
+  if (fieldId) {
+    extraProps.id = `${fieldId}_extra`;
+  }
+  const extraDom = extra ? /* @__PURE__ */ createElement("div", {
+    ...extraProps,
+    className: clsx(`${baseClassName}-extra`, contextClassNames?.extra),
+    style: contextStyles?.extra,
+    ref: extraRef
+  }, extra) : null;
+  const additionalDom = errorListDom || extraDom ? /* @__PURE__ */ createElement("div", {
+    className: `${baseClassName}-additional`,
+    style: marginBottom ? {
+      minHeight: marginBottom + extraHeight
+    } : {}
+  }, errorListDom, extraDom) : null;
+  const dom = formItemRender && formItemRender.mark === "pro_table_render" && formItemRender.render ? formItemRender.render(props, {
+    input: inputDom,
+    errorList: errorListDom,
+    extra: extraDom
+  }) : /* @__PURE__ */ createElement(Fragment, null, inputDom, additionalDom);
+  return /* @__PURE__ */ createElement(FormContext.Provider, {
+    value: subFormContext
+  }, /* @__PURE__ */ createElement(col_default, {
+    ...mergedWrapperCol,
+    className
+  }, dom), /* @__PURE__ */ createElement(fallbackCmp_default, {
+    prefixCls
+  }));
+};
+var FormItemInput_default = FormItemInput;
+
+// ../../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/QuestionCircleOutlined.js
+var import_QuestionCircleOutlined = __toESM(require_QuestionCircleOutlined());
+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 QuestionCircleOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends3({}, props, {
+  ref,
+  icon: import_QuestionCircleOutlined.default
+}));
+var RefIcon2 = /* @__PURE__ */ forwardRef(QuestionCircleOutlined);
+if (true) {
+  RefIcon2.displayName = "QuestionCircleOutlined";
+}
+var QuestionCircleOutlined_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/form/FormItemLabel.js
+var FormItemLabel = ({
+  prefixCls,
+  label,
+  htmlFor,
+  labelCol,
+  labelAlign,
+  colon,
+  required,
+  requiredMark,
+  tooltip,
+  vertical
+}) => {
+  const [formLocale] = useLocale_default("Form");
+  const {
+    labelAlign: contextLabelAlign,
+    labelCol: contextLabelCol,
+    labelWrap,
+    colon: contextColon,
+    classNames: contextClassNames,
+    styles: contextStyles,
+    tooltip: contextTooltip
+  } = useContext(FormContext);
+  if (!label) {
+    return null;
+  }
+  const mergedLabelCol = labelCol || contextLabelCol || {};
+  const mergedLabelAlign = labelAlign || contextLabelAlign;
+  const labelClsBasic = `${prefixCls}-item-label`;
+  const labelColClassName = clsx(labelClsBasic, mergedLabelAlign === "left" && `${labelClsBasic}-left`, mergedLabelCol.className, {
+    [`${labelClsBasic}-wrap`]: !!labelWrap
+  });
+  let labelChildren = label;
+  const computedColon = colon === true || contextColon !== false && colon !== false;
+  const haveColon = computedColon && !vertical;
+  if (haveColon && typeof label === "string" && label.trim()) {
+    labelChildren = label.replace(/[:|：]\s*$/, "");
+  }
+  const tooltipProps = convertToTooltipProps_default(tooltip, contextTooltip);
+  if (tooltipProps) {
+    const tooltipNode = /* @__PURE__ */ createElement(tooltip_default, {
+      ...tooltipProps
+    }, /* @__PURE__ */ createElement("span", {
+      className: `${prefixCls}-item-tooltip`,
+      onClick: (e3) => {
+        e3.preventDefault();
+      },
+      tabIndex: -1
+    }, tooltipProps.icon || tooltipProps.children || /* @__PURE__ */ createElement(QuestionCircleOutlined_default, null)));
+    labelChildren = /* @__PURE__ */ createElement(Fragment, null, labelChildren, tooltipNode);
+  }
+  const isOptionalMark = requiredMark === "optional";
+  const isRenderMark = isFunction(requiredMark);
+  const hideRequiredMark = requiredMark === false;
+  if (isRenderMark) {
+    labelChildren = requiredMark(labelChildren, {
+      required: !!required
+    });
+  } else if (isOptionalMark && !required) {
+    labelChildren = /* @__PURE__ */ createElement(Fragment, null, labelChildren, /* @__PURE__ */ createElement("span", {
+      className: `${prefixCls}-item-optional`
+    }, formLocale?.optional || en_US_default.Form?.optional));
+  }
+  let markType;
+  if (hideRequiredMark) {
+    markType = "hidden";
+  } else if (isOptionalMark || isRenderMark) {
+    markType = "optional";
+  }
+  const labelClassName = clsx(contextClassNames?.label, {
+    [`${prefixCls}-item-required`]: required,
+    [`${prefixCls}-item-required-mark-${markType}`]: markType,
+    [`${prefixCls}-item-no-colon`]: !computedColon
+  });
+  return /* @__PURE__ */ createElement(col_default, {
+    ...mergedLabelCol,
+    className: labelColClassName
+  }, /* @__PURE__ */ createElement("label", {
+    htmlFor,
+    className: labelClassName,
+    style: contextStyles?.label,
+    title: typeof label === "string" ? label : void 0
+  }, labelChildren));
+};
+var FormItemLabel_default = FormItemLabel;
+
+// ../../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/form/FormItem/StatusProvider.js
+var iconMap = {
+  success: CheckCircleFilled_default,
+  warning: ExclamationCircleFilled_default,
+  error: CloseCircleFilled_default,
+  validating: LoadingOutlined_default
+};
+function StatusProvider({
+  children,
+  errors,
+  warnings,
+  hasFeedback,
+  validateStatus,
+  prefixCls,
+  meta,
+  noStyle,
+  name
+}) {
+  const itemPrefixCls = `${prefixCls}-item`;
+  const {
+    feedbackIcons
+  } = useContext(FormContext);
+  const mergedValidateStatus = getStatus(errors, warnings, meta, null, !!hasFeedback, validateStatus);
+  const {
+    isFormItemInput: parentIsFormItemInput,
+    status: parentStatus,
+    hasFeedback: parentHasFeedback,
+    feedbackIcon: parentFeedbackIcon,
+    name: parentName
+  } = useContext(FormItemInputContext);
+  const formItemStatusContext = useMemo(() => {
+    let feedbackIcon;
+    if (hasFeedback) {
+      const customIcons = hasFeedback !== true && hasFeedback.icons || feedbackIcons;
+      const customIconNode = mergedValidateStatus && customIcons?.({
+        status: mergedValidateStatus,
+        errors,
+        warnings
+      })?.[mergedValidateStatus];
+      const IconNode = mergedValidateStatus ? iconMap[mergedValidateStatus] : null;
+      feedbackIcon = customIconNode !== false && IconNode ? /* @__PURE__ */ createElement("span", {
+        className: clsx(`${itemPrefixCls}-feedback-icon`, `${itemPrefixCls}-feedback-icon-${mergedValidateStatus}`)
+      }, customIconNode || /* @__PURE__ */ createElement(IconNode, null)) : null;
+    }
+    const context = {
+      status: mergedValidateStatus || "",
+      errors,
+      warnings,
+      hasFeedback: !!hasFeedback,
+      feedbackIcon,
+      isFormItemInput: true,
+      name
+    };
+    if (noStyle) {
+      context.status = (mergedValidateStatus ?? parentStatus) || "";
+      context.isFormItemInput = parentIsFormItemInput;
+      context.hasFeedback = !!(hasFeedback ?? parentHasFeedback);
+      context.feedbackIcon = hasFeedback !== void 0 ? context.feedbackIcon : parentFeedbackIcon;
+      context.name = name ?? parentName;
+    }
+    return context;
+  }, [mergedValidateStatus, errors, warnings, hasFeedback, feedbackIcons, noStyle, name, parentIsFormItemInput, parentStatus, itemPrefixCls, parentHasFeedback, parentFeedbackIcon, parentName]);
+  return /* @__PURE__ */ createElement(FormItemInputContext.Provider, {
+    value: formItemStatusContext
+  }, children);
+}
+var StatusProvider_default = StatusProvider;
+
+// ../../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/form/FormItem/ItemHolder.js
+function ItemHolder(props) {
+  const {
+    prefixCls,
+    className,
+    rootClassName,
+    style,
+    help,
+    errors,
+    warnings,
+    validateStatus,
+    meta,
+    hasFeedback,
+    hidden,
+    children,
+    fieldId,
+    required,
+    isRequired,
+    onSubItemMetaChange,
+    layout: propsLayout,
+    name,
+    ...restProps
+  } = props;
+  const itemPrefixCls = `${prefixCls}-item`;
+  const {
+    requiredMark,
+    layout: formLayout
+  } = useContext(FormContext);
+  const layout = propsLayout || formLayout;
+  const vertical = layout === "vertical";
+  const itemRef = useRef(null);
+  const debounceErrors = useDebounce(errors);
+  const debounceWarnings = useDebounce(warnings);
+  const hasHelp = isNonNullable(help);
+  const hasError = !!(hasHelp || debounceErrors.length || debounceWarnings.length);
+  const isOnScreen = !!itemRef.current && isVisible_default(itemRef.current);
+  const [marginBottom, setMarginBottom] = useState(null);
+  useLayoutEffect_default(() => {
+    if (hasError && itemRef.current) {
+      const itemStyle = getComputedStyle(itemRef.current);
+      setMarginBottom(Number.parseInt(itemStyle.marginBottom, 10));
+    }
+  }, [hasError, isOnScreen]);
+  const onErrorVisibleChanged = (nextVisible) => {
+    if (!nextVisible && !hasError) {
+      setMarginBottom(null);
+    }
+  };
+  const getValidateState = (isDebounce = false) => {
+    const _errors = isDebounce ? debounceErrors : meta.errors;
+    const _warnings = isDebounce ? debounceWarnings : meta.warnings;
+    return getStatus(_errors, _warnings, meta, "", !!hasFeedback, validateStatus);
+  };
+  const mergedValidateStatus = getValidateState();
+  const itemClassName = clsx(itemPrefixCls, className, rootClassName, {
+    [`${itemPrefixCls}-with-help`]: hasHelp || debounceErrors.length || debounceWarnings.length,
+    // Status
+    [`${itemPrefixCls}-has-feedback`]: mergedValidateStatus && hasFeedback,
+    [`${itemPrefixCls}-has-success`]: mergedValidateStatus === "success",
+    [`${itemPrefixCls}-has-warning`]: mergedValidateStatus === "warning",
+    [`${itemPrefixCls}-has-error`]: mergedValidateStatus === "error",
+    [`${itemPrefixCls}-is-validating`]: mergedValidateStatus === "validating",
+    [`${itemPrefixCls}-hidden`]: hidden,
+    // Layout
+    [`${itemPrefixCls}-${layout}`]: layout
+  });
+  return /* @__PURE__ */ createElement("div", {
+    className: itemClassName,
+    style,
+    ref: itemRef
+  }, /* @__PURE__ */ createElement(row_default, {
+    className: `${itemPrefixCls}-row`,
+    ...omit(restProps, [
+      "_internalItemRender",
+      "colon",
+      "dependencies",
+      "extra",
+      "fieldKey",
+      "getValueFromEvent",
+      "getValueProps",
+      "htmlFor",
+      "id",
+      // It is deprecated because `htmlFor` is its replacement.
+      "initialValue",
+      "isListField",
+      "label",
+      "labelAlign",
+      "labelCol",
+      "labelWrap",
+      "messageVariables",
+      "name",
+      "normalize",
+      "noStyle",
+      "preserve",
+      "requiredMark",
+      "rules",
+      "shouldUpdate",
+      "trigger",
+      "tooltip",
+      "validateFirst",
+      "validateTrigger",
+      "valuePropName",
+      "wrapperCol",
+      "validateDebounce"
+    ])
+  }, /* @__PURE__ */ createElement(FormItemLabel_default, {
+    htmlFor: fieldId,
+    ...props,
+    requiredMark,
+    required: required ?? isRequired,
+    prefixCls,
+    vertical
+  }), /* @__PURE__ */ createElement(FormItemInput_default, {
+    ...props,
+    ...meta,
+    errors: debounceErrors,
+    warnings: debounceWarnings,
+    prefixCls,
+    status: mergedValidateStatus,
+    help,
+    marginBottom,
+    onErrorVisibleChanged
+  }, /* @__PURE__ */ createElement(NoStyleItemContext.Provider, {
+    value: onSubItemMetaChange
+  }, /* @__PURE__ */ createElement(StatusProvider_default, {
+    prefixCls,
+    meta,
+    errors: meta.errors,
+    warnings: meta.warnings,
+    hasFeedback,
+    // Already calculated
+    validateStatus: mergedValidateStatus,
+    name
+  }, children)))), !!marginBottom && /* @__PURE__ */ createElement("div", {
+    className: `${itemPrefixCls}-margin-offset`,
+    style: {
+      marginBottom: -marginBottom
+    }
+  }));
+}
+
+// ../../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/form/FormItem/index.js
+var NAME_SPLIT = "__SPLIT__";
+function isSimilarControl(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  return keysA.length === keysB.length && keysA.every((key) => {
+    const propValueA = a[key];
+    const propValueB = b[key];
+    return propValueA === propValueB || isFunction(propValueA) || isFunction(propValueB);
+  });
+}
+var MemoInput = /* @__PURE__ */ memo((props) => props.children, (prev, next) => isSimilarControl(prev.control, next.control) && prev.update === next.update && prev.childProps.length === next.childProps.length && prev.childProps.every((value, index) => value === next.childProps[index]));
+function genEmptyMeta() {
+  return {
+    errors: [],
+    warnings: [],
+    touched: false,
+    validating: false,
+    name: [],
+    validated: false
+  };
+}
+function InternalFormItem(props) {
+  const {
+    name,
+    noStyle,
+    className,
+    dependencies,
+    prefixCls: customizePrefixCls,
+    shouldUpdate,
+    rules,
+    children,
+    required,
+    label,
+    messageVariables,
+    trigger = "onChange",
+    validateTrigger,
+    hidden,
+    help,
+    layout
+  } = props;
+  const {
+    getPrefixCls
+  } = useContext(ConfigContext);
+  const {
+    name: formName
+  } = useContext(FormContext);
+  const mergedChildren = useChildren_default(children);
+  const isRenderProps = isFunction(mergedChildren);
+  const notifyParentMetaChange = useContext(NoStyleItemContext);
+  const {
+    validateTrigger: contextValidateTrigger
+  } = useContext(FieldContext_default);
+  const mergedValidateTrigger = isNonNullable(validateTrigger) ? validateTrigger : contextValidateTrigger;
+  const hasName = isNonNullable(name);
+  const prefixCls = getPrefixCls("form", customizePrefixCls);
+  const rootCls = useCSSVarCls_default(prefixCls);
+  const [hashId, cssVarCls] = style_default3(prefixCls, rootCls);
+  const warning = useDevWarning("Form.Item");
+  if (true) {
+    true ? warning(name !== null, "usage", "`null` is passed as `name` property") : void 0;
+  }
+  const listContext = useContext(ListContext_default);
+  const fieldKeyPathRef = useRef(null);
+  const [subFieldErrors, setSubFieldErrors] = useFrameState({});
+  const [meta, setMeta] = useState_default(() => genEmptyMeta());
+  const onMetaChange = (nextMeta) => {
+    const keyInfo = listContext?.getKey(nextMeta.name);
+    setMeta(nextMeta.destroy ? genEmptyMeta() : nextMeta, true);
+    if (noStyle && help !== false && notifyParentMetaChange) {
+      let namePath = nextMeta.name;
+      if (!nextMeta.destroy) {
+        if (keyInfo !== void 0) {
+          const [fieldKey, restPath] = keyInfo;
+          namePath = [fieldKey].concat(_toConsumableArray(restPath));
+          fieldKeyPathRef.current = namePath;
+        }
+      } else {
+        namePath = fieldKeyPathRef.current || namePath;
+      }
+      notifyParentMetaChange(nextMeta, namePath);
+    }
+  };
+  const onSubItemMetaChange = (subMeta, uniqueKeys) => {
+    setSubFieldErrors((prevSubFieldErrors) => {
+      const clone = {
+        ...prevSubFieldErrors
+      };
+      const mergedNamePath = [].concat(_toConsumableArray(subMeta.name.slice(0, -1)), _toConsumableArray(uniqueKeys));
+      const mergedNameKey = mergedNamePath.join(NAME_SPLIT);
+      if (subMeta.destroy) {
+        delete clone[mergedNameKey];
+      } else {
+        clone[mergedNameKey] = subMeta;
+      }
+      return clone;
+    });
+  };
+  const [mergedErrors, mergedWarnings] = useMemo(() => {
+    const errorList = _toConsumableArray(meta.errors);
+    const warningList = _toConsumableArray(meta.warnings);
+    Object.values(subFieldErrors).forEach((subFieldError) => {
+      errorList.push.apply(errorList, _toConsumableArray(subFieldError.errors || []));
+      warningList.push.apply(warningList, _toConsumableArray(subFieldError.warnings || []));
+    });
+    return [errorList, warningList];
+  }, [subFieldErrors, meta.errors, meta.warnings]);
+  const getItemRef = useItemRef_default();
+  function renderLayout(baseChildren, fieldId, isRequired) {
+    if (noStyle && !hidden) {
+      return /* @__PURE__ */ createElement(StatusProvider_default, {
+        prefixCls,
+        hasFeedback: props.hasFeedback,
+        validateStatus: props.validateStatus,
+        meta,
+        errors: mergedErrors,
+        warnings: mergedWarnings,
+        noStyle: true,
+        name
+      }, baseChildren);
+    }
+    return /* @__PURE__ */ createElement(ItemHolder, {
+      key: "row",
+      ...props,
+      className: clsx(className, cssVarCls, rootCls, hashId),
+      prefixCls,
+      fieldId,
+      isRequired,
+      errors: mergedErrors,
+      warnings: mergedWarnings,
+      meta,
+      onSubItemMetaChange,
+      layout,
+      name
+    }, baseChildren);
+  }
+  if (!hasName && !isRenderProps && !dependencies) {
+    return renderLayout(mergedChildren);
+  }
+  let variables = {};
+  if (typeof label === "string") {
+    variables.label = label;
+  } else if (name) {
+    variables.label = String(name);
+  }
+  if (messageVariables) {
+    variables = {
+      ...variables,
+      ...messageVariables
+    };
+  }
+  return /* @__PURE__ */ createElement(Field_default, {
+    ...props,
+    messageVariables: variables,
+    trigger,
+    validateTrigger: mergedValidateTrigger,
+    onMetaChange
+  }, (control, renderMeta, context) => {
+    const mergedName = toArray2(name).length && renderMeta ? renderMeta.name : [];
+    const fieldId = getFieldId(mergedName, formName);
+    const isRequired = required !== void 0 ? required : rules?.some((rule) => {
+      if (isPlainObject(rule) && rule.required && !rule.warningOnly) {
+        return true;
+      }
+      if (isFunction(rule)) {
+        const ruleEntity = rule(context);
+        return ruleEntity?.required && !ruleEntity?.warningOnly;
+      }
+      return false;
+    });
+    const mergedControl = {
+      ...control
+    };
+    let childNode = null;
+    true ? warning(!(shouldUpdate && dependencies), "usage", "`shouldUpdate` and `dependencies` shouldn't be used together. See https://u.ant.design/form-deps.") : void 0;
+    if (Array.isArray(mergedChildren) && hasName) {
+      true ? warning(false, "usage", "A `Form.Item` with a `name` prop must have a single child element. For information on how to render more complex form items, see https://u.ant.design/complex-form-item.") : void 0;
+      childNode = mergedChildren;
+    } else if (isRenderProps && (!(shouldUpdate || dependencies) || hasName)) {
+      true ? warning(!!(shouldUpdate || dependencies), "usage", "A `Form.Item` with a render function must have either `shouldUpdate` or `dependencies`.") : void 0;
+      true ? warning(!hasName, "usage", "A `Form.Item` with a render function cannot be a field, and thus cannot have a `name` prop.") : void 0;
+    } else if (dependencies && !isRenderProps && !hasName) {
+      true ? warning(false, "usage", "Must set `name` or use a render function when `dependencies` is set.") : void 0;
+    } else if (/* @__PURE__ */ isValidElement(mergedChildren)) {
+      true ? warning(mergedChildren.props.defaultValue === void 0, "usage", "`defaultValue` will not work on controlled Field. You should use `initialValues` of Form instead.") : void 0;
+      const childProps = {
+        ...mergedChildren.props,
+        ...mergedControl
+      };
+      if (!childProps.id) {
+        childProps.id = fieldId;
+      }
+      if (help || mergedErrors.length > 0 || mergedWarnings.length > 0 || props.extra) {
+        const describedbyArr = [];
+        if (help || mergedErrors.length > 0) {
+          describedbyArr.push(`${fieldId}_help`);
+        }
+        if (props.extra) {
+          describedbyArr.push(`${fieldId}_extra`);
+        }
+        childProps["aria-describedby"] = describedbyArr.join(" ");
+      }
+      if (mergedErrors.length > 0) {
+        childProps["aria-invalid"] = "true";
+      }
+      if (isRequired) {
+        childProps["aria-required"] = "true";
+      }
+      if (supportRef(mergedChildren)) {
+        childProps.ref = getItemRef(mergedName, mergedChildren);
+      }
+      const triggers = new Set([].concat(_toConsumableArray(toArray2(trigger)), _toConsumableArray(toArray2(mergedValidateTrigger))));
+      triggers.forEach((eventName) => {
+        childProps[eventName] = (...args) => {
+          mergedControl[eventName]?.(...args);
+          mergedChildren.props[eventName]?.(...args);
+        };
+      });
+      const watchingChildProps = [childProps["aria-required"], childProps["aria-invalid"], childProps["aria-describedby"]];
+      childNode = /* @__PURE__ */ createElement(MemoInput, {
+        control: mergedControl,
+        update: mergedChildren,
+        childProps: watchingChildProps
+      }, cloneElement(mergedChildren, childProps));
+    } else if (isRenderProps && (shouldUpdate || dependencies) && !hasName) {
+      childNode = mergedChildren(context);
+    } else {
+      true ? warning(!mergedName.length || !!noStyle, "usage", "`name` is only used for validate React element. If you are using Form.Item as layout display, please remove `name` instead.") : void 0;
+      childNode = mergedChildren;
+    }
+    return renderLayout(childNode, fieldId, isRequired);
+  });
+}
+var FormItem = InternalFormItem;
+FormItem.useStatus = useFormItemStatus_default;
+var FormItem_default = FormItem;
+
+// ../../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/form/FormList.js
+var FormList = ({
+  prefixCls: customizePrefixCls,
+  children,
+  ...props
+}) => {
+  if (true) {
+    const warning = useDevWarning("Form.List");
+    true ? warning(isNumber(props.name) || (Array.isArray(props.name) ? !!props.name.length : !!props.name), "usage", "Miss `name` prop.") : void 0;
+  }
+  const {
+    getPrefixCls
+  } = useContext(ConfigContext);
+  const prefixCls = getPrefixCls("form", customizePrefixCls);
+  const contextValue = useMemo(() => ({
+    prefixCls,
+    status: "error"
+  }), [prefixCls]);
+  return /* @__PURE__ */ createElement(List_default, {
+    ...props
+  }, (fields, operation, meta) => /* @__PURE__ */ createElement(FormItemPrefixContext.Provider, {
+    value: contextValue
+  }, children(fields.map((field) => ({
+    ...field,
+    fieldKey: field.key
+  })), operation, {
+    errors: meta.errors,
+    warnings: meta.warnings
+  })));
+};
+var FormList_default = FormList;
+
+// ../../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/form/hooks/useFormInstance.js
+function useFormInstance() {
+  const {
+    form
+  } = useContext(FormContext);
+  return form;
+}
+
+// ../../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/form/index.js
+var Form2 = Form_default;
+Form2.Item = FormItem_default;
+Form2.List = FormList_default;
+Form2.ErrorList = ErrorList_default;
+Form2.useForm = useForm;
+Form2.useFormInstance = useFormInstance;
+Form2.useWatch = useWatch_default;
+Form2.Provider = FormProvider;
+var form_default = Form2;
+
+// ../../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/input/Group.js
+var Group = (props) => {
+  const {
+    getPrefixCls,
+    direction
+  } = useContext(ConfigContext);
+  const {
+    prefixCls: customizePrefixCls,
+    className
+  } = props;
+  const prefixCls = getPrefixCls("input-group", customizePrefixCls);
+  const inputPrefixCls = getPrefixCls("input");
+  const [hashId, cssVarCls] = style_default(inputPrefixCls);
+  const cls = clsx(prefixCls, cssVarCls, {
+    [`${prefixCls}-lg`]: props.size === "large",
+    [`${prefixCls}-sm`]: props.size === "small",
+    [`${prefixCls}-compact`]: props.compact,
+    [`${prefixCls}-rtl`]: direction === "rtl"
+  }, hashId, className);
+  const formItemContext = useContext(FormItemInputContext);
+  const groupFormItemContext = useMemo(() => ({
+    ...formItemContext,
+    isFormItemInput: false
+  }), [formItemContext]);
+  if (true) {
+    const warning = devUseWarning("Input.Group");
+    warning.deprecated(false, "Input.Group", "Space.Compact");
+  }
+  return /* @__PURE__ */ createElement(FormItemInputContext.Provider, {
+    value: groupFormItemContext
+  }, /* @__PURE__ */ createElement(space_default.Compact, {
+    className: cls,
+    style: props.style,
+    onMouseEnter: props.onMouseEnter,
+    onMouseLeave: props.onMouseLeave,
+    onFocus: props.onFocus,
+    onBlur: props.onBlur
+  }, props.children));
+};
+var Group_default = Group;
+
+// ../../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/input/style/otp.js
+var genOTPStyle = (token) => {
+  const {
+    componentCls,
+    paddingXS
+  } = token;
+  return {
+    [componentCls]: {
+      display: "inline-flex",
+      alignItems: "center",
+      flexWrap: "nowrap",
+      columnGap: paddingXS,
+      [`${componentCls}-input-wrapper`]: {
+        position: "relative",
+        [`${componentCls}-mask-icon`]: {
+          position: "absolute",
+          zIndex: "1",
+          top: "50%",
+          right: "50%",
+          transform: "translate(50%, -50%)",
+          pointerEvents: "none"
+        },
+        [`${componentCls}-mask-input`]: {
+          color: "transparent",
+          caretColor: token.colorText,
+          "&::selection": {
+            color: "transparent"
+          }
+        },
+        [`${componentCls}-mask-input[type=number]::-webkit-inner-spin-button`]: {
+          "-webkit-appearance": "none",
+          margin: 0
+        },
+        [`${componentCls}-mask-input[type=number]`]: {
+          "-moz-appearance": "textfield"
+        }
+      },
+      "&-rtl": {
+        direction: "rtl"
+      },
+      [`${componentCls}-input`]: {
+        textAlign: "center",
+        paddingInline: token.paddingXXS
+      },
+      // ================= Size =================
+      [`&${componentCls}-sm ${componentCls}-input`]: {
+        paddingInline: token.calc(token.paddingXXS).div(2).equal()
+      },
+      [`&${componentCls}-lg ${componentCls}-input`]: {
+        paddingInline: token.paddingXS
+      }
+    }
+  };
+};
+var otp_default = genStyleHooks(["Input", "OTP"], (token) => {
+  const inputToken = merge(token, initInputToken(token));
+  return genOTPStyle(inputToken);
+}, initComponentToken);
+
+// ../../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/input/OTP/OTPInput.js
+var DEFAULT_MASK_VALUE = "\u2022";
+var OTPInput = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    className,
+    value,
+    onChange,
+    onActiveChange,
+    index,
+    mask,
+    onFocus,
+    type,
+    ...restProps
+  } = props;
+  const {
+    getPrefixCls
+  } = useContext(ConfigContext);
+  const prefixCls = getPrefixCls("otp");
+  const maskValue = typeof mask === "string" ? mask : DEFAULT_MASK_VALUE;
+  const inputRef = useRef(null);
+  useImperativeHandle(ref, () => inputRef.current);
+  const onInternalChange = (e3) => {
+    onChange(index, e3.target.value);
+  };
+  const syncSelection = () => {
+    raf_default(() => {
+      const inputEle = inputRef.current?.input;
+      if (document.activeElement === inputEle && inputEle) {
+        inputEle.select();
+      }
+    });
+  };
+  const onInternalFocus = (e3) => {
+    onFocus?.(e3);
+    syncSelection();
+  };
+  const onInternalKeyDown = (event) => {
+    const {
+      key,
+      ctrlKey,
+      metaKey
+    } = event;
+    if (key === "ArrowLeft") {
+      onActiveChange(index - 1);
+    } else if (key === "ArrowRight") {
+      onActiveChange(index + 1);
+    } else if (key === "z" && (ctrlKey || metaKey)) {
+      event.preventDefault();
+    } else if (key === "Backspace" && !value) {
+      onActiveChange(index - 1);
+    }
+    syncSelection();
+  };
+  return /* @__PURE__ */ createElement("span", {
+    className: `${prefixCls}-input-wrapper`,
+    role: "presentation"
+  }, mask && value !== "" && value !== void 0 && /* @__PURE__ */ createElement("span", {
+    className: `${prefixCls}-mask-icon`,
+    "aria-hidden": "true"
+  }, maskValue), /* @__PURE__ */ createElement(Input_default, {
+    "aria-label": `OTP Input ${index + 1}`,
+    ...restProps,
+    type: type ?? (mask ? "password" : "text"),
+    ref: inputRef,
+    value,
+    onInput: onInternalChange,
+    onFocus: onInternalFocus,
+    onKeyDown: onInternalKeyDown,
+    onMouseDown: syncSelection,
+    onMouseUp: syncSelection,
+    className: clsx(className, {
+      [`${prefixCls}-mask-input`]: mask
+    })
+  }));
+});
+var OTPInput_default = OTPInput;
+
+// ../../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/input/OTP/index.js
+function strToArr(str) {
+  return (str || "").split("");
+}
+var Separator = (props) => {
+  const {
+    index,
+    prefixCls,
+    separator,
+    className: semanticClassName,
+    style: semanticStyle
+  } = props;
+  const separatorNode = isFunction(separator) ? separator(index) : separator;
+  if (!separatorNode) {
+    return null;
+  }
+  return /* @__PURE__ */ createElement("span", {
+    className: clsx(`${prefixCls}-separator`, semanticClassName),
+    style: semanticStyle
+  }, separatorNode);
+};
+var OTP = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    length = 6,
+    size: customSize,
+    defaultValue,
+    value,
+    onChange,
+    formatter,
+    separator,
+    variant: customizeVariant,
+    disabled,
+    status: customStatus,
+    autoFocus,
+    mask,
+    type,
+    autoComplete,
+    onInput,
+    onFocus,
+    inputMode,
+    classNames,
+    styles,
+    className,
+    style,
+    ...restProps
+  } = props;
+  if (true) {
+    const warning = devUseWarning("Input.OTP");
+    true ? warning(!(typeof mask === "string" && mask.length > 1), "usage", "`mask` prop should be a single character.") : void 0;
+  }
+  const {
+    classNames: contextClassNames,
+    styles: contextStyles,
+    getPrefixCls,
+    direction,
+    style: contextStyle,
+    className: contextClassName
+  } = useComponentConfig("otp");
+  const prefixCls = getPrefixCls("otp", customizePrefixCls);
+  const [variant] = useVariants_default("otp", customizeVariant, void 0, "input");
+  const mergedProps = {
+    ...props,
+    length,
+    variant
+  };
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const styleRoot = useSemanticRootStyle(style);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNames, classNames], [contextStyles, contextStyleRoot, styles, styleRoot], {
+    props: mergedProps
+  });
+  const domAttrs = pickAttrs(restProps, {
+    aria: true,
+    data: true,
+    attr: true
+  });
+  const [hashId, cssVarCls] = otp_default(prefixCls);
+  const mergedSize = useSize_default((ctx) => customSize ?? ctx);
+  const formContext = useContext(FormItemInputContext);
+  const mergedStatus = getMergedStatus(formContext.status, customStatus);
+  const proxyFormContext = useMemo(() => ({
+    ...formContext,
+    status: mergedStatus,
+    hasFeedback: false,
+    feedbackIcon: null
+  }), [formContext, mergedStatus]);
+  const containerRef = useRef(null);
+  const inputsRef = useRef({});
+  useImperativeHandle(ref, () => ({
+    focus: () => {
+      inputsRef.current[0]?.focus();
+    },
+    blur: () => {
+      for (let i = 0; i < length; i += 1) {
+        inputsRef.current[i]?.blur();
+      }
+    },
+    nativeElement: containerRef.current
+  }));
+  const internalFormatter = (txt) => formatter ? formatter(txt) : txt;
+  const [valueCells, setValueCells] = useState(() => strToArr(internalFormatter(defaultValue || "")));
+  useEffect(() => {
+    if (value !== void 0) {
+      setValueCells(strToArr(value));
+    }
+  }, [value]);
+  const triggerValueCellsChange = useEvent_default((nextValueCells) => {
+    setValueCells(nextValueCells);
+    if (onInput) {
+      onInput(nextValueCells);
+    }
+    if (onChange && nextValueCells.length === length && nextValueCells.every((c) => c) && nextValueCells.some((c, index) => valueCells[index] !== c)) {
+      onChange(nextValueCells.join(""));
+    }
+  });
+  const patchValue = useEvent_default((index, txt) => {
+    let nextCells = _toConsumableArray(valueCells);
+    for (let i = 0; i < index; i += 1) {
+      if (!nextCells[i]) {
+        nextCells[i] = "";
+      }
+    }
+    if (txt.length <= 1) {
+      nextCells[index] = txt;
+    } else {
+      nextCells = nextCells.slice(0, index).concat(strToArr(txt));
+    }
+    nextCells = nextCells.slice(0, length);
+    for (let i = nextCells.length - 1; i >= 0; i -= 1) {
+      if (nextCells[i]) {
+        break;
+      }
+      nextCells.pop();
+    }
+    const formattedValue = internalFormatter(nextCells.map((c) => c || " ").join(""));
+    nextCells = strToArr(formattedValue).map((c, i) => {
+      if (c === " " && !nextCells[i]) {
+        return nextCells[i];
+      }
+      return c;
+    });
+    return nextCells;
+  });
+  const onInputChange = (index, txt) => {
+    const nextCells = patchValue(index, txt);
+    const nextIndex = Math.min(index + txt.length, length - 1);
+    if (nextIndex !== index && nextCells[index] !== void 0) {
+      inputsRef.current[nextIndex]?.focus();
+    }
+    triggerValueCellsChange(nextCells);
+  };
+  const onInputActiveChange = (nextIndex) => {
+    inputsRef.current[nextIndex]?.focus();
+  };
+  const onInputFocus = (event, index) => {
+    for (let i = 0; i < index; i += 1) {
+      if (!inputsRef.current[i]?.input?.value) {
+        inputsRef.current[i]?.focus();
+        break;
+      }
+    }
+    onFocus?.(event);
+  };
+  const inputSharedProps = {
+    variant,
+    disabled,
+    status: mergedStatus,
+    mask,
+    type,
+    inputMode,
+    autoComplete
+  };
+  return /* @__PURE__ */ createElement("div", {
+    ...domAttrs,
+    ref: containerRef,
+    className: clsx(className, prefixCls, {
+      [`${prefixCls}-sm`]: mergedSize === "small",
+      [`${prefixCls}-lg`]: mergedSize === "large",
+      [`${prefixCls}-rtl`]: direction === "rtl"
+    }, cssVarCls, hashId, contextClassName, mergedClassNames.root),
+    style: mergedStyles.root,
+    role: "group"
+  }, /* @__PURE__ */ createElement(FormItemInputContext.Provider, {
+    value: proxyFormContext
+  }, Array.from({
+    length
+  }).map((_, index) => {
+    const key = `otp-${index}`;
+    const singleValue = valueCells[index] || "";
+    return /* @__PURE__ */ createElement(Fragment, {
+      key
+    }, /* @__PURE__ */ createElement(OTPInput_default, {
+      ref: (inputEle) => {
+        inputsRef.current[index] = inputEle;
+      },
+      index,
+      size: mergedSize,
+      htmlSize: 1,
+      className: clsx(mergedClassNames.input, `${prefixCls}-input`),
+      style: mergedStyles.input,
+      onChange: onInputChange,
+      value: singleValue,
+      onActiveChange: onInputActiveChange,
+      autoFocus: index === 0 && autoFocus,
+      onFocus: (event) => onInputFocus(event, index),
+      ...inputSharedProps
+    }), index < length - 1 && /* @__PURE__ */ createElement(Separator, {
+      separator,
+      index,
+      prefixCls,
+      className: clsx(mergedClassNames.separator),
+      style: mergedStyles.separator
+    }));
+  })));
+});
+var OTP_default = OTP;
+
+// ../../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/EyeInvisibleOutlined.js
+var import_EyeInvisibleOutlined = __toESM(require_EyeInvisibleOutlined());
+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 EyeInvisibleOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends4({}, props, {
+  ref,
+  icon: import_EyeInvisibleOutlined.default
+}));
+var RefIcon3 = /* @__PURE__ */ forwardRef(EyeInvisibleOutlined);
+if (true) {
+  RefIcon3.displayName = "EyeInvisibleOutlined";
+}
+var EyeInvisibleOutlined_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/EyeOutlined.js
+var import_EyeOutlined = __toESM(require_EyeOutlined());
+function _extends5() {
+  _extends5 = 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 _extends5.apply(this, arguments);
+}
+var EyeOutlined = (props, ref) => /* @__PURE__ */ createElement(AntdIconLight_default, _extends5({}, props, {
+  ref,
+  icon: import_EyeOutlined.default
+}));
+var RefIcon4 = /* @__PURE__ */ forwardRef(EyeOutlined);
+if (true) {
+  RefIcon4.displayName = "EyeOutlined";
+}
+var EyeOutlined_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/input/Password.js
+var defaultIconRender = (visible) => visible ? /* @__PURE__ */ createElement(EyeOutlined_default, null) : /* @__PURE__ */ createElement(EyeInvisibleOutlined_default, null);
+var actionMap = {
+  click: "onClick",
+  hover: "onMouseOver"
+};
+var Password = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    disabled: customDisabled,
+    action = "click",
+    visibilityToggle = true,
+    iconRender,
+    prefixCls: customizePrefixCls,
+    inputPrefixCls: customizeInputPrefixCls,
+    suffix,
+    className,
+    style,
+    classNames,
+    styles,
+    variant: customizeVariant,
+    ...restProps
+  } = props;
+  const {
+    getPrefixCls,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles,
+    iconRender: contextIconRender
+  } = useComponentConfig("inputPassword");
+  const [variant] = useVariants_default("inputPassword", customizeVariant, props.bordered, "input");
+  const [locale] = useLocale_default("global");
+  const disabled = useContext(DisabledContext_default);
+  const mergedDisabled = customDisabled ?? disabled;
+  const mergedProps = {
+    ...props,
+    disabled: mergedDisabled,
+    variant
+  };
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const styleRoot = useSemanticRootStyle(style);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNames, classNames], [contextStyles, contextStyleRoot, styles, styleRoot], {
+    props: mergedProps
+  });
+  const visibilityControlled = isPlainObject(visibilityToggle) && visibilityToggle.visible !== void 0;
+  const [visible, setVisible] = useState(() => visibilityControlled ? visibilityToggle.visible : false);
+  const inputRef = useRef(null);
+  useEffect(() => {
+    if (visibilityControlled) {
+      setVisible(visibilityToggle.visible);
+    }
+  }, [visibilityControlled, visibilityToggle]);
+  const removePasswordTimeout = useRemovePasswordTimeout(inputRef);
+  const onVisibleChange = () => {
+    if (mergedDisabled) {
+      return;
+    }
+    if (visible) {
+      removePasswordTimeout();
+    }
+    const nextVisible = !visible;
+    setVisible(nextVisible);
+    if (isPlainObject(visibilityToggle)) {
+      visibilityToggle.onVisibleChange?.(nextVisible);
+    }
+  };
+  const getIcon = (prefixCls2) => {
+    const iconTrigger = actionMap[action] || "";
+    const iconRenderer = iconRender || contextIconRender || defaultIconRender;
+    const icon = iconRenderer(visible);
+    const iconTabIndex = isPlainObject(visibilityToggle) ? visibilityToggle.tabIndex : void 0;
+    return /* @__PURE__ */ createElement("span", {
+      key: "passwordIcon",
+      role: "button",
+      tabIndex: mergedDisabled ? -1 : iconTabIndex ?? 0,
+      className: `${prefixCls2}-icon`,
+      "aria-disabled": mergedDisabled,
+      "aria-pressed": visible,
+      "aria-label": visible ? locale.hide : locale.show,
+      onMouseDown: (e3) => {
+        e3.preventDefault();
+      },
+      onMouseUp: (e3) => {
+        e3.preventDefault();
+      },
+      onKeyDown: (e3) => {
+        if (e3.key === "Enter" || e3.key === " ") {
+          e3.preventDefault();
+          onVisibleChange();
+        }
+      },
+      [iconTrigger]: onVisibleChange
+    }, icon);
+  };
+  const inputPrefixCls = getPrefixCls("input", customizeInputPrefixCls);
+  const prefixCls = getPrefixCls("input-password", customizePrefixCls);
+  const suffixIcon = visibilityToggle && getIcon(prefixCls);
+  const inputClassName = clsx(prefixCls, contextClassName, className, {
+    [`${prefixCls}-${props.size}`]: !!props.size
+  });
+  const inputProps = {
+    ...restProps,
+    type: visible ? "text" : "password",
+    prefixCls: inputPrefixCls,
+    suffix: /* @__PURE__ */ createElement(Fragment, null, suffixIcon, suffix),
+    disabled: mergedDisabled,
+    className: inputClassName,
+    classNames: mergedClassNames,
+    styles: mergedStyles,
+    variant
+  };
+  return /* @__PURE__ */ createElement(Input_default, {
+    ref: composeRef(ref, inputRef),
+    ...inputProps
+  });
+});
+if (true) {
+  Password.displayName = "Input.Password";
+}
+var Password_default = Password;
+
+// ../../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/input/style/search.js
+var genSearchStyle = (token) => {
+  const {
+    componentCls,
+    antCls,
+    calc,
+    max
+  } = token;
+  const btnCls = `${componentCls}-btn`;
+  const [varName, varRef] = genCssVar(antCls, "input-search");
+  const inputFontSizeSM = token.inputFontSizeSM ?? token.fontSize;
+  const smallButtonHeight = max(token.controlHeightSM, calc(inputFontSizeSM).mul(token.lineHeight).add(calc(token.paddingBlockSM).mul(2)).add(calc(token.lineWidth).mul(2)).equal());
+  return {
+    [componentCls]: {
+      [varName("btn-height")]: unit(token.controlHeight),
+      width: "100%",
+      // =========================== Button ===========================
+      [btnCls]: {
+        height: varRef("btn-height"),
+        "&:focus-visible": {
+          zIndex: 5
+        },
+        [`&${antCls}-btn-icon-only`]: {
+          width: varRef("btn-height")
+        },
+        "&-filled": {
+          background: token.colorFillTertiary,
+          "&:not(:disabled)": {
+            "&:hover": {
+              background: token.colorFillSecondary
+            },
+            "&:active": {
+              background: token.colorFill
+            }
+          }
+        }
+      },
+      [`&${componentCls}-large`]: {
+        [varName("btn-height")]: unit(token.controlHeightLG)
+      },
+      [`&${componentCls}-small`]: {
+        [varName("btn-height")]: unit(token.controlHeightSM)
+      },
+      [`&${componentCls}-small ${btnCls}`]: {
+        minHeight: smallButtonHeight,
+        [`&${token.antCls}-btn-icon-only`]: {
+          minWidth: smallButtonHeight
+        }
+      }
+    }
+  };
+};
+var search_default = genStyleHooks(["Input", "Search"], (token) => {
+  const inputToken = merge(token, initInputToken(token));
+  return genSearchStyle(inputToken);
+}, initComponentToken);
+
+// ../../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/input/Search.js
+var Search = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    inputPrefixCls: customizeInputPrefixCls,
+    className,
+    size: customizeSize,
+    style,
+    enterButton = false,
+    searchIcon: customizeSearchIcon,
+    addonAfter,
+    loading,
+    disabled,
+    onSearch: customOnSearch,
+    onChange: customOnChange,
+    onCompositionStart,
+    onCompositionEnd,
+    variant: customizeVariant,
+    onPressEnter: customOnPressEnter,
+    classNames,
+    styles,
+    hidden,
+    ...restProps
+  } = props;
+  const {
+    direction,
+    getPrefixCls,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles,
+    searchIcon: contextSearchIcon
+  } = useComponentConfig("inputSearch");
+  const contextDisabled = useContext(DisabledContext_default);
+  const mergedDisabled = disabled ?? contextDisabled;
+  const [mergedVariant, , isVariantConfigured] = useVariants_default("inputSearch", customizeVariant, props.bordered);
+  const variant = isVariantConfigured ? mergedVariant : void 0;
+  const [inputVariant] = useVariants_default("inputSearch", customizeVariant, props.bordered, "input");
+  const mergedProps = {
+    ...props,
+    enterButton,
+    variant
+  };
+  const contextStyleRoot = useSemanticRootStyle(contextStyle);
+  const styleRoot = useSemanticRootStyle(style);
+  const [mergedClassNames, mergedStyles] = useMergeSemantic([contextClassNames, classNames], [contextStyles, contextStyleRoot, styles, styleRoot], {
+    props: mergedProps
+  }, {
+    button: {
+      _default: "root"
+    }
+  });
+  const composedRef = useRef(false);
+  const prefixCls = getPrefixCls("input-search", customizePrefixCls);
+  const inputPrefixCls = getPrefixCls("input", customizeInputPrefixCls);
+  const [hashId, cssVarCls] = search_default(prefixCls);
+  const {
+    compactSize
+  } = useCompactItemContext(prefixCls, direction);
+  const size = useSize_default((ctx) => customizeSize ?? compactSize ?? ctx);
+  const inputRef = useRef(null);
+  const onChange = (e3) => {
+    if (e3?.target && e3.type === "click" && customOnSearch) {
+      customOnSearch(e3.target.value, e3, {
+        source: "clear"
+      });
+    }
+    customOnChange?.(e3);
+  };
+  const onMouseDown = (e3) => {
+    if (document.activeElement === inputRef.current?.input) {
+      e3.preventDefault();
+    }
+  };
+  const onSearch = (e3) => {
+    if (customOnSearch) {
+      customOnSearch(inputRef.current?.input?.value, e3, {
+        source: "input"
+      });
+    }
+  };
+  const onPressEnter = (e3) => {
+    if (composedRef.current || loading) {
+      return;
+    }
+    customOnPressEnter?.(e3);
+    onSearch(e3);
+  };
+  const searchIcon = typeof enterButton === "boolean" ? fallbackProp(customizeSearchIcon, contextSearchIcon, /* @__PURE__ */ createElement(SearchOutlined_default, null)) : null;
+  const btnPrefixCls = `${prefixCls}-btn`;
+  const btnClassName = clsx(btnPrefixCls, {
+    [`${btnPrefixCls}-${variant}`]: variant
+  });
+  let button;
+  const enterButtonAsElement = enterButton || {};
+  const isAntdButton = enterButtonAsElement.type && enterButtonAsElement.type.__ANT_BUTTON === true;
+  if (isAntdButton || enterButtonAsElement.type === "button") {
+    const enterButtonProps = enterButtonAsElement.props;
+    button = cloneElement(enterButtonAsElement, {
+      disabled: mergedDisabled || enterButtonProps.disabled || !isAntdButton && loading,
+      onMouseDown,
+      onClick: (e3) => {
+        enterButtonAsElement?.props?.onClick?.(e3);
+        onSearch(e3);
+      },
+      key: "enterButton",
+      ...isAntdButton ? {
+        className: clsx(btnClassName, enterButtonProps.className),
+        loading: loading || enterButtonProps.loading,
+        size
+      } : {}
+    });
+  } else {
+    button = /* @__PURE__ */ createElement(Button_default, {
+      classNames: mergedClassNames.button,
+      styles: mergedStyles.button,
+      className: btnClassName,
+      color: enterButton ? "primary" : "default",
+      size,
+      disabled,
+      key: "enterButton",
+      onMouseDown,
+      onClick: onSearch,
+      loading,
+      icon: searchIcon,
+      variant: variant === "borderless" || variant === "filled" || variant === "underlined" ? "text" : enterButton ? "solid" : void 0
+    }, enterButton);
+  }
+  if (addonAfter) {
+    button = [button, cloneElement(addonAfter, {
+      key: "addonAfter"
+    })];
+  }
+  const mergedClassName = clsx(prefixCls, cssVarCls, {
+    [`${prefixCls}-rtl`]: direction === "rtl",
+    [`${prefixCls}-${size}`]: !!size,
+    [`${prefixCls}-with-button`]: !!enterButton
+  }, className, contextClassName, hashId, mergedClassNames.root);
+  const handleOnCompositionStart = (e3) => {
+    composedRef.current = true;
+    onCompositionStart?.(e3);
+  };
+  const handleOnCompositionEnd = (e3) => {
+    composedRef.current = false;
+    onCompositionEnd?.(e3);
+  };
+  const rootProps = pickAttrs(restProps, {
+    data: true
+  });
+  const inputProps = omit({
+    ...restProps,
+    classNames: omit(mergedClassNames, ["button", "root"]),
+    styles: omit(mergedStyles, ["button", "root"]),
+    prefixCls: inputPrefixCls,
+    type: "search",
+    size,
+    variant: inputVariant,
+    onPressEnter,
+    onCompositionStart: handleOnCompositionStart,
+    onCompositionEnd: handleOnCompositionEnd,
+    onChange,
+    disabled
+  }, Object.keys(rootProps));
+  return /* @__PURE__ */ createElement(Compact_default, {
+    className: mergedClassName,
+    style: mergedStyles.root,
+    ...rootProps,
+    hidden
+  }, /* @__PURE__ */ createElement(Input_default, {
+    ref: composeRef(inputRef, ref),
+    ...inputProps
+  }), button);
+});
+if (true) {
+  Search.displayName = "Search";
+}
+var Search_default = Search;
+
+// ../../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/input/index.js
+var Input = Input_default;
+Input.Group = Group_default;
+Input.Search = Search_default;
+Input.TextArea = TextArea_default;
+Input.Password = Password_default;
+Input.OTP = OTP_default;
+var input_default = Input;
+
+// ../../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/index.js
+if (true) {
+  const majorVersion = getReactMajorVersion();
+  true ? warning_default(majorVersion >= 18, "version", `antd v6 no longer supports React versions below 18. Please upgrade to React 18 or higher.`) : void 0;
+}
+
+// src/plugin/auth-response.ts
+function parseAuthenticationCompletion(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("\u8BA4\u8BC1\u54CD\u5E94\u65E0\u6548");
+  }
+  const response = input;
+  if (response.status === "verified") return { status: "verified" };
+  if (response.status === "denied") throw new Error("\u8BA4\u8BC1\u4FE1\u606F\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5");
+  if (response.status === "pending") throw new Error("\u8BA4\u8BC1\u4ECD\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+  throw new Error("\u8BA4\u8BC1\u54CD\u5E94\u65E0\u6548");
+}
+function parseAuthenticationChallenge(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("\u9A8C\u8BC1\u7801\u54CD\u5E94\u65E0\u6548");
+  }
+  const response = input;
+  if (response.status !== "pending" || !Number.isSafeInteger(response.retryAfterMs) || response.retryAfterMs <= 0 || response.retryAfterMs > 6e4) {
+    throw new Error("\u9A8C\u8BC1\u7801\u54CD\u5E94\u65E0\u6548");
+  }
+  return { retryAfterMs: response.retryAfterMs };
+}
+
+// src/plugin/password-form.module.css
+var password_form_default = {
+  authShell: "password_form_authShell",
+  introduction: "password_form_introduction",
+  eyebrow: "password_form_eyebrow",
+  introductionTitle: "password_form_introductionTitle",
+  introductionCopy: "password_form_introductionCopy",
+  formRegion: "password_form_formRegion",
+  formBody: "password_form_formBody",
+  formNote: "password_form_formNote",
+  codeRow: "password_form_codeRow",
+  changeEmail: "password_form_changeEmail",
+  alternate: "password_form_alternate",
+  alternateLinks: "password_form_alternateLinks"
+};
+
+// src/plugin/password-form.tsx
+function PasswordForm(props) {
+  const [form] = form_default.useForm();
+  const { message } = app_default.useApp();
+  const request = useRequest();
+  const navigation = useRscNavigation();
+  const [transactionId, setTransactionId] = useState(props.transactionId);
+  const [mode, setMode] = useState("password");
+  const [codeSent, setCodeSent] = useState(false);
+  const [countdown, setCountdown] = useState(0);
+  const [submitting, setSubmitting] = useState(false);
+  const [sending, setSending] = useState(false);
+  const pendingSend = useRef(void 0);
+  const usesCode = props.intent !== "login" || mode === "code";
+  const needsPassword = props.intent !== "login" || mode === "password";
+  useEffect(() => {
+    if (countdown <= 0) return;
+    const timer = window.setInterval(() => setCountdown((value) => Math.max(0, value - 1)), 1e3);
+    return () => window.clearInterval(timer);
+  }, [countdown > 0]);
+  async function ensureTransaction() {
+    if (transactionId) return transactionId;
+    const created = await beginTransaction(request, props.intent);
+    setTransactionId(created);
+    return created;
+  }
+  async function sendCode() {
+    try {
+      const { email } = await form.validateFields(["email"]);
+      setSending(true);
+      const currentTransactionId = await ensureTransaction();
+      const requestId = pendingSend.current?.email === email ? pendingSend.current.requestId : crypto.randomUUID();
+      pendingSend.current = { email, requestId };
+      const challenge = await request(
+        `/api/auth/transactions/${encodeURIComponent(currentTransactionId)}/complete`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify({ input: { action: "send-code", email, requestId } })
+        },
+        { errorMessage: "\u9A8C\u8BC1\u7801\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", parse: parseAuthenticationChallenge }
+      );
+      setCodeSent(true);
+      setCountdown(Math.ceil(challenge.retryAfterMs / 1e3));
+      pendingSend.current = void 0;
+      void message.success("\u9A8C\u8BC1\u7801\u5DF2\u53D1\u9001");
+    } catch {
+    } finally {
+      setSending(false);
+    }
+  }
+  async function submit(values) {
+    setSubmitting(true);
+    try {
+      const currentTransactionId = await ensureTransaction();
+      const input = usesCode ? {
+        action: "verify-code",
+        email: values.email,
+        code: values.code,
+        ...needsPassword ? { password: values.password } : {}
+      } : { action: "password-login", email: values.email, password: values.password };
+      await request(`/api/auth/transactions/${encodeURIComponent(currentTransactionId)}/complete`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        credentials: "same-origin",
+        body: JSON.stringify({ input })
+      }, { errorMessage: "\u6CA1\u6709\u5B8C\u6210\uFF0C\u8BF7\u68C0\u67E5\u8F93\u5165\u540E\u91CD\u8BD5", parse: parseAuthenticationCompletion });
+      if (props.intent === "registration") {
+        navigation.replace(USER_ACCOUNT_HREF);
+        return;
+      }
+      navigation.replace("/");
+    } catch {
+    } finally {
+      setSubmitting(false);
+    }
+  }
+  const copy = pageCopy(props.intent);
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-labelledby": "password-auth-title",
+      className: password_form_default.authShell,
+      "data-auth-method": "password",
+      "data-flat-auth-layout": true,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: password_form_default.introduction, children: [
+          /* @__PURE__ */ jsx("p", { className: password_form_default.eyebrow, children: copy.step }),
+          /* @__PURE__ */ jsx("h1", { className: password_form_default.introductionTitle, id: "password-auth-title", children: copy.title }),
+          /* @__PURE__ */ jsx("p", { className: password_form_default.introductionCopy, children: copy.introduction }),
+          /* @__PURE__ */ jsx(AlternateLinks, { intent: props.intent })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: password_form_default.formRegion, children: [
+          /* @__PURE__ */ jsx("div", { className: password_form_default.formBody, children: /* @__PURE__ */ jsxs(
+            form_default,
+            {
+              form,
+              layout: "vertical",
+              requiredMark: false,
+              scrollToFirstError: { focus: true },
+              validateTrigger: "onBlur",
+              onFinish: submit,
+              children: [
+                props.intent === "login" ? /* @__PURE__ */ jsx(form_default.Item, { children: /* @__PURE__ */ jsx(
+                  segmented_default,
+                  {
+                    "aria-label": "\u9009\u62E9\u767B\u5F55\u65B9\u5F0F",
+                    block: true,
+                    options: [{ label: "\u5BC6\u7801\u767B\u5F55", value: "password" }, { label: "\u9A8C\u8BC1\u7801\u767B\u5F55", value: "code" }],
+                    size: "large",
+                    value: mode,
+                    onChange: (value) => {
+                      setMode(value);
+                      setCodeSent(false);
+                      setCountdown(0);
+                      setTransactionId(props.transactionId);
+                      pendingSend.current = void 0;
+                      form.resetFields(["code"]);
+                    }
+                  }
+                ) }) : null,
+                /* @__PURE__ */ jsx(form_default.Item, { label: "\u90AE\u7BB1", name: "email", rules: emailRules, children: /* @__PURE__ */ jsx(input_default, { autoComplete: "username", disabled: codeSent, inputMode: "email", maxLength: 320, placeholder: "name@example.com", size: "large", type: "email" }) }),
+                codeSent ? /* @__PURE__ */ jsx(
+                  button_default,
+                  {
+                    className: password_form_default.changeEmail,
+                    disabled: sending || submitting,
+                    type: "link",
+                    onClick: () => {
+                      setCodeSent(false);
+                      setCountdown(0);
+                      setTransactionId(void 0);
+                      pendingSend.current = void 0;
+                      form.resetFields(["code"]);
+                      window.requestAnimationFrame(() => form.focusField("email"));
+                    },
+                    children: "\u4FEE\u6539\u90AE\u7BB1"
+                  }
+                ) : null,
+                usesCode ? /* @__PURE__ */ jsx(form_default.Item, { label: "\u9A8C\u8BC1\u7801", required: true, children: /* @__PURE__ */ jsxs("div", { className: password_form_default.codeRow, children: [
+                  /* @__PURE__ */ jsx(form_default.Item, { noStyle: true, name: "code", rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u9A8C\u8BC1\u7801" }, { len: 6, message: "\u9A8C\u8BC1\u7801\u5E94\u4E3A 6 \u4F4D\u6570\u5B57" }, { pattern: /^\d{6}$/, message: "\u9A8C\u8BC1\u7801\u5E94\u4E3A 6 \u4F4D\u6570\u5B57" }], children: /* @__PURE__ */ jsx(input_default, { "aria-label": "\u9A8C\u8BC1\u7801", autoComplete: "one-time-code", inputMode: "numeric", maxLength: 6, placeholder: "6 \u4F4D\u9A8C\u8BC1\u7801", size: "large" }) }),
+                  /* @__PURE__ */ jsx(button_default, { disabled: countdown > 0 || submitting, loading: sending, onClick: sendCode, size: "large", children: countdown > 0 ? `${countdown} \u79D2\u540E\u91CD\u53D1` : codeSent ? "\u91CD\u65B0\u53D1\u9001" : "\u53D1\u9001\u9A8C\u8BC1\u7801" })
+                ] }) }) : null,
+                needsPassword ? /* @__PURE__ */ jsx(
+                  form_default.Item,
+                  {
+                    extra: props.intent !== "login" ? "\u81F3\u5C11 12 \u4E2A\u5B57\u7B26\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u5BC6\u7801\u7BA1\u7406\u5668\u751F\u6210\u5E76\u4FDD\u5B58\u3002" : void 0,
+                    label: props.intent === "recovery" ? "\u65B0\u5BC6\u7801" : "\u5BC6\u7801",
+                    name: "password",
+                    rules: passwordRules(props.intent !== "login"),
+                    children: /* @__PURE__ */ jsx(
+                      input_default.Password,
+                      {
+                        autoComplete: props.intent === "login" ? "current-password" : "new-password",
+                        maxLength: 128,
+                        placeholder: props.intent === "login" ? "\u8F93\u5165\u5BC6\u7801" : "\u521B\u5EFA\u4E00\u4E2A\u5B89\u5168\u5BC6\u7801",
+                        size: "large"
+                      }
+                    )
+                  }
+                ) : null,
+                /* @__PURE__ */ jsx(button_default, { block: true, htmlType: "submit", loading: submitting, size: "large", type: "primary", disabled: sending || usesCode && !codeSent, children: copy.submit })
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsxs("aside", { className: password_form_default.formNote, children: [
+            /* @__PURE__ */ jsx("p", { children: copy.description }),
+            /* @__PURE__ */ jsx("span", { children: "\u4F60\u7684\u767B\u5F55\u4FE1\u606F\u53EA\u7528\u4E8E\u8BC6\u522B\u8D26\u6237\u3002" })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function AlternateLinks({ intent }) {
+  if (intent === "registration") return /* @__PURE__ */ jsxs("p", { className: password_form_default.alternate, children: [
+    "\u5DF2\u7ECF\u6709\u8D26\u53F7\uFF1F",
+    /* @__PURE__ */ jsx(RscLink, { href: "/auth.password/login", children: "\u8FD4\u56DE\u767B\u5F55" })
+  ] });
+  if (intent === "recovery") return /* @__PURE__ */ jsxs("p", { className: password_form_default.alternate, children: [
+    "\u60F3\u8D77\u5BC6\u7801\u4E86\uFF1F",
+    /* @__PURE__ */ jsx(RscLink, { href: "/auth.password/login", children: "\u8FD4\u56DE\u767B\u5F55" })
+  ] });
+  return /* @__PURE__ */ jsxs("div", { className: password_form_default.alternateLinks, children: [
+    /* @__PURE__ */ jsxs("p", { children: [
+      /* @__PURE__ */ jsx("span", { children: "\u8FD8\u6CA1\u6709\u8D26\u6237\uFF1F" }),
+      /* @__PURE__ */ jsx(RscLink, { href: "/auth.password/register", children: "\u521B\u5EFA\u8D26\u6237" })
+    ] }),
+    /* @__PURE__ */ jsxs("p", { children: [
+      /* @__PURE__ */ jsx("span", { children: "\u5FD8\u8BB0\u5BC6\u7801\uFF1F" }),
+      /* @__PURE__ */ jsx(RscLink, { href: "/auth.password/recovery", children: "\u627E\u56DE\u5BC6\u7801" })
+    ] })
+  ] });
+}
+async function beginTransaction(request, intent) {
+  return request("/api/auth/transactions", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    credentials: "same-origin",
+    body: JSON.stringify({ methodId: "password", intent })
+  }, { errorMessage: "\u6682\u65F6\u65E0\u6CD5\u7EE7\u7EED\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", parse: parseTransactionId });
+}
+function parseTransactionId(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) throw new Error("Invalid transaction response");
+  const transactionId = data.transactionId;
+  if (typeof transactionId !== "string" || !UUID.test(transactionId)) {
+    throw new Error("Invalid transaction response");
+  }
+  return transactionId;
+}
+var emailRules = [
+  { required: true, message: "\u8BF7\u8F93\u5165\u90AE\u7BB1", whitespace: true },
+  { type: "email", message: "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740" },
+  { max: 320, message: "\u90AE\u7BB1\u5730\u5740\u4E0D\u80FD\u8D85\u8FC7 320 \u4E2A\u5B57\u7B26" }
+];
+function passwordRules(requireMinimum) {
+  return [
+    { required: true, message: "\u8BF7\u8F93\u5165\u5BC6\u7801" },
+    ...requireMinimum ? [{
+      validator: async (_rule, value) => {
+        if (!value) return;
+        if (Array.from(value).length < 12) throw new Error("\u5BC6\u7801\u81F3\u5C11\u9700\u8981 12 \u4E2A\u5B57\u7B26");
+        if (new TextEncoder().encode(value).byteLength > 128) throw new Error("\u5BC6\u7801\u8FC7\u957F\uFF0C\u8BF7\u7F29\u77ED\u540E\u91CD\u8BD5");
+      }
+    }] : [{ max: 128, message: "\u5BC6\u7801\u4E0D\u80FD\u8D85\u8FC7 128 \u4E2A\u5B57\u7B26" }]
+  ];
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function pageCopy(intent) {
+  if (intent === "registration") return {
+    introduction: "\u9A8C\u8BC1\u90AE\u7BB1\u5E76\u521B\u5EFA\u8D26\u53F7\u540E\uFF0C\u53EF\u4EE5\u7EE7\u7EED\u5B8C\u5584\u8D44\u6599\uFF0C\u6574\u7406\u5C5E\u4E8E\u4F60\u7684\u8BB0\u5F55\u3002",
+    step: "ACCOUNT / REGISTER",
+    title: "\u521B\u5EFA\u8D26\u6237",
+    description: "\u4F7F\u7528\u90AE\u7BB1\u9A8C\u8BC1\u7801\u548C\u5BC6\u7801\u521B\u5EFA\u8D26\u53F7\u3002",
+    submit: "\u521B\u5EFA\u8D26\u53F7"
+  };
+  if (intent === "recovery") return {
+    introduction: "\u9A8C\u8BC1\u6CE8\u518C\u90AE\u7BB1\u540E\u8BBE\u7F6E\u65B0\u5BC6\u7801\uFF0C\u65E7\u8BBE\u5907\u4E0A\u7684\u767B\u5F55\u4F1A\u81EA\u52A8\u9000\u51FA\u3002",
+    step: "ACCOUNT / RECOVERY",
+    title: "\u627E\u56DE\u5BC6\u7801",
+    description: "\u9A8C\u8BC1\u7801\u53EA\u4F1A\u53D1\u9001\u5230\u5DF2\u7ECF\u6CE8\u518C\u7684\u90AE\u7BB1\u3002",
+    submit: "\u66F4\u65B0\u5BC6\u7801\u5E76\u767B\u5F55"
+  };
+  return {
+    introduction: "\u767B\u5F55\u540E\u53EF\u4EE5\u7BA1\u7406\u4E2A\u4EBA\u8D44\u6599\u4E0E\u767B\u5F55\u4F1A\u8BDD\u3002",
+    step: "ACCOUNT / SIGN IN",
+    title: "\u767B\u5F55\u8D26\u6237",
+    description: "\u4F7F\u7528\u5BC6\u7801\u6216\u90AE\u7BB1\u9A8C\u8BC1\u7801\u767B\u5F55\u4F60\u7684\u8D26\u6237\u3002",
+    submit: "\u767B\u5F55"
+  };
+}
+export {
+  PasswordForm as default
+};