add all frontend files

node_modules/antd/lib/style/compact-item-vertical.d.ts

@@ -0,0 +1,3 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import type { FullToken, OverrideComponent } from '../theme/internal';
+export declare function genCompactItemVerticalStyle<T extends OverrideComponent>(token: FullToken<T>): CSSInterpolation;

node_modules/antd/lib/style/compact-item-vertical.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genCompactItemVerticalStyle = genCompactItemVerticalStyle;
+function compactItemVerticalBorder(token, parentCls, prefixCls) {
+  return {
+    // border collapse
+    [`&-item:not(${parentCls}-last-item)`]: {
+      marginBottom: token.calc(token.lineWidth).mul(-1).equal()
+    },
+    [`&-item:not(${prefixCls}-status-success)`]: {
+      zIndex: 2
+    },
+    '&-item': {
+      '&:hover,&:focus,&:active': {
+        zIndex: 3
+      },
+      '&[disabled]': {
+        zIndex: 0
+      }
+    }
+  };
+}
+function compactItemBorderVerticalRadius(prefixCls, parentCls) {
+  return {
+    [`&-item:not(${parentCls}-first-item):not(${parentCls}-last-item)`]: {
+      borderRadius: 0
+    },
+    [`&-item${parentCls}-first-item:not(${parentCls}-last-item)`]: {
+      [`&, &${prefixCls}-sm, &${prefixCls}-lg`]: {
+        borderEndEndRadius: 0,
+        borderEndStartRadius: 0
+      }
+    },
+    [`&-item${parentCls}-last-item:not(${parentCls}-first-item)`]: {
+      [`&, &${prefixCls}-sm, &${prefixCls}-lg`]: {
+        borderStartStartRadius: 0,
+        borderStartEndRadius: 0
+      }
+    }
+  };
+}
+function genCompactItemVerticalStyle(token) {
+  const compactCls = `${token.componentCls}-compact-vertical`;
+  return {
+    [compactCls]: Object.assign(Object.assign({}, compactItemVerticalBorder(token, compactCls, token.componentCls)), compactItemBorderVerticalRadius(token.componentCls, compactCls))
+  };
+}

node_modules/antd/lib/style/compact-item.d.ts

@@ -0,0 +1,18 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import type { FullToken, OverrideComponent } from '../theme/internal';
+interface CompactItemOptions {
+    componentCls?: string;
+    focus?: boolean;
+    /**
+     * Some component borders are implemented on child elements
+     * like `Select`
+     */
+    borderElCls?: string;
+    /**
+     * Some components have special `focus` className especially with popovers
+     * like `Select` and `DatePicker`
+     */
+    focusElCls?: string;
+}
+export declare function genCompactItemStyle<T extends OverrideComponent>(token: FullToken<T>, options?: CompactItemOptions): CSSInterpolation;
+export {};

node_modules/antd/lib/style/compact-item.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genCompactItemStyle = genCompactItemStyle;
+// handle border collapse
+function compactItemBorder(token, parentCls, options, prefixCls) {
+  const {
+    focusElCls,
+    focus,
+    borderElCls
+  } = options;
+  const childCombinator = borderElCls ? '> *' : '';
+  const hoverEffects = ['hover', focus ? 'focus' : null, 'active'].filter(Boolean).map(n => `&:${n} ${childCombinator}`).join(',');
+  return {
+    [`&-item:not(${parentCls}-last-item)`]: {
+      marginInlineEnd: token.calc(token.lineWidth).mul(-1).equal()
+    },
+    [`&-item:not(${prefixCls}-status-success)`]: {
+      zIndex: 2
+    },
+    '&-item': Object.assign(Object.assign({
+      [hoverEffects]: {
+        zIndex: 3
+      }
+    }, focusElCls ? {
+      [`&${focusElCls}`]: {
+        zIndex: 3
+      }
+    } : {}), {
+      [`&[disabled] ${childCombinator}`]: {
+        zIndex: 0
+      }
+    })
+  };
+}
+// handle border-radius
+function compactItemBorderRadius(prefixCls, parentCls, options) {
+  const {
+    borderElCls
+  } = options;
+  const childCombinator = borderElCls ? `> ${borderElCls}` : '';
+  return {
+    [`&-item:not(${parentCls}-first-item):not(${parentCls}-last-item) ${childCombinator}`]: {
+      borderRadius: 0
+    },
+    [`&-item:not(${parentCls}-last-item)${parentCls}-first-item`]: {
+      [`& ${childCombinator}, &${prefixCls}-sm ${childCombinator}, &${prefixCls}-lg ${childCombinator}`]: {
+        borderStartEndRadius: 0,
+        borderEndEndRadius: 0
+      }
+    },
+    [`&-item:not(${parentCls}-first-item)${parentCls}-last-item`]: {
+      [`& ${childCombinator}, &${prefixCls}-sm ${childCombinator}, &${prefixCls}-lg ${childCombinator}`]: {
+        borderStartStartRadius: 0,
+        borderEndStartRadius: 0
+      }
+    }
+  };
+}
+function genCompactItemStyle(token, options = {
+  focus: true
+}) {
+  const {
+    componentCls
+  } = token;
+  const {
+    componentCls: customizePrefixCls
+  } = options;
+  const mergedComponentCls = customizePrefixCls || componentCls;
+  const compactCls = `${mergedComponentCls}-compact`;
+  return {
+    [compactCls]: Object.assign(Object.assign({}, compactItemBorder(token, compactCls, options, mergedComponentCls)), compactItemBorderRadius(mergedComponentCls, compactCls, options))
+  };
+}

node_modules/antd/lib/style/index.d.ts

@@ -0,0 +1,12 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { AliasToken } from '../theme/internal';
+export declare const textEllipsis: CSSObject;
+export declare const resetComponent: (token: AliasToken, needInheritFontFamily?: boolean) => CSSObject;
+export declare const resetIcon: () => CSSObject;
+export declare const clearFix: () => CSSObject;
+export declare const genLinkStyle: (token: AliasToken) => CSSObject;
+export declare const genCommonStyle: (token: AliasToken, componentPrefixCls: string, rootCls?: string, resetFont?: boolean) => CSSObject;
+export declare const genFocusOutline: (token: AliasToken, offset?: number) => CSSObject;
+export declare const genFocusStyle: (token: AliasToken, offset?: number) => CSSObject;
+export declare const genIconStyle: (iconPrefixCls: string) => CSSObject;
+export declare const operationUnit: (token: AliasToken) => CSSObject;

node_modules/antd/lib/style/index.js

