agentworkshop 0.8.2 → 0.8.4

package/.output/server/chunks/build/tag-CRW-anwy.mjs

@@ -0,0 +1,1010 @@
+import { k as useConfigInject_default, q as classNames, r as _objectSpread2, X as wave_default, Y as useInjectDisabled, o as _extends, Z as omit, x as genComponentStyleHook, y as merge, B as CloseOutlined, P as PropTypes, O as eventType, J as functionType, E as stringType, I as booleanType, $ as arrayType, v as initDefaultProps, K as resetComponent, a0 as capitalize, a1 as isObject, L as Keyframe, a2 as genFocusOutline, a3 as root } from '../virtual/entry.mjs';
+import { i as isPresetColor, a as isPresetStatusColor, g as genPresetColor } from './tooltip-GlMrUZzx.mjs';
+import { a as isSymbol } from './input-CJgB-RL6.mjs';
+import { u as useInjectFormItemContext, F as FormItemInputContext } from './FormItemContext-DmuQqaeJ.mjs';
+import { defineComponent, shallowRef, watchEffect, computed, createVNode, Fragment, ref, watch, provide, inject, nextTick } from 'vue';
+
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) ;
+  return index;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var NAN = NaN;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") return value;
+  if (isSymbol(value)) return NAN;
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(other) ? other + "" : other;
+  }
+  if (typeof value != "string") return value === 0 ? value : +value;
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var now = function() {
+  return root.Date.now();
+};
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max;
+var nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") throw new TypeError(FUNC_ERROR_TEXT);
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) return trailingEdge(time);
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) return invokeFunc(time);
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) clearTimeout(timerId);
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now());
+  }
+  function debounced() {
+    var time = now(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) return leadingEdge(lastCallTime);
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) timerId = setTimeout(timerExpired, wait);
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+var __rest$1 = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+var checkboxProps = {
+  prefixCls: String,
+  name: String,
+  id: String,
+  type: String,
+  defaultChecked: {
+    type: [Boolean, Number],
+    default: void 0
+  },
+  checked: {
+    type: [Boolean, Number],
+    default: void 0
+  },
+  disabled: Boolean,
+  tabindex: { type: [Number, String] },
+  readonly: Boolean,
+  autofocus: Boolean,
+  value: PropTypes.any,
+  required: Boolean
+};
+var Checkbox_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "Checkbox",
+  inheritAttrs: false,
+  props: initDefaultProps(checkboxProps, {
+    prefixCls: "rc-checkbox",
+    type: "checkbox",
+    defaultChecked: false
+  }),
+  emits: ["click", "change"],
+  setup(props, _ref) {
+    let { attrs, emit, expose } = _ref;
+    const checked = ref(props.checked === void 0 ? props.defaultChecked : props.checked);
+    const inputRef = ref();
+    watch(() => props.checked, () => {
+      checked.value = props.checked;
+    });
+    expose({
+      focus() {
+        var _a;
+        (_a = inputRef.value) === null || _a === void 0 || _a.focus();
+      },
+      blur() {
+        var _a;
+        (_a = inputRef.value) === null || _a === void 0 || _a.blur();
+      }
+    });
+    const eventShiftKey = ref();
+    const handleChange = (e) => {
+      if (props.disabled) return;
+      if (props.checked === void 0) checked.value = e.target.checked;
+      e.shiftKey = eventShiftKey.value;
+      const eventObj = {
+        target: _extends(_extends({}, props), { checked: e.target.checked }),
+        stopPropagation() {
+          e.stopPropagation();
+        },
+        preventDefault() {
+          e.preventDefault();
+        },
+        nativeEvent: e
+      };
+      if (props.checked !== void 0) inputRef.value.checked = !!props.checked;
+      emit("change", eventObj);
+      eventShiftKey.value = false;
+    };
+    const onClick = (e) => {
+      emit("click", e);
+      eventShiftKey.value = e.shiftKey;
+    };
+    return () => {
+      const { prefixCls, name, id, type, disabled, readonly, tabindex, autofocus, value, required } = props, others = __rest$1(props, [
+        "prefixCls",
+        "name",
+        "id",
+        "type",
+        "disabled",
+        "readonly",
+        "tabindex",
+        "autofocus",
+        "value",
+        "required"
+      ]);
+      const { class: className, onFocus, onBlur, onKeydown, onKeypress, onKeyup } = attrs;
+      const othersAndAttrs = _extends(_extends({}, others), attrs);
+      const globalProps = Object.keys(othersAndAttrs).reduce((prev, key) => {
+        if (key.startsWith("data-") || key.startsWith("aria-") || key === "role") prev[key] = othersAndAttrs[key];
+        return prev;
+      }, {});
+      const classString = classNames(prefixCls, className, {
+        [`${prefixCls}-checked`]: checked.value,
+        [`${prefixCls}-disabled`]: disabled
+      });
+      const inputProps = _extends(_extends({
+        name,
+        id,
+        type,
+        readonly,
+        disabled,
+        tabindex,
+        class: `${prefixCls}-input`,
+        checked: !!checked.value,
+        autofocus,
+        value
+      }, globalProps), {
+        onChange: handleChange,
+        onClick,
+        onFocus,
+        onBlur,
+        onKeydown,
+        onKeypress,
+        onKeyup,
+        required
+      });
+      return createVNode("span", { "class": classString }, [createVNode("input", _objectSpread2({ "ref": inputRef }, inputProps), null), createVNode("span", { "class": `${prefixCls}-inner` }, null)]);
+    };
+  }
+});
+var radioGroupContextKey = /* @__PURE__ */ Symbol("radioGroupContextKey");
+var useProvideRadioGroupContext = (props) => {
+  provide(radioGroupContextKey, props);
+};
+var useInjectRadioGroupContext = () => {
+  return inject(radioGroupContextKey, void 0);
+};
+var radioOptionTypeContextKey = /* @__PURE__ */ Symbol("radioOptionTypeContextKey");
+var useProvideRadioOptionTypeContext = (props) => {
+  provide(radioOptionTypeContextKey, props);
+};
+var useInjectRadioOptionTypeContext = () => {
+  return inject(radioOptionTypeContextKey, void 0);
+};
+var antRadioEffect = new Keyframe("antRadioEffect", {
+  "0%": {
+    transform: "scale(1)",
+    opacity: 0.5
+  },
+  "100%": {
+    transform: "scale(1.6)",
+    opacity: 0
+  }
+});
+var getGroupRadioStyle = (token) => {
+  const { componentCls, antCls } = token;
+  const groupPrefixCls = `${componentCls}-group`;
+  return { [groupPrefixCls]: _extends(_extends({}, resetComponent(token)), {
+    display: "inline-block",
+    fontSize: 0,
+    [`&${groupPrefixCls}-rtl`]: { direction: "rtl" },
+    [`${antCls}-badge ${antCls}-badge-count`]: { zIndex: 1 },
+    [`> ${antCls}-badge:not(:first-child) > ${antCls}-button-wrapper`]: { borderInlineStart: "none" }
+  }) };
+};
+var getRadioBasicStyle = (token) => {
+  const { componentCls, radioWrapperMarginRight, radioCheckedColor, radioSize, motionDurationSlow, motionDurationMid, motionEaseInOut, motionEaseInOutCirc, radioButtonBg, colorBorder, lineWidth, radioDotSize, colorBgContainerDisabled, colorTextDisabled, paddingXS, radioDotDisabledColor, lineType, radioDotDisabledSize, wireframe, colorWhite } = token;
+  const radioInnerPrefixCls = `${componentCls}-inner`;
+  return { [`${componentCls}-wrapper`]: _extends(_extends({}, resetComponent(token)), {
+    position: "relative",
+    display: "inline-flex",
+    alignItems: "baseline",
+    marginInlineStart: 0,
+    marginInlineEnd: radioWrapperMarginRight,
+    cursor: "pointer",
+    [`&${componentCls}-wrapper-rtl`]: { direction: "rtl" },
+    "&-disabled": {
+      cursor: "not-allowed",
+      color: token.colorTextDisabled
+    },
+    "&::after": {
+      display: "inline-block",
+      width: 0,
+      overflow: "hidden",
+      content: '"\\a0"'
+    },
+    [`${componentCls}-checked::after`]: {
+      position: "absolute",
+      insetBlockStart: 0,
+      insetInlineStart: 0,
+      width: "100%",
+      height: "100%",
+      border: `${lineWidth}px ${lineType} ${radioCheckedColor}`,
+      borderRadius: "50%",
+      visibility: "hidden",
+      animationName: antRadioEffect,
+      animationDuration: motionDurationSlow,
+      animationTimingFunction: motionEaseInOut,
+      animationFillMode: "both",
+      content: '""'
+    },
+    [componentCls]: _extends(_extends({}, resetComponent(token)), {
+      position: "relative",
+      display: "inline-block",
+      outline: "none",
+      cursor: "pointer",
+      alignSelf: "center"
+    }),
+    [`${componentCls}-wrapper:hover &,
+        &:hover ${radioInnerPrefixCls}`]: { borderColor: radioCheckedColor },
+    [`${componentCls}-input:focus-visible + ${radioInnerPrefixCls}`]: _extends({}, genFocusOutline(token)),
+    [`${componentCls}:hover::after, ${componentCls}-wrapper:hover &::after`]: { visibility: "visible" },
+    [`${componentCls}-inner`]: {
+      "&::after": {
+        boxSizing: "border-box",
+        position: "absolute",
+        insetBlockStart: "50%",
+        insetInlineStart: "50%",
+        display: "block",
+        width: radioSize,
+        height: radioSize,
+        marginBlockStart: radioSize / -2,
+        marginInlineStart: radioSize / -2,
+        backgroundColor: wireframe ? radioCheckedColor : colorWhite,
+        borderBlockStart: 0,
+        borderInlineStart: 0,
+        borderRadius: radioSize,
+        transform: "scale(0)",
+        opacity: 0,
+        transition: `all ${motionDurationSlow} ${motionEaseInOutCirc}`,
+        content: '""'
+      },
+      boxSizing: "border-box",
+      position: "relative",
+      insetBlockStart: 0,
+      insetInlineStart: 0,
+      display: "block",
+      width: radioSize,
+      height: radioSize,
+      backgroundColor: radioButtonBg,
+      borderColor: colorBorder,
+      borderStyle: "solid",
+      borderWidth: lineWidth,
+      borderRadius: "50%",
+      transition: `all ${motionDurationMid}`
+    },
+    [`${componentCls}-input`]: {
+      position: "absolute",
+      insetBlockStart: 0,
+      insetInlineEnd: 0,
+      insetBlockEnd: 0,
+      insetInlineStart: 0,
+      zIndex: 1,
+      cursor: "pointer",
+      opacity: 0
+    },
+    [`${componentCls}-checked`]: { [radioInnerPrefixCls]: {
+      borderColor: radioCheckedColor,
+      backgroundColor: wireframe ? radioButtonBg : radioCheckedColor,
+      "&::after": {
+        transform: `scale(${radioDotSize / radioSize})`,
+        opacity: 1,
+        transition: `all ${motionDurationSlow} ${motionEaseInOutCirc}`
+      }
+    } },
+    [`${componentCls}-disabled`]: {
+      cursor: "not-allowed",
+      [radioInnerPrefixCls]: {
+        backgroundColor: colorBgContainerDisabled,
+        borderColor: colorBorder,
+        cursor: "not-allowed",
+        "&::after": { backgroundColor: radioDotDisabledColor }
+      },
+      [`${componentCls}-input`]: { cursor: "not-allowed" },
+      [`${componentCls}-disabled + span`]: {
+        color: colorTextDisabled,
+        cursor: "not-allowed"
+      },
+      [`&${componentCls}-checked`]: { [radioInnerPrefixCls]: { "&::after": { transform: `scale(${radioDotDisabledSize / radioSize})` } } }
+    },
+    [`span${componentCls} + *`]: {
+      paddingInlineStart: paddingXS,
+      paddingInlineEnd: paddingXS
+    }
+  }) };
+};
+var getRadioButtonStyle = (token) => {
+  const { radioButtonColor, controlHeight, componentCls, lineWidth, lineType, colorBorder, motionDurationSlow, motionDurationMid, radioButtonPaddingHorizontal, fontSize, radioButtonBg, fontSizeLG, controlHeightLG, controlHeightSM, paddingXS, borderRadius, borderRadiusSM, borderRadiusLG, radioCheckedColor, radioButtonCheckedBg, radioButtonHoverColor, radioButtonActiveColor, radioSolidCheckedColor, colorTextDisabled, colorBgContainerDisabled, radioDisabledButtonCheckedColor, radioDisabledButtonCheckedBg } = token;
+  return { [`${componentCls}-button-wrapper`]: {
+    position: "relative",
+    display: "inline-block",
+    height: controlHeight,
+    margin: 0,
+    paddingInline: radioButtonPaddingHorizontal,
+    paddingBlock: 0,
+    color: radioButtonColor,
+    fontSize,
+    lineHeight: `${controlHeight - lineWidth * 2}px`,
+    background: radioButtonBg,
+    border: `${lineWidth}px ${lineType} ${colorBorder}`,
+    borderBlockStartWidth: lineWidth + 0.02,
+    borderInlineStartWidth: 0,
+    borderInlineEndWidth: lineWidth,
+    cursor: "pointer",
+    transition: [
+      `color ${motionDurationMid}`,
+      `background ${motionDurationMid}`,
+      `border-color ${motionDurationMid}`,
+      `box-shadow ${motionDurationMid}`
+    ].join(","),
+    a: { color: radioButtonColor },
+    [`> ${componentCls}-button`]: {
+      position: "absolute",
+      insetBlockStart: 0,
+      insetInlineStart: 0,
+      zIndex: -1,
+      width: "100%",
+      height: "100%"
+    },
+    "&:not(:first-child)": { "&::before": {
+      position: "absolute",
+      insetBlockStart: -lineWidth,
+      insetInlineStart: -lineWidth,
+      display: "block",
+      boxSizing: "content-box",
+      width: 1,
+      height: "100%",
+      paddingBlock: lineWidth,
+      paddingInline: 0,
+      backgroundColor: colorBorder,
+      transition: `background-color ${motionDurationSlow}`,
+      content: '""'
+    } },
+    "&:first-child": {
+      borderInlineStart: `${lineWidth}px ${lineType} ${colorBorder}`,
+      borderStartStartRadius: borderRadius,
+      borderEndStartRadius: borderRadius
+    },
+    "&:last-child": {
+      borderStartEndRadius: borderRadius,
+      borderEndEndRadius: borderRadius
+    },
+    "&:first-child:last-child": { borderRadius },
+    [`${componentCls}-group-large &`]: {
+      height: controlHeightLG,
+      fontSize: fontSizeLG,
+      lineHeight: `${controlHeightLG - lineWidth * 2}px`,
+      "&:first-child": {
+        borderStartStartRadius: borderRadiusLG,
+        borderEndStartRadius: borderRadiusLG
+      },
+      "&:last-child": {
+        borderStartEndRadius: borderRadiusLG,
+        borderEndEndRadius: borderRadiusLG
+      }
+    },
+    [`${componentCls}-group-small &`]: {
+      height: controlHeightSM,
+      paddingInline: paddingXS - lineWidth,
+      paddingBlock: 0,
+      lineHeight: `${controlHeightSM - lineWidth * 2}px`,
+      "&:first-child": {
+        borderStartStartRadius: borderRadiusSM,
+        borderEndStartRadius: borderRadiusSM
+      },
+      "&:last-child": {
+        borderStartEndRadius: borderRadiusSM,
+        borderEndEndRadius: borderRadiusSM
+      }
+    },
+    "&:hover": {
+      position: "relative",
+      color: radioCheckedColor
+    },
+    "&:has(:focus-visible)": _extends({}, genFocusOutline(token)),
+    [`${componentCls}-inner, input[type='checkbox'], input[type='radio']`]: {
+      width: 0,
+      height: 0,
+      opacity: 0,
+      pointerEvents: "none"
+    },
+    [`&-checked:not(${componentCls}-button-wrapper-disabled)`]: {
+      zIndex: 1,
+      color: radioCheckedColor,
+      background: radioButtonCheckedBg,
+      borderColor: radioCheckedColor,
+      "&::before": { backgroundColor: radioCheckedColor },
+      "&:first-child": { borderColor: radioCheckedColor },
+      "&:hover": {
+        color: radioButtonHoverColor,
+        borderColor: radioButtonHoverColor,
+        "&::before": { backgroundColor: radioButtonHoverColor }
+      },
+      "&:active": {
+        color: radioButtonActiveColor,
+        borderColor: radioButtonActiveColor,
+        "&::before": { backgroundColor: radioButtonActiveColor }
+      }
+    },
+    [`${componentCls}-group-solid &-checked:not(${componentCls}-button-wrapper-disabled)`]: {
+      color: radioSolidCheckedColor,
+      background: radioCheckedColor,
+      borderColor: radioCheckedColor,
+      "&:hover": {
+        color: radioSolidCheckedColor,
+        background: radioButtonHoverColor,
+        borderColor: radioButtonHoverColor
+      },
+      "&:active": {
+        color: radioSolidCheckedColor,
+        background: radioButtonActiveColor,
+        borderColor: radioButtonActiveColor
+      }
+    },
+    "&-disabled": {
+      color: colorTextDisabled,
+      backgroundColor: colorBgContainerDisabled,
+      borderColor: colorBorder,
+      cursor: "not-allowed",
+      "&:first-child, &:hover": {
+        color: colorTextDisabled,
+        backgroundColor: colorBgContainerDisabled,
+        borderColor: colorBorder
+      }
+    },
+    [`&-disabled${componentCls}-button-wrapper-checked`]: {
+      color: radioDisabledButtonCheckedColor,
+      backgroundColor: radioDisabledButtonCheckedBg,
+      borderColor: colorBorder,
+      boxShadow: "none"
+    }
+  } };
+};
+var style_default$1 = genComponentStyleHook("Radio", (token) => {
+  const { padding, lineWidth, controlItemBgActiveDisabled, colorTextDisabled, colorBgContainer, fontSizeLG, controlOutline, colorPrimaryHover, colorPrimaryActive, colorText, colorPrimary, marginXS, controlOutlineWidth, colorTextLightSolid, wireframe } = token;
+  const radioFocusShadow = `0 0 0 ${controlOutlineWidth}px ${controlOutline}`;
+  const radioButtonFocusShadow = radioFocusShadow;
+  const radioSize = fontSizeLG;
+  const dotPadding = 4;
+  const radioDotDisabledSize = radioSize - 8;
+  const radioDotSize = wireframe ? radioDotDisabledSize : radioSize - (dotPadding + lineWidth) * 2;
+  const radioCheckedColor = colorPrimary;
+  const radioButtonColor = colorText;
+  const radioButtonHoverColor = colorPrimaryHover;
+  const radioButtonActiveColor = colorPrimaryActive;
+  const radioButtonPaddingHorizontal = padding - lineWidth;
+  const radioToken = merge(token, {
+    radioFocusShadow,
+    radioButtonFocusShadow,
+    radioSize,
+    radioDotSize,
+    radioDotDisabledSize,
+    radioCheckedColor,
+    radioDotDisabledColor: colorTextDisabled,
+    radioSolidCheckedColor: colorTextLightSolid,
+    radioButtonBg: colorBgContainer,
+    radioButtonCheckedBg: colorBgContainer,
+    radioButtonColor,
+    radioButtonHoverColor,
+    radioButtonActiveColor,
+    radioButtonPaddingHorizontal,
+    radioDisabledButtonCheckedBg: controlItemBgActiveDisabled,
+    radioDisabledButtonCheckedColor: colorTextDisabled,
+    radioWrapperMarginRight: marginXS
+  });
+  return [
+    getGroupRadioStyle(radioToken),
+    getRadioBasicStyle(radioToken),
+    getRadioButtonStyle(radioToken)
+  ];
+});
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+var radioProps = () => ({
+  prefixCls: String,
+  checked: booleanType(),
+  disabled: booleanType(),
+  isGroup: booleanType(),
+  value: PropTypes.any,
+  name: String,
+  id: String,
+  autofocus: booleanType(),
+  onChange: functionType(),
+  onFocus: functionType(),
+  onBlur: functionType(),
+  onClick: functionType(),
+  "onUpdate:checked": functionType(),
+  "onUpdate:value": functionType()
+});
+var Radio_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ARadio",
+  inheritAttrs: false,
+  props: radioProps(),
+  setup(props, _ref) {
+    let { emit, expose, slots, attrs } = _ref;
+    const formItemContext = useInjectFormItemContext();
+    const formItemInputContext = FormItemInputContext.useInject();
+    const radioOptionTypeContext = useInjectRadioOptionTypeContext();
+    const radioGroupContext = useInjectRadioGroupContext();
+    const disabledContext = useInjectDisabled();
+    const mergedDisabled = computed(() => {
+      var _a;
+      return (_a = disabled.value) !== null && _a !== void 0 ? _a : disabledContext.value;
+    });
+    const vcCheckbox = ref();
+    const { prefixCls: radioPrefixCls, direction, disabled } = useConfigInject_default("radio", props);
+    const prefixCls = computed(() => (radioGroupContext === null || radioGroupContext === void 0 ? void 0 : radioGroupContext.optionType.value) === "button" || radioOptionTypeContext === "button" ? `${radioPrefixCls.value}-button` : radioPrefixCls.value);
+    const contextDisabled = useInjectDisabled();
+    const [wrapSSR, hashId] = style_default$1(radioPrefixCls);
+    const focus = () => {
+      vcCheckbox.value.focus();
+    };
+    const blur = () => {
+      vcCheckbox.value.blur();
+    };
+    expose({
+      focus,
+      blur
+    });
+    const handleChange = (event) => {
+      const targetChecked = event.target.checked;
+      emit("update:checked", targetChecked);
+      emit("update:value", targetChecked);
+      emit("change", event);
+      formItemContext.onFieldChange();
+    };
+    const onChange = (e) => {
+      emit("change", e);
+      if (radioGroupContext && radioGroupContext.onChange) radioGroupContext.onChange(e);
+    };
+    return () => {
+      var _a;
+      const radioGroup = radioGroupContext;
+      const { prefixCls: customizePrefixCls, id = formItemContext.id.value } = props, restProps = __rest(props, ["prefixCls", "id"]);
+      const rProps = _extends(_extends({
+        prefixCls: prefixCls.value,
+        id
+      }, omit(restProps, ["onUpdate:checked", "onUpdate:value"])), { disabled: (_a = disabled.value) !== null && _a !== void 0 ? _a : contextDisabled.value });
+      if (radioGroup) {
+        rProps.name = radioGroup.name.value;
+        rProps.onChange = onChange;
+        rProps.checked = props.value === radioGroup.value.value;
+        rProps.disabled = mergedDisabled.value || radioGroup.disabled.value;
+      } else rProps.onChange = handleChange;
+      const wrapperClassString = classNames({
+        [`${prefixCls.value}-wrapper`]: true,
+        [`${prefixCls.value}-wrapper-checked`]: rProps.checked,
+        [`${prefixCls.value}-wrapper-disabled`]: rProps.disabled,
+        [`${prefixCls.value}-wrapper-rtl`]: direction.value === "rtl",
+        [`${prefixCls.value}-wrapper-in-form-item`]: formItemInputContext.isFormItemInput
+      }, attrs.class, hashId.value);
+      return wrapSSR(createVNode("label", _objectSpread2(_objectSpread2({}, attrs), {}, { "class": wrapperClassString }), [createVNode(Checkbox_default, _objectSpread2(_objectSpread2({}, rProps), {}, {
+        "type": "radio",
+        "ref": vcCheckbox
+      }), null), slots.default && createVNode("span", null, [slots.default()])]));
+    };
+  }
+});
+var radioGroupProps = () => ({
+  prefixCls: String,
+  value: PropTypes.any,
+  size: stringType(),
+  options: arrayType(),
+  disabled: booleanType(),
+  name: String,
+  buttonStyle: stringType("outline"),
+  id: String,
+  optionType: stringType("default"),
+  onChange: functionType(),
+  "onUpdate:value": functionType()
+});
+var Group_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ARadioGroup",
+  inheritAttrs: false,
+  props: radioGroupProps(),
+  setup(props, _ref) {
+    let { slots, emit, attrs } = _ref;
+    const formItemContext = useInjectFormItemContext();
+    const { prefixCls, direction, size } = useConfigInject_default("radio", props);
+    const [wrapSSR, hashId] = style_default$1(prefixCls);
+    const stateValue = ref(props.value);
+    const updatingValue = ref(false);
+    watch(() => props.value, (val) => {
+      stateValue.value = val;
+      updatingValue.value = false;
+    });
+    const onRadioChange = (ev) => {
+      const lastValue = stateValue.value;
+      const { value } = ev.target;
+      if (!("value" in props)) stateValue.value = value;
+      if (!updatingValue.value && value !== lastValue) {
+        updatingValue.value = true;
+        emit("update:value", value);
+        emit("change", ev);
+        formItemContext.onFieldChange();
+      }
+      nextTick(() => {
+        updatingValue.value = false;
+      });
+    };
+    useProvideRadioGroupContext({
+      onChange: onRadioChange,
+      value: stateValue,
+      disabled: computed(() => props.disabled),
+      name: computed(() => props.name),
+      optionType: computed(() => props.optionType)
+    });
+    return () => {
+      var _a;
+      const { options, buttonStyle, id = formItemContext.id.value } = props;
+      const groupPrefixCls = `${prefixCls.value}-group`;
+      const classString = classNames(groupPrefixCls, `${groupPrefixCls}-${buttonStyle}`, {
+        [`${groupPrefixCls}-${size.value}`]: size.value,
+        [`${groupPrefixCls}-rtl`]: direction.value === "rtl"
+      }, attrs.class, hashId.value);
+      let children = null;
+      if (options && options.length > 0) children = options.map((option) => {
+        if (typeof option === "string" || typeof option === "number") return createVNode(Radio_default, {
+          "key": option,
+          "prefixCls": prefixCls.value,
+          "disabled": props.disabled,
+          "value": option,
+          "checked": stateValue.value === option
+        }, { default: () => [option] });
+        const { value, disabled, label } = option;
+        return createVNode(Radio_default, {
+          "key": `radio-group-value-options-${value}`,
+          "prefixCls": prefixCls.value,
+          "disabled": disabled || props.disabled,
+          "value": value,
+          "checked": stateValue.value === value
+        }, { default: () => [label] });
+      });
+      else children = (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+      return wrapSSR(createVNode("div", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "class": classString,
+        "id": id
+      }), [children]));
+    };
+  }
+});
+var RadioButton_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ARadioButton",
+  inheritAttrs: false,
+  props: radioProps(),
+  setup(props, _ref) {
+    let { slots, attrs } = _ref;
+    const { prefixCls } = useConfigInject_default("radio", props);
+    useProvideRadioOptionTypeContext("button");
+    return () => {
+      var _a;
+      return createVNode(Radio_default, _objectSpread2(_objectSpread2(_objectSpread2({}, attrs), props), {}, { "prefixCls": prefixCls.value }), { default: () => [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)] });
+    };
+  }
+});
+Radio_default.Group = Group_default;
+Radio_default.Button = RadioButton_default;
+Radio_default.install = function(app) {
+  app.component(Radio_default.name, Radio_default);
+  app.component(Radio_default.Group.name, Radio_default.Group);
+  app.component(Radio_default.Button.name, Radio_default.Button);
+  return app;
+};
+var radio_default = Radio_default;
+var genTagStatusStyle = (token, status, cssVariableType) => {
+  const capitalizedCssVariableType = capitalize(cssVariableType);
+  return { [`${token.componentCls}-${status}`]: {
+    color: token[`color${cssVariableType}`],
+    background: token[`color${capitalizedCssVariableType}Bg`],
+    borderColor: token[`color${capitalizedCssVariableType}Border`],
+    [`&${token.componentCls}-borderless`]: { borderColor: "transparent" }
+  } };
+};
+var genPresetStyle = (token) => genPresetColor(token, (colorKey, _ref) => {
+  let { textColor, lightBorderColor, lightColor, darkColor } = _ref;
+  return { [`${token.componentCls}-${colorKey}`]: {
+    color: textColor,
+    background: lightColor,
+    borderColor: lightBorderColor,
+    "&-inverse": {
+      color: token.colorTextLightSolid,
+      background: darkColor,
+      borderColor: darkColor
+    },
+    [`&${token.componentCls}-borderless`]: { borderColor: "transparent" }
+  } };
+});
+var genBaseStyle = (token) => {
+  const { paddingXXS, lineWidth, tagPaddingHorizontal, componentCls } = token;
+  const paddingInline = tagPaddingHorizontal - lineWidth;
+  const iconMarginInline = paddingXXS - lineWidth;
+  return {
+    [componentCls]: _extends(_extends({}, resetComponent(token)), {
+      display: "inline-block",
+      height: "auto",
+      marginInlineEnd: token.marginXS,
+      paddingInline,
+      fontSize: token.tagFontSize,
+      lineHeight: `${token.tagLineHeight}px`,
+      whiteSpace: "nowrap",
+      background: token.tagDefaultBg,
+      border: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`,
+      borderRadius: token.borderRadiusSM,
+      opacity: 1,
+      transition: `all ${token.motionDurationMid}`,
+      textAlign: "start",
+      [`&${componentCls}-rtl`]: { direction: "rtl" },
+      "&, a, a:hover": { color: token.tagDefaultColor },
+      [`${componentCls}-close-icon`]: {
+        marginInlineStart: iconMarginInline,
+        color: token.colorTextDescription,
+        fontSize: token.tagIconSize,
+        cursor: "pointer",
+        transition: `all ${token.motionDurationMid}`,
+        "&:hover": { color: token.colorTextHeading }
+      },
+      [`&${componentCls}-has-color`]: {
+        borderColor: "transparent",
+        [`&, a, a:hover, ${token.iconCls}-close, ${token.iconCls}-close:hover`]: { color: token.colorTextLightSolid }
+      },
+      [`&-checkable`]: {
+        backgroundColor: "transparent",
+        borderColor: "transparent",
+        cursor: "pointer",
+        [`&:not(${componentCls}-checkable-checked):hover`]: {
+          color: token.colorPrimary,
+          backgroundColor: token.colorFillSecondary
+        },
+        "&:active, &-checked": { color: token.colorTextLightSolid },
+        "&-checked": {
+          backgroundColor: token.colorPrimary,
+          "&:hover": { backgroundColor: token.colorPrimaryHover }
+        },
+        "&:active": { backgroundColor: token.colorPrimaryActive }
+      },
+      [`&-hidden`]: { display: "none" },
+      [`> ${token.iconCls} + span, > span + ${token.iconCls}`]: { marginInlineStart: paddingInline }
+    }),
+    [`${componentCls}-borderless`]: {
+      borderColor: "transparent",
+      background: token.tagBorderlessBg
+    }
+  };
+};
+var style_default = genComponentStyleHook("Tag", (token) => {
+  const { fontSize, lineHeight, lineWidth, fontSizeIcon } = token;
+  const tagHeight = Math.round(fontSize * lineHeight);
+  const tagFontSize = token.fontSizeSM;
+  const tagLineHeight = tagHeight - lineWidth * 2;
+  const tagDefaultBg = token.colorFillAlter;
+  const tagDefaultColor = token.colorText;
+  const tagToken = merge(token, {
+    tagFontSize,
+    tagLineHeight,
+    tagDefaultBg,
+    tagDefaultColor,
+    tagIconSize: fontSizeIcon - 2 * lineWidth,
+    tagPaddingHorizontal: 8,
+    tagBorderlessBg: token.colorFillTertiary
+  });
+  return [
+    genBaseStyle(tagToken),
+    genPresetStyle(tagToken),
+    genTagStatusStyle(tagToken, "success", "Success"),
+    genTagStatusStyle(tagToken, "processing", "Info"),
+    genTagStatusStyle(tagToken, "error", "Error"),
+    genTagStatusStyle(tagToken, "warning", "Warning")
+  ];
+});
+var checkableTagProps = () => ({
+  prefixCls: String,
+  checked: {
+    type: Boolean,
+    default: void 0
+  },
+  onChange: { type: Function },
+  onClick: { type: Function },
+  "onUpdate:checked": Function
+});
+var CheckableTag = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ACheckableTag",
+  inheritAttrs: false,
+  props: checkableTagProps(),
+  setup(props, _ref) {
+    let { slots, emit, attrs } = _ref;
+    const { prefixCls } = useConfigInject_default("tag", props);
+    const [wrapSSR, hashId] = style_default(prefixCls);
+    const handleClick = (e) => {
+      const { checked } = props;
+      emit("update:checked", !checked);
+      emit("change", !checked);
+      emit("click", e);
+    };
+    const cls = computed(() => classNames(prefixCls.value, hashId.value, {
+      [`${prefixCls.value}-checkable`]: true,
+      [`${prefixCls.value}-checkable-checked`]: props.checked
+    }));
+    return () => {
+      var _a;
+      return wrapSSR(createVNode("span", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "class": [cls.value, attrs.class],
+        "onClick": handleClick
+      }), [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]));
+    };
+  }
+});
+var tagProps = () => ({
+  prefixCls: String,
+  color: { type: String },
+  closable: {
+    type: Boolean,
+    default: false
+  },
+  closeIcon: PropTypes.any,
+  /** @deprecated `visible` will be removed in next major version. */
+  visible: {
+    type: Boolean,
+    default: void 0
+  },
+  onClose: { type: Function },
+  onClick: eventType(),
+  "onUpdate:visible": Function,
+  icon: PropTypes.any,
+  bordered: {
+    type: Boolean,
+    default: true
+  }
+});
+var Tag = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ATag",
+  inheritAttrs: false,
+  props: tagProps(),
+  slots: Object,
+  setup(props, _ref) {
+    let { slots, emit, attrs } = _ref;
+    const { prefixCls, direction } = useConfigInject_default("tag", props);
+    const [wrapSSR, hashId] = style_default(prefixCls);
+    const visible = shallowRef(true);
+    watchEffect(() => {
+      if (props.visible !== void 0) visible.value = props.visible;
+    });
+    const handleCloseClick = (e) => {
+      e.stopPropagation();
+      emit("update:visible", false);
+      emit("close", e);
+      if (e.defaultPrevented) return;
+      if (props.visible === void 0) visible.value = false;
+    };
+    const isInternalColor = computed(() => isPresetColor(props.color) || isPresetStatusColor(props.color));
+    const tagClassName = computed(() => classNames(prefixCls.value, hashId.value, {
+      [`${prefixCls.value}-${props.color}`]: isInternalColor.value,
+      [`${prefixCls.value}-has-color`]: props.color && !isInternalColor.value,
+      [`${prefixCls.value}-hidden`]: !visible.value,
+      [`${prefixCls.value}-rtl`]: direction.value === "rtl",
+      [`${prefixCls.value}-borderless`]: !props.bordered
+    }));
+    const handleClick = (e) => {
+      emit("click", e);
+    };
+    return () => {
+      var _a, _b, _c;
+      const { icon = (_a = slots.icon) === null || _a === void 0 ? void 0 : _a.call(slots), color, closeIcon = (_b = slots.closeIcon) === null || _b === void 0 ? void 0 : _b.call(slots), closable = false } = props;
+      const renderCloseIcon = () => {
+        if (closable) return closeIcon ? createVNode("span", {
+          "class": `${prefixCls.value}-close-icon`,
+          "onClick": handleCloseClick
+        }, [closeIcon]) : createVNode(CloseOutlined, {
+          "class": `${prefixCls.value}-close-icon`,
+          "onClick": handleCloseClick
+        }, null);
+        return null;
+      };
+      const tagStyle = { backgroundColor: color && !isInternalColor.value ? color : void 0 };
+      const iconNode = icon || null;
+      const children = (_c = slots.default) === null || _c === void 0 ? void 0 : _c.call(slots);
+      const kids = iconNode ? createVNode(Fragment, null, [iconNode, createVNode("span", null, [children])]) : children;
+      const isNeedWave = props.onClick !== void 0;
+      const tagNode = createVNode("span", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "onClick": handleClick,
+        "class": [tagClassName.value, attrs.class],
+        "style": [tagStyle, attrs.style]
+      }), [kids, renderCloseIcon()]);
+      return wrapSSR(isNeedWave ? createVNode(wave_default, null, { default: () => [tagNode] }) : tagNode);
+    };
+  }
+});
+Tag.CheckableTag = CheckableTag;
+Tag.install = function(app) {
+  app.component(Tag.name, Tag);
+  app.component(CheckableTag.name, CheckableTag);
+  return app;
+};
+
+export { Checkbox_default as C, Group_default as G, RadioButton_default as R, Tag as T, debounce as d, radio_default as r, toNumber as t };
+//# sourceMappingURL=tag-CRW-anwy.mjs.map