@@ -0,0 +1,162 @@
+"use strict";
+"use client";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.textEllipsis = exports.resetIcon = exports.resetComponent = exports.operationUnit = exports.genLinkStyle = exports.genIconStyle = exports.genFocusStyle = exports.genFocusOutline = exports.genCommonStyle = exports.clearFix = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+const textEllipsis = exports.textEllipsis = {
+  overflow: 'hidden',
+  whiteSpace: 'nowrap',
+  textOverflow: 'ellipsis'
+};
+const resetComponent = (token, needInheritFontFamily = false) => ({
+  boxSizing: 'border-box',
+  margin: 0,
+  padding: 0,
+  color: token.colorText,
+  fontSize: token.fontSize,
+  // font-variant: @font-variant-base;
+  lineHeight: token.lineHeight,
+  listStyle: 'none',
+  // font-feature-settings: @font-feature-settings-base;
+  fontFamily: needInheritFontFamily ? 'inherit' : token.fontFamily
+});
+exports.resetComponent = resetComponent;
+const resetIcon = () => ({
+  display: 'inline-flex',
+  alignItems: 'center',
+  color: 'inherit',
+  fontStyle: 'normal',
+  lineHeight: 0,
+  textAlign: 'center',
+  textTransform: 'none',
+  // for SVG icon, see https://blog.prototypr.io/align-svg-icons-to-text-and-say-goodbye-to-font-icons-d44b3d7b26b4
+  verticalAlign: '-0.125em',
+  textRendering: 'optimizeLegibility',
+  '-webkit-font-smoothing': 'antialiased',
+  '-moz-osx-font-smoothing': 'grayscale',
+  '> *': {
+    lineHeight: 1
+  },
+  svg: {
+    display: 'inline-block'
+  }
+});
+exports.resetIcon = resetIcon;
+const clearFix = () => ({
+  // https://github.com/ant-design/ant-design/issues/21301#issuecomment-583955229
+  '&::before': {
+    display: 'table',
+    content: '""'
+  },
+  '&::after': {
+    // https://github.com/ant-design/ant-design/issues/21864
+    display: 'table',
+    clear: 'both',
+    content: '""'
+  }
+});
+exports.clearFix = clearFix;
+const genLinkStyle = token => ({
+  a: {
+    color: token.colorLink,
+    textDecoration: token.linkDecoration,
+    backgroundColor: 'transparent',
+    // remove the gray background on active links in IE 10.
+    outline: 'none',
+    cursor: 'pointer',
+    transition: `color ${token.motionDurationSlow}`,
+    '-webkit-text-decoration-skip': 'objects',
+    // remove gaps in links underline in iOS 8+ and Safari 8+.
+    '&:hover': {
+      color: token.colorLinkHover
+    },
+    '&:active': {
+      color: token.colorLinkActive
+    },
+    '&:active, &:hover': {
+      textDecoration: token.linkHoverDecoration,
+      outline: 0
+    },
+    // https://github.com/ant-design/ant-design/issues/22503
+    '&:focus': {
+      textDecoration: token.linkFocusDecoration,
+      outline: 0
+    },
+    '&[disabled]': {
+      color: token.colorTextDisabled,
+      cursor: 'not-allowed'
+    }
+  }
+});
+exports.genLinkStyle = genLinkStyle;
+const genCommonStyle = (token, componentPrefixCls, rootCls, resetFont) => {
+  const prefixSelector = `[class^="${componentPrefixCls}"], [class*=" ${componentPrefixCls}"]`;
+  const rootPrefixSelector = rootCls ? `.${rootCls}` : prefixSelector;
+  const resetStyle = {
+    boxSizing: 'border-box',
+    '&::before, &::after': {
+      boxSizing: 'border-box'
+    }
+  };
+  let resetFontStyle = {};
+  if (resetFont !== false) {
+    resetFontStyle = {
+      fontFamily: token.fontFamily,
+      fontSize: token.fontSize
+    };
+  }
+  return {
+    [rootPrefixSelector]: Object.assign(Object.assign(Object.assign({}, resetFontStyle), resetStyle), {
+      [prefixSelector]: resetStyle
+    })
+  };
+};
+exports.genCommonStyle = genCommonStyle;
+const genFocusOutline = (token, offset) => ({
+  outline: `${(0, _cssinjs.unit)(token.lineWidthFocus)} solid ${token.colorPrimaryBorder}`,
+  outlineOffset: offset !== null && offset !== void 0 ? offset : 1,
+  transition: 'outline-offset 0s, outline 0s'
+});
+exports.genFocusOutline = genFocusOutline;
+const genFocusStyle = (token, offset) => ({
+  '&:focus-visible': genFocusOutline(token, offset)
+});
+exports.genFocusStyle = genFocusStyle;
+const genIconStyle = iconPrefixCls => ({
+  [`.${iconPrefixCls}`]: Object.assign(Object.assign({}, resetIcon()), {
+    [`.${iconPrefixCls} .${iconPrefixCls}-icon`]: {
+      display: 'block'
+    }
+  })
+});
+exports.genIconStyle = genIconStyle;
+const operationUnit = token => Object.assign(Object.assign({
+  // FIXME: This use link but is a operation unit. Seems should be a colorPrimary.
+  // And Typography use this to generate link style which should not do this.
+  color: token.colorLink,
+  textDecoration: token.linkDecoration,
+  outline: 'none',
+  cursor: 'pointer',
+  transition: `all ${token.motionDurationSlow}`,
+  border: 0,
+  padding: 0,
+  background: 'none',
+  userSelect: 'none'
+}, genFocusStyle(token)), {
+  '&:hover': {
+    color: token.colorLinkHover,
+    textDecoration: token.linkHoverDecoration
+  },
+  '&:focus': {
+    color: token.colorLinkHover,
+    textDecoration: token.linkFocusDecoration
+  },
+  '&:active': {
+    color: token.colorLinkActive,
+    textDecoration: token.linkHoverDecoration
+  }
+});
+exports.operationUnit = operationUnit;

node_modules/antd/lib/style/motion/collapse.d.ts

@@ -0,0 +1,3 @@
+import type { AliasToken, GenerateStyle, TokenWithCommonCls } from '../../theme/internal';
+declare const genCollapseMotion: GenerateStyle<TokenWithCommonCls<AliasToken>>;
+export default genCollapseMotion;

node_modules/antd/lib/style/motion/collapse.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const genCollapseMotion = token => ({
+  [token.componentCls]: {
+    // For common/openAnimation
+    [`${token.antCls}-motion-collapse-legacy`]: {
+      overflow: 'hidden',
+      '&-active': {
+        transition: `height ${token.motionDurationMid} ${token.motionEaseInOut},
+        opacity ${token.motionDurationMid} ${token.motionEaseInOut} !important`
+      }
+    },
+    [`${token.antCls}-motion-collapse`]: {
+      overflow: 'hidden',
+      transition: `height ${token.motionDurationMid} ${token.motionEaseInOut},
+        opacity ${token.motionDurationMid} ${token.motionEaseInOut} !important`
+    }
+  }
+});
+var _default = exports.default = genCollapseMotion;

node_modules/antd/lib/style/motion/fade.d.ts

@@ -0,0 +1,6 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import { Keyframes } from '@ant-design/cssinjs';
+import type { AliasToken, TokenWithCommonCls } from '../../theme/internal';
+export declare const fadeIn: Keyframes;
+export declare const fadeOut: Keyframes;
+export declare const initFadeMotion: (token: TokenWithCommonCls<AliasToken>, sameLevel?: boolean) => CSSInterpolation;

node_modules/antd/lib/style/motion/fade.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initFadeMotion = exports.fadeOut = exports.fadeIn = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _motion = require("./motion");
+const fadeIn = exports.fadeIn = new _cssinjs.Keyframes('antFadeIn', {
+  '0%': {
+    opacity: 0
+  },
+  '100%': {
+    opacity: 1
+  }
+});
+const fadeOut = exports.fadeOut = new _cssinjs.Keyframes('antFadeOut', {
+  '0%': {
+    opacity: 1
+  },
+  '100%': {
+    opacity: 0
+  }
+});
+const initFadeMotion = (token, sameLevel = false) => {
+  const {
+    antCls
+  } = token;
+  const motionCls = `${antCls}-fade`;
+  const sameLevelPrefix = sameLevel ? '&' : '';
+  return [(0, _motion.initMotion)(motionCls, fadeIn, fadeOut, token.motionDurationMid, sameLevel), {
+    [`
+        ${sameLevelPrefix}${motionCls}-enter,
+        ${sameLevelPrefix}${motionCls}-appear
+      `]: {
+      opacity: 0,
+      animationTimingFunction: 'linear'
+    },
+    [`${sameLevelPrefix}${motionCls}-leave`]: {
+      animationTimingFunction: 'linear'
+    }
+  }];
+};
+exports.initFadeMotion = initFadeMotion;

node_modules/antd/lib/style/motion/index.d.ts

@@ -0,0 +1,6 @@
+import genCollapseMotion from './collapse';
+import { fadeIn, fadeOut, initFadeMotion } from './fade';
+import { initMoveMotion, moveDownIn, moveDownOut, moveLeftIn, moveLeftOut, moveRightIn, moveRightOut, moveUpIn, moveUpOut } from './move';
+import { initSlideMotion, slideDownIn, slideDownOut, slideLeftIn, slideLeftOut, slideRightIn, slideRightOut, slideUpIn, slideUpOut } from './slide';
+import { initZoomMotion, zoomBigIn, zoomBigOut, zoomDownIn, zoomDownOut, zoomIn, zoomLeftIn, zoomLeftOut, zoomOut, zoomRightIn, zoomRightOut, zoomUpIn, zoomUpOut } from './zoom';
+export { initSlideMotion, slideUpIn, slideUpOut, slideDownIn, slideDownOut, slideLeftIn, slideLeftOut, slideRightIn, slideRightOut, zoomOut, zoomIn, zoomBigIn, zoomLeftOut, zoomBigOut, zoomLeftIn, zoomRightIn, zoomUpIn, zoomRightOut, zoomUpOut, zoomDownIn, zoomDownOut, initZoomMotion, fadeIn, fadeOut, initFadeMotion, moveRightOut, moveRightIn, moveLeftOut, moveLeftIn, moveDownOut, moveDownIn, moveUpIn, moveUpOut, initMoveMotion, genCollapseMotion, };

node_modules/antd/lib/style/motion/index.js

@@ -0,0 +1,221 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "fadeIn", {
+  enumerable: true,
+  get: function () {
+    return _fade.fadeIn;
+  }
+});
+Object.defineProperty(exports, "fadeOut", {
+  enumerable: true,
+  get: function () {
+    return _fade.fadeOut;
+  }
+});
+Object.defineProperty(exports, "genCollapseMotion", {
+  enumerable: true,
+  get: function () {
+    return _collapse.default;
+  }
+});
+Object.defineProperty(exports, "initFadeMotion", {
+  enumerable: true,
+  get: function () {
+    return _fade.initFadeMotion;
+  }
+});
+Object.defineProperty(exports, "initMoveMotion", {
+  enumerable: true,
+  get: function () {
+    return _move.initMoveMotion;
+  }
+});
+Object.defineProperty(exports, "initSlideMotion", {
+  enumerable: true,
+  get: function () {
+    return _slide.initSlideMotion;
+  }
+});
+Object.defineProperty(exports, "initZoomMotion", {
+  enumerable: true,
+  get: function () {
+    return _zoom.initZoomMotion;
+  }
+});
+Object.defineProperty(exports, "moveDownIn", {
+  enumerable: true,
+  get: function () {
+    return _move.moveDownIn;
+  }
+});
+Object.defineProperty(exports, "moveDownOut", {
+  enumerable: true,
+  get: function () {
+    return _move.moveDownOut;
+  }
+});
+Object.defineProperty(exports, "moveLeftIn", {
+  enumerable: true,
+  get: function () {
+    return _move.moveLeftIn;
+  }
+});
+Object.defineProperty(exports, "moveLeftOut", {
+  enumerable: true,
+  get: function () {
+    return _move.moveLeftOut;
+  }
+});
+Object.defineProperty(exports, "moveRightIn", {
+  enumerable: true,
+  get: function () {
+    return _move.moveRightIn;
+  }
+});
+Object.defineProperty(exports, "moveRightOut", {
+  enumerable: true,
+  get: function () {
+    return _move.moveRightOut;
+  }
+});
+Object.defineProperty(exports, "moveUpIn", {
+  enumerable: true,
+  get: function () {
+    return _move.moveUpIn;
+  }
+});
+Object.defineProperty(exports, "moveUpOut", {
+  enumerable: true,
+  get: function () {
+    return _move.moveUpOut;
+  }
+});
+Object.defineProperty(exports, "slideDownIn", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideDownIn;
+  }
+});
+Object.defineProperty(exports, "slideDownOut", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideDownOut;
+  }
+});
+Object.defineProperty(exports, "slideLeftIn", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideLeftIn;
+  }
+});
+Object.defineProperty(exports, "slideLeftOut", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideLeftOut;
+  }
+});
+Object.defineProperty(exports, "slideRightIn", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideRightIn;
+  }
+});
+Object.defineProperty(exports, "slideRightOut", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideRightOut;
+  }
+});
+Object.defineProperty(exports, "slideUpIn", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideUpIn;
+  }
+});
+Object.defineProperty(exports, "slideUpOut", {
+  enumerable: true,
+  get: function () {
+    return _slide.slideUpOut;
+  }
+});
+Object.defineProperty(exports, "zoomBigIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomBigIn;
+  }
+});
+Object.defineProperty(exports, "zoomBigOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomBigOut;
+  }
+});
+Object.defineProperty(exports, "zoomDownIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomDownIn;
+  }
+});
+Object.defineProperty(exports, "zoomDownOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomDownOut;
+  }
+});
+Object.defineProperty(exports, "zoomIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomIn;
+  }
+});
+Object.defineProperty(exports, "zoomLeftIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomLeftIn;
+  }
+});
+Object.defineProperty(exports, "zoomLeftOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomLeftOut;
+  }
+});
+Object.defineProperty(exports, "zoomOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomOut;
+  }
+});
+Object.defineProperty(exports, "zoomRightIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomRightIn;
+  }
+});
+Object.defineProperty(exports, "zoomRightOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomRightOut;
+  }
+});
+Object.defineProperty(exports, "zoomUpIn", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomUpIn;
+  }
+});
+Object.defineProperty(exports, "zoomUpOut", {
+  enumerable: true,
+  get: function () {
+    return _zoom.zoomUpOut;
+  }
+});
+var _collapse = _interopRequireDefault(require("./collapse"));
+var _fade = require("./fade");
+var _move = require("./move");
+var _slide = require("./slide");
+var _zoom = require("./zoom");

node_modules/antd/lib/style/motion/motion.d.ts

@@ -0,0 +1,2 @@
+import type { CSSObject, Keyframes } from '@ant-design/cssinjs';
+export declare const initMotion: (motionCls: string, inKeyframes: Keyframes, outKeyframes: Keyframes, duration: string, sameLevel?: boolean) => CSSObject;

node_modules/antd/lib/style/motion/motion.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initMotion = void 0;
+const initMotionCommon = duration => ({
+  animationDuration: duration,
+  animationFillMode: 'both'
+});
+// FIXME: origin less code seems same as initMotionCommon. Maybe we can safe remove
+const initMotionCommonLeave = duration => ({
+  animationDuration: duration,
+  animationFillMode: 'both'
+});
+const initMotion = (motionCls, inKeyframes, outKeyframes, duration, sameLevel = false) => {
+  const sameLevelPrefix = sameLevel ? '&' : '';
+  return {
+    [`
+      ${sameLevelPrefix}${motionCls}-enter,
+      ${sameLevelPrefix}${motionCls}-appear
+    `]: Object.assign(Object.assign({}, initMotionCommon(duration)), {
+      animationPlayState: 'paused'
+    }),
+    [`${sameLevelPrefix}${motionCls}-leave`]: Object.assign(Object.assign({}, initMotionCommonLeave(duration)), {
+      animationPlayState: 'paused'
+    }),
+    [`
+      ${sameLevelPrefix}${motionCls}-enter${motionCls}-enter-active,
+      ${sameLevelPrefix}${motionCls}-appear${motionCls}-appear-active
+    `]: {
+      animationName: inKeyframes,
+      animationPlayState: 'running'
+    },
+    [`${sameLevelPrefix}${motionCls}-leave${motionCls}-leave-active`]: {
+      animationName: outKeyframes,
+      animationPlayState: 'running',
+      pointerEvents: 'none'
+    }
+  };
+};
+exports.initMotion = initMotion;

node_modules/antd/lib/style/motion/move.d.ts

@@ -0,0 +1,14 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import { Keyframes } from '@ant-design/cssinjs';
+import type { AliasToken, TokenWithCommonCls } from '../../theme/internal';
+export declare const moveDownIn: Keyframes;
+export declare const moveDownOut: Keyframes;
+export declare const moveLeftIn: Keyframes;
+export declare const moveLeftOut: Keyframes;
+export declare const moveRightIn: Keyframes;
+export declare const moveRightOut: Keyframes;
+export declare const moveUpIn: Keyframes;
+export declare const moveUpOut: Keyframes;
+type MoveMotionTypes = 'move-up' | 'move-down' | 'move-left' | 'move-right';
+export declare const initMoveMotion: (token: TokenWithCommonCls<AliasToken>, motionName: MoveMotionTypes) => CSSInterpolation;
+export {};

node_modules/antd/lib/style/motion/move.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveUpOut = exports.moveUpIn = exports.moveRightOut = exports.moveRightIn = exports.moveLeftOut = exports.moveLeftIn = exports.moveDownOut = exports.moveDownIn = exports.initMoveMotion = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _motion = require("./motion");
+const moveDownIn = exports.moveDownIn = new _cssinjs.Keyframes('antMoveDownIn', {
+  '0%': {
+    transform: 'translate3d(0, 100%, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  }
+});
+const moveDownOut = exports.moveDownOut = new _cssinjs.Keyframes('antMoveDownOut', {
+  '0%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'translate3d(0, 100%, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  }
+});
+const moveLeftIn = exports.moveLeftIn = new _cssinjs.Keyframes('antMoveLeftIn', {
+  '0%': {
+    transform: 'translate3d(-100%, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  }
+});
+const moveLeftOut = exports.moveLeftOut = new _cssinjs.Keyframes('antMoveLeftOut', {
+  '0%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'translate3d(-100%, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  }
+});
+const moveRightIn = exports.moveRightIn = new _cssinjs.Keyframes('antMoveRightIn', {
+  '0%': {
+    transform: 'translate3d(100%, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  }
+});
+const moveRightOut = exports.moveRightOut = new _cssinjs.Keyframes('antMoveRightOut', {
+  '0%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'translate3d(100%, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  }
+});
+const moveUpIn = exports.moveUpIn = new _cssinjs.Keyframes('antMoveUpIn', {
+  '0%': {
+    transform: 'translate3d(0, -100%, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  }
+});
+const moveUpOut = exports.moveUpOut = new _cssinjs.Keyframes('antMoveUpOut', {
+  '0%': {
+    transform: 'translate3d(0, 0, 0)',
+    transformOrigin: '0 0',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'translate3d(0, -100%, 0)',
+    transformOrigin: '0 0',
+    opacity: 0
+  }
+});
+const moveMotion = {
+  'move-up': {
+    inKeyframes: moveUpIn,
+    outKeyframes: moveUpOut
+  },
+  'move-down': {
+    inKeyframes: moveDownIn,
+    outKeyframes: moveDownOut
+  },
+  'move-left': {
+    inKeyframes: moveLeftIn,
+    outKeyframes: moveLeftOut
+  },
+  'move-right': {
+    inKeyframes: moveRightIn,
+    outKeyframes: moveRightOut
+  }
+};
+const initMoveMotion = (token, motionName) => {
+  const {
+    antCls
+  } = token;
+  const motionCls = `${antCls}-${motionName}`;
+  const {
+    inKeyframes,
+    outKeyframes
+  } = moveMotion[motionName];
+  return [(0, _motion.initMotion)(motionCls, inKeyframes, outKeyframes, token.motionDurationMid), {
+    [`
+        ${motionCls}-enter,
+        ${motionCls}-appear
+      `]: {
+      opacity: 0,
+      animationTimingFunction: token.motionEaseOutCirc
+    },
+    [`${motionCls}-leave`]: {
+      animationTimingFunction: token.motionEaseInOutCirc
+    }
+  }];
+};
+exports.initMoveMotion = initMoveMotion;

node_modules/antd/lib/style/motion/slide.d.ts

@@ -0,0 +1,14 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import { Keyframes } from '@ant-design/cssinjs';
+import type { AliasToken, TokenWithCommonCls } from '../../theme/internal';
+export declare const slideUpIn: Keyframes;
+export declare const slideUpOut: Keyframes;
+export declare const slideDownIn: Keyframes;
+export declare const slideDownOut: Keyframes;
+export declare const slideLeftIn: Keyframes;
+export declare const slideLeftOut: Keyframes;
+export declare const slideRightIn: Keyframes;
+export declare const slideRightOut: Keyframes;
+type SlideMotionTypes = 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right';
+export declare const initSlideMotion: (token: TokenWithCommonCls<AliasToken>, motionName: SlideMotionTypes) => CSSInterpolation;
+export {};

node_modules/antd/lib/style/motion/slide.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slideUpOut = exports.slideUpIn = exports.slideRightOut = exports.slideRightIn = exports.slideLeftOut = exports.slideLeftIn = exports.slideDownOut = exports.slideDownIn = exports.initSlideMotion = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _motion = require("./motion");
+const slideUpIn = exports.slideUpIn = new _cssinjs.Keyframes('antSlideUpIn', {
+  '0%': {
+    transform: 'scaleY(0.8)',
+    transformOrigin: '0% 0%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scaleY(1)',
+    transformOrigin: '0% 0%',
+    opacity: 1
+  }
+});
+const slideUpOut = exports.slideUpOut = new _cssinjs.Keyframes('antSlideUpOut', {
+  '0%': {
+    transform: 'scaleY(1)',
+    transformOrigin: '0% 0%',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'scaleY(0.8)',
+    transformOrigin: '0% 0%',
+    opacity: 0
+  }
+});
+const slideDownIn = exports.slideDownIn = new _cssinjs.Keyframes('antSlideDownIn', {
+  '0%': {
+    transform: 'scaleY(0.8)',
+    transformOrigin: '100% 100%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scaleY(1)',
+    transformOrigin: '100% 100%',
+    opacity: 1
+  }
+});
+const slideDownOut = exports.slideDownOut = new _cssinjs.Keyframes('antSlideDownOut', {
+  '0%': {
+    transform: 'scaleY(1)',
+    transformOrigin: '100% 100%',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'scaleY(0.8)',
+    transformOrigin: '100% 100%',
+    opacity: 0
+  }
+});
+const slideLeftIn = exports.slideLeftIn = new _cssinjs.Keyframes('antSlideLeftIn', {
+  '0%': {
+    transform: 'scaleX(0.8)',
+    transformOrigin: '0% 0%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scaleX(1)',
+    transformOrigin: '0% 0%',
+    opacity: 1
+  }
+});
+const slideLeftOut = exports.slideLeftOut = new _cssinjs.Keyframes('antSlideLeftOut', {
+  '0%': {
+    transform: 'scaleX(1)',
+    transformOrigin: '0% 0%',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'scaleX(0.8)',
+    transformOrigin: '0% 0%',
+    opacity: 0
+  }
+});
+const slideRightIn = exports.slideRightIn = new _cssinjs.Keyframes('antSlideRightIn', {
+  '0%': {
+    transform: 'scaleX(0.8)',
+    transformOrigin: '100% 0%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scaleX(1)',
+    transformOrigin: '100% 0%',
+    opacity: 1
+  }
+});
+const slideRightOut = exports.slideRightOut = new _cssinjs.Keyframes('antSlideRightOut', {
+  '0%': {
+    transform: 'scaleX(1)',
+    transformOrigin: '100% 0%',
+    opacity: 1
+  },
+  '100%': {
+    transform: 'scaleX(0.8)',
+    transformOrigin: '100% 0%',
+    opacity: 0
+  }
+});
+const slideMotion = {
+  'slide-up': {
+    inKeyframes: slideUpIn,
+    outKeyframes: slideUpOut
+  },
+  'slide-down': {
+    inKeyframes: slideDownIn,
+    outKeyframes: slideDownOut
+  },
+  'slide-left': {
+    inKeyframes: slideLeftIn,
+    outKeyframes: slideLeftOut
+  },
+  'slide-right': {
+    inKeyframes: slideRightIn,
+    outKeyframes: slideRightOut
+  }
+};
+const initSlideMotion = (token, motionName) => {
+  const {
+    antCls
+  } = token;
+  const motionCls = `${antCls}-${motionName}`;
+  const {
+    inKeyframes,
+    outKeyframes
+  } = slideMotion[motionName];
+  return [(0, _motion.initMotion)(motionCls, inKeyframes, outKeyframes, token.motionDurationMid), {
+    [`
+      ${motionCls}-enter,
+      ${motionCls}-appear
+    `]: {
+      transform: 'scale(0)',
+      transformOrigin: '0% 0%',
+      opacity: 0,
+      animationTimingFunction: token.motionEaseOutQuint,
+      '&-prepare': {
+        transform: 'scale(1)'
+      }
+    },
+    [`${motionCls}-leave`]: {
+      animationTimingFunction: token.motionEaseInQuint
+    }
+  }];
+};
+exports.initSlideMotion = initSlideMotion;

node_modules/antd/lib/style/motion/zoom.d.ts

@@ -0,0 +1,18 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import { Keyframes } from '@ant-design/cssinjs';
+import type { AliasToken, TokenWithCommonCls } from '../../theme/internal';
+export declare const zoomIn: Keyframes;
+export declare const zoomOut: Keyframes;
+export declare const zoomBigIn: Keyframes;
+export declare const zoomBigOut: Keyframes;
+export declare const zoomUpIn: Keyframes;
+export declare const zoomUpOut: Keyframes;
+export declare const zoomLeftIn: Keyframes;
+export declare const zoomLeftOut: Keyframes;
+export declare const zoomRightIn: Keyframes;
+export declare const zoomRightOut: Keyframes;
+export declare const zoomDownIn: Keyframes;
+export declare const zoomDownOut: Keyframes;
+type ZoomMotionTypes = 'zoom' | 'zoom-big' | 'zoom-big-fast' | 'zoom-left' | 'zoom-right' | 'zoom-up' | 'zoom-down';
+export declare const initZoomMotion: (token: TokenWithCommonCls<AliasToken>, motionName: ZoomMotionTypes) => CSSInterpolation;
+export {};

node_modules/antd/lib/style/motion/zoom.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zoomUpOut = exports.zoomUpIn = exports.zoomRightOut = exports.zoomRightIn = exports.zoomOut = exports.zoomLeftOut = exports.zoomLeftIn = exports.zoomIn = exports.zoomDownOut = exports.zoomDownIn = exports.zoomBigOut = exports.zoomBigIn = exports.initZoomMotion = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _motion = require("./motion");
+const zoomIn = exports.zoomIn = new _cssinjs.Keyframes('antZoomIn', {
+  '0%': {
+    transform: 'scale(0.2)',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    opacity: 1
+  }
+});
+const zoomOut = exports.zoomOut = new _cssinjs.Keyframes('antZoomOut', {
+  '0%': {
+    transform: 'scale(1)'
+  },
+  '100%': {
+    transform: 'scale(0.2)',
+    opacity: 0
+  }
+});
+const zoomBigIn = exports.zoomBigIn = new _cssinjs.Keyframes('antZoomBigIn', {
+  '0%': {
+    transform: 'scale(0.8)',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    opacity: 1
+  }
+});
+const zoomBigOut = exports.zoomBigOut = new _cssinjs.Keyframes('antZoomBigOut', {
+  '0%': {
+    transform: 'scale(1)'
+  },
+  '100%': {
+    transform: 'scale(0.8)',
+    opacity: 0
+  }
+});
+const zoomUpIn = exports.zoomUpIn = new _cssinjs.Keyframes('antZoomUpIn', {
+  '0%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '50% 0%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    transformOrigin: '50% 0%'
+  }
+});
+const zoomUpOut = exports.zoomUpOut = new _cssinjs.Keyframes('antZoomUpOut', {
+  '0%': {
+    transform: 'scale(1)',
+    transformOrigin: '50% 0%'
+  },
+  '100%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '50% 0%',
+    opacity: 0
+  }
+});
+const zoomLeftIn = exports.zoomLeftIn = new _cssinjs.Keyframes('antZoomLeftIn', {
+  '0%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '0% 50%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    transformOrigin: '0% 50%'
+  }
+});
+const zoomLeftOut = exports.zoomLeftOut = new _cssinjs.Keyframes('antZoomLeftOut', {
+  '0%': {
+    transform: 'scale(1)',
+    transformOrigin: '0% 50%'
+  },
+  '100%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '0% 50%',
+    opacity: 0
+  }
+});
+const zoomRightIn = exports.zoomRightIn = new _cssinjs.Keyframes('antZoomRightIn', {
+  '0%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '100% 50%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    transformOrigin: '100% 50%'
+  }
+});
+const zoomRightOut = exports.zoomRightOut = new _cssinjs.Keyframes('antZoomRightOut', {
+  '0%': {
+    transform: 'scale(1)',
+    transformOrigin: '100% 50%'
+  },
+  '100%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '100% 50%',
+    opacity: 0
+  }
+});
+const zoomDownIn = exports.zoomDownIn = new _cssinjs.Keyframes('antZoomDownIn', {
+  '0%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '50% 100%',
+    opacity: 0
+  },
+  '100%': {
+    transform: 'scale(1)',
+    transformOrigin: '50% 100%'
+  }
+});
+const zoomDownOut = exports.zoomDownOut = new _cssinjs.Keyframes('antZoomDownOut', {
+  '0%': {
+    transform: 'scale(1)',
+    transformOrigin: '50% 100%'
+  },
+  '100%': {
+    transform: 'scale(0.8)',
+    transformOrigin: '50% 100%',
+    opacity: 0
+  }
+});
+const zoomMotion = {
+  zoom: {
+    inKeyframes: zoomIn,
+    outKeyframes: zoomOut
+  },
+  'zoom-big': {
+    inKeyframes: zoomBigIn,
+    outKeyframes: zoomBigOut
+  },
+  'zoom-big-fast': {
+    inKeyframes: zoomBigIn,
+    outKeyframes: zoomBigOut
+  },
+  'zoom-left': {
+    inKeyframes: zoomLeftIn,
+    outKeyframes: zoomLeftOut
+  },
+  'zoom-right': {
+    inKeyframes: zoomRightIn,
+    outKeyframes: zoomRightOut
+  },
+  'zoom-up': {
+    inKeyframes: zoomUpIn,
+    outKeyframes: zoomUpOut
+  },
+  'zoom-down': {
+    inKeyframes: zoomDownIn,
+    outKeyframes: zoomDownOut
+  }
+};
+const initZoomMotion = (token, motionName) => {
+  const {
+    antCls
+  } = token;
+  const motionCls = `${antCls}-${motionName}`;
+  const {
+    inKeyframes,
+    outKeyframes
+  } = zoomMotion[motionName];
+  return [(0, _motion.initMotion)(motionCls, inKeyframes, outKeyframes, motionName === 'zoom-big-fast' ? token.motionDurationFast : token.motionDurationMid), {
+    [`
+        ${motionCls}-enter,
+        ${motionCls}-appear
+      `]: {
+      transform: 'scale(0)',
+      opacity: 0,
+      animationTimingFunction: token.motionEaseOutCirc,
+      '&-prepare': {
+        transform: 'none'
+      }
+    },
+    [`${motionCls}-leave`]: {
+      animationTimingFunction: token.motionEaseInOutCirc
+    }
+  }];
+};
+exports.initZoomMotion = initZoomMotion;

node_modules/antd/lib/style/placementArrow.d.ts

@@ -0,0 +1,19 @@
+import type { CSSInterpolation } from '@ant-design/cssinjs';
+import type { AliasToken, TokenWithCommonCls } from '../theme/internal';
+import type { ArrowToken } from './roundedArrow';
+export declare const MAX_VERTICAL_CONTENT_RADIUS = 8;
+export interface ArrowOffsetToken {
+}
+export declare function getArrowOffsetToken(options: {
+    contentRadius: number;
+    limitVerticalRadius?: boolean;
+}): ArrowOffsetToken;
+export default function getArrowStyle<Token extends TokenWithCommonCls<AliasToken> & ArrowOffsetToken & ArrowToken>(token: Token, colorBg: string, options?: {
+    arrowDistance?: number;
+    arrowPlacement?: {
+        left?: boolean;
+        right?: boolean;
+        top?: boolean;
+        bottom?: boolean;
+    };
+}): CSSInterpolation;

node_modules/antd/lib/style/placementArrow.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_VERTICAL_CONTENT_RADIUS = void 0;
+exports.default = getArrowStyle;
+exports.getArrowOffsetToken = getArrowOffsetToken;
+var _cssinjs = require("@ant-design/cssinjs");
+var _roundedArrow = require("./roundedArrow");
+const MAX_VERTICAL_CONTENT_RADIUS = exports.MAX_VERTICAL_CONTENT_RADIUS = 8;
+function getArrowOffsetToken(options) {
+  const {
+    contentRadius,
+    limitVerticalRadius
+  } = options;
+  const arrowOffset = contentRadius > 12 ? contentRadius + 2 : 12;
+  const arrowOffsetVertical = limitVerticalRadius ? MAX_VERTICAL_CONTENT_RADIUS : arrowOffset;
+  return {
+    arrowOffsetHorizontal: arrowOffset,
+    arrowOffsetVertical
+  };
+}
+function isInject(valid, code) {
+  if (!valid) {
+    return {};
+  }
+  return code;
+}
+function getArrowStyle(token, colorBg, options) {
+  const {
+    componentCls,
+    boxShadowPopoverArrow,
+    arrowOffsetVertical,
+    arrowOffsetHorizontal
+  } = token;
+  const {
+    arrowDistance = 0,
+    arrowPlacement = {
+      left: true,
+      right: true,
+      top: true,
+      bottom: true
+    }
+  } = options || {};
+  return {
+    [componentCls]: Object.assign(Object.assign(Object.assign(Object.assign({
+      // ============================ Basic ============================
+      [`${componentCls}-arrow`]: [Object.assign(Object.assign({
+        position: 'absolute',
+        zIndex: 1,
+        display: 'block'
+      }, (0, _roundedArrow.genRoundedArrow)(token, colorBg, boxShadowPopoverArrow)), {
+        '&:before': {
+          background: colorBg
+        }
+      })]
+    }, isInject(!!arrowPlacement.top, {
+      [[`&-placement-top > ${componentCls}-arrow`, `&-placement-topLeft > ${componentCls}-arrow`, `&-placement-topRight > ${componentCls}-arrow`].join(',')]: {
+        bottom: arrowDistance,
+        transform: 'translateY(100%) rotate(180deg)'
+      },
+      [`&-placement-top > ${componentCls}-arrow`]: {
+        left: {
+          _skip_check_: true,
+          value: '50%'
+        },
+        transform: 'translateX(-50%) translateY(100%) rotate(180deg)'
+      },
+      '&-placement-topLeft': {
+        '--arrow-offset-horizontal': arrowOffsetHorizontal,
+        [`> ${componentCls}-arrow`]: {
+          left: {
+            _skip_check_: true,
+            value: arrowOffsetHorizontal
+          }
+        }
+      },
+      '&-placement-topRight': {
+        '--arrow-offset-horizontal': `calc(100% - ${(0, _cssinjs.unit)(arrowOffsetHorizontal)})`,
+        [`> ${componentCls}-arrow`]: {
+          right: {
+            _skip_check_: true,
+            value: arrowOffsetHorizontal
+          }
+        }
+      }
+    })), isInject(!!arrowPlacement.bottom, {
+      [[`&-placement-bottom > ${componentCls}-arrow`, `&-placement-bottomLeft > ${componentCls}-arrow`, `&-placement-bottomRight > ${componentCls}-arrow`].join(',')]: {
+        top: arrowDistance,
+        transform: `translateY(-100%)`
+      },
+      [`&-placement-bottom > ${componentCls}-arrow`]: {
+        left: {
+          _skip_check_: true,
+          value: '50%'
+        },
+        transform: `translateX(-50%) translateY(-100%)`
+      },
+      '&-placement-bottomLeft': {
+        '--arrow-offset-horizontal': arrowOffsetHorizontal,
+        [`> ${componentCls}-arrow`]: {
+          left: {
+            _skip_check_: true,
+            value: arrowOffsetHorizontal
+          }
+        }
+      },
+      '&-placement-bottomRight': {
+        '--arrow-offset-horizontal': `calc(100% - ${(0, _cssinjs.unit)(arrowOffsetHorizontal)})`,
+        [`> ${componentCls}-arrow`]: {
+          right: {
+            _skip_check_: true,
+            value: arrowOffsetHorizontal
+          }
+        }
+      }
+    })), isInject(!!arrowPlacement.left, {
+      [[`&-placement-left > ${componentCls}-arrow`, `&-placement-leftTop > ${componentCls}-arrow`, `&-placement-leftBottom > ${componentCls}-arrow`].join(',')]: {
+        right: {
+          _skip_check_: true,
+          value: arrowDistance
+        },
+        transform: 'translateX(100%) rotate(90deg)'
+      },
+      [`&-placement-left > ${componentCls}-arrow`]: {
+        top: {
+          _skip_check_: true,
+          value: '50%'
+        },
+        transform: 'translateY(-50%) translateX(100%) rotate(90deg)'
+      },
+      [`&-placement-leftTop > ${componentCls}-arrow`]: {
+        top: arrowOffsetVertical
+      },
+      [`&-placement-leftBottom > ${componentCls}-arrow`]: {
+        bottom: arrowOffsetVertical
+      }
+    })), isInject(!!arrowPlacement.right, {
+      [[`&-placement-right > ${componentCls}-arrow`, `&-placement-rightTop > ${componentCls}-arrow`, `&-placement-rightBottom > ${componentCls}-arrow`].join(',')]: {
+        left: {
+          _skip_check_: true,
+          value: arrowDistance
+        },
+        transform: 'translateX(-100%) rotate(-90deg)'
+      },
+      [`&-placement-right > ${componentCls}-arrow`]: {
+        top: {
+          _skip_check_: true,
+          value: '50%'
+        },
+        transform: 'translateY(-50%) translateX(-100%) rotate(-90deg)'
+      },
+      [`&-placement-rightTop > ${componentCls}-arrow`]: {
+        top: arrowOffsetVertical
+      },
+      [`&-placement-rightBottom > ${componentCls}-arrow`]: {
+        bottom: arrowOffsetVertical
+      }
+    }))
+  };
+}

node_modules/antd/lib/style/reset.css

@@ -0,0 +1,252 @@
+/* stylelint-disable */
+html,
+body {
+  width: 100%;
+  height: 100%;
+}
+input::-ms-clear,
+input::-ms-reveal {
+  display: none;
+}
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+html {
+  font-family: sans-serif;
+  line-height: 1.15;
+  -webkit-text-size-adjust: 100%;
+  -ms-text-size-adjust: 100%;
+  -ms-overflow-style: scrollbar;
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+@-ms-viewport {
+  width: device-width;
+}
+body {
+  margin: 0;
+}
+[tabindex='-1']:focus {
+  outline: none;
+}
+hr {
+  box-sizing: content-box;
+  height: 0;
+  overflow: visible;
+}
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin-top: 0;
+  margin-bottom: 0.5em;
+  font-weight: 500;
+}
+p {
+  margin-top: 0;
+  margin-bottom: 1em;
+}
+abbr[title],
+abbr[data-original-title] {
+  -webkit-text-decoration: underline dotted;
+  text-decoration: underline dotted;
+  border-bottom: 0;
+  cursor: help;
+}
+address {
+  margin-bottom: 1em;
+  font-style: normal;
+  line-height: inherit;
+}
+input[type='text'],
+input[type='password'],
+input[type='number'],
+textarea {
+  -webkit-appearance: none;
+}
+ol,
+ul,
+dl {
+  margin-top: 0;
+  margin-bottom: 1em;
+}
+ol ol,
+ul ul,
+ol ul,
+ul ol {
+  margin-bottom: 0;
+}
+dt {
+  font-weight: 500;
+}
+dd {
+  margin-bottom: 0.5em;
+  margin-left: 0;
+}
+blockquote {
+  margin: 0 0 1em;
+}
+dfn {
+  font-style: italic;
+}
+b,
+strong {
+  font-weight: bolder;
+}
+small {
+  font-size: 80%;
+}
+sub,
+sup {
+  position: relative;
+  font-size: 75%;
+  line-height: 0;
+  vertical-align: baseline;
+}
+sub {
+  bottom: -0.25em;
+}
+sup {
+  top: -0.5em;
+}
+pre,
+code,
+kbd,
+samp {
+  font-size: 1em;
+  font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace;
+}
+pre {
+  margin-top: 0;
+  margin-bottom: 1em;
+  overflow: auto;
+}
+figure {
+  margin: 0 0 1em;
+}
+img {
+  vertical-align: middle;
+  border-style: none;
+}
+a,
+area,
+button,
+[role='button'],
+input:not([type='range']),
+label,
+select,
+summary,
+textarea {
+  touch-action: manipulation;
+}
+table {
+  border-collapse: collapse;
+}
+caption {
+  padding-top: 0.75em;
+  padding-bottom: 0.3em;
+  text-align: left;
+  caption-side: bottom;
+}
+input,
+button,
+select,
+optgroup,
+textarea {
+  margin: 0;
+  color: inherit;
+  font-size: inherit;
+  font-family: inherit;
+  line-height: inherit;
+}
+button,
+input {
+  overflow: visible;
+}
+button,
+select {
+  text-transform: none;
+}
+button,
+html [type='button'],
+[type='reset'],
+[type='submit'] {
+  -webkit-appearance: button;
+}
+button::-moz-focus-inner,
+[type='button']::-moz-focus-inner,
+[type='reset']::-moz-focus-inner,
+[type='submit']::-moz-focus-inner {
+  padding: 0;
+  border-style: none;
+}
+input[type='radio'],
+input[type='checkbox'] {
+  box-sizing: border-box;
+  padding: 0;
+}
+input[type='date'],
+input[type='time'],
+input[type='datetime-local'],
+input[type='month'] {
+  -webkit-appearance: listbox;
+}
+textarea {
+  overflow: auto;
+  resize: vertical;
+}
+fieldset {
+  min-width: 0;
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+legend {
+  display: block;
+  width: 100%;
+  max-width: 100%;
+  margin-bottom: 0.5em;
+  padding: 0;
+  color: inherit;
+  font-size: 1.5em;
+  line-height: inherit;
+  white-space: normal;
+}
+progress {
+  vertical-align: baseline;
+}
+[type='number']::-webkit-inner-spin-button,
+[type='number']::-webkit-outer-spin-button {
+  height: auto;
+}
+[type='search'] {
+  outline-offset: -2px;
+  -webkit-appearance: none;
+}
+[type='search']::-webkit-search-cancel-button,
+[type='search']::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+::-webkit-file-upload-button {
+  font: inherit;
+  -webkit-appearance: button;
+}
+output {
+  display: inline-block;
+}
+summary {
+  display: list-item;
+}
+template {
+  display: none;
+}
+[hidden] {
+  display: none !important;
+}
+mark {
+  padding: 0.2em;
+  background-color: #feffe6;
+}

node_modules/antd/lib/style/roundedArrow.d.ts

@@ -0,0 +1,7 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { AliasToken } from '../theme/interface';
+import type { CSSUtil } from '../theme/internal';
+export interface ArrowToken {
+}
+export declare function getArrowToken(token: AliasToken): ArrowToken;
+export declare const genRoundedArrow: <T extends AliasToken & ArrowToken & CSSUtil>(token: T, bgColor: string, boxShadow: string) => CSSObject;

node_modules/antd/lib/style/roundedArrow.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genRoundedArrow = void 0;
+exports.getArrowToken = getArrowToken;
+var _cssinjs = require("@ant-design/cssinjs");
+function getArrowToken(token) {
+  const {
+    sizePopupArrow,
+    borderRadiusXS,
+    borderRadiusOuter
+  } = token;
+  const unitWidth = sizePopupArrow / 2;
+  const ax = 0;
+  const ay = unitWidth;
+  const bx = borderRadiusOuter * 1 / Math.sqrt(2);
+  const by = unitWidth - borderRadiusOuter * (1 - 1 / Math.sqrt(2));
+  const cx = unitWidth - borderRadiusXS * (1 / Math.sqrt(2));
+  const cy = borderRadiusOuter * (Math.sqrt(2) - 1) + borderRadiusXS * (1 / Math.sqrt(2));
+  const dx = 2 * unitWidth - cx;
+  const dy = cy;
+  const ex = 2 * unitWidth - bx;
+  const ey = by;
+  const fx = 2 * unitWidth - ax;
+  const fy = ay;
+  const shadowWidth = unitWidth * Math.sqrt(2) + borderRadiusOuter * (Math.sqrt(2) - 2);
+  const polygonOffset = borderRadiusOuter * (Math.sqrt(2) - 1);
+  const arrowPolygon = `polygon(${polygonOffset}px 100%, 50% ${polygonOffset}px, ${2 * unitWidth - polygonOffset}px 100%, ${polygonOffset}px 100%)`;
+  const arrowPath = `path('M ${ax} ${ay} A ${borderRadiusOuter} ${borderRadiusOuter} 0 0 0 ${bx} ${by} L ${cx} ${cy} A ${borderRadiusXS} ${borderRadiusXS} 0 0 1 ${dx} ${dy} L ${ex} ${ey} A ${borderRadiusOuter} ${borderRadiusOuter} 0 0 0 ${fx} ${fy} Z')`;
+  return {
+    arrowShadowWidth: shadowWidth,
+    arrowPath,
+    arrowPolygon
+  };
+}
+const genRoundedArrow = (token, bgColor, boxShadow) => {
+  const {
+    sizePopupArrow,
+    arrowPolygon,
+    arrowPath,
+    arrowShadowWidth,
+    borderRadiusXS,
+    calc
+  } = token;
+  return {
+    pointerEvents: 'none',
+    width: sizePopupArrow,
+    height: sizePopupArrow,
+    overflow: 'hidden',
+    '&::before': {
+      position: 'absolute',
+      bottom: 0,
+      insetInlineStart: 0,
+      width: sizePopupArrow,
+      height: calc(sizePopupArrow).div(2).equal(),
+      background: bgColor,
+      clipPath: {
+        _multi_value_: true,
+        value: [arrowPolygon, arrowPath]
+      },
+      content: '""'
+    },
+    '&::after': {
+      content: '""',
+      position: 'absolute',
+      width: arrowShadowWidth,
+      height: arrowShadowWidth,
+      bottom: 0,
+      insetInline: 0,
+      margin: 'auto',
+      borderRadius: {
+        _skip_check_: true,
+        value: `0 0 ${(0, _cssinjs.unit)(borderRadiusXS)} 0`
+      },
+      transform: 'translateY(50%) rotate(-135deg)',
+      boxShadow,
+      zIndex: 0,
+      background: 'transparent'
+    }
+  };
+};
+exports.genRoundedArrow = genRoundedArrow;