@firerian/fireui 1.0.0

package/dist/fireui.es.mjs

@@ -0,0 +1,3867 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, normalizeStyle, unref, normalizeClass, renderSlot, createElementVNode, createBlock, resolveDynamicComponent, createCommentVNode, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly, onMounted, onUnmounted, Teleport, createVNode, Transition, withCtx, createTextVNode, toDisplayString, withKeys, reactive, provide, readonly, inject, withModifiers, Fragment, renderList, useSlots } from "vue";
+import { Info, XCircle, AlertTriangle, CheckCircle, X, Eye, EyeOff, ChevronUp, ChevronDown } from "lucide-vue-next";
+const _hoisted_1$5 = ["disabled", "type"];
+const _hoisted_2$4 = ["src", "alt"];
+const prefixCls = "f-button";
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "FButton",
+    inheritAttrs: false
+  },
+  __name: "button",
+  props: {
+    type: { default: "default" },
+    size: { default: "default" },
+    nativeType: { default: "button" },
+    disabled: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    circle: { type: Boolean, default: false },
+    block: { type: Boolean, default: false },
+    loadingIcon: { default: "" },
+    icon: { default: "" }
+  },
+  emits: ["click"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const buttonRef = ref();
+    const { type: type4, size, disabled, loading, circle, block, nativeType, loadingIcon, icon } = props;
+    const buttonClasses = computed(() => [
+      prefixCls,
+      `${prefixCls}--${type4}`,
+      `${prefixCls}--${size}`,
+      {
+        [`${prefixCls}--disabled`]: disabled,
+        [`${prefixCls}--loading`]: loading,
+        [`${prefixCls}--circle`]: circle,
+        [`${prefixCls}--block`]: block
+      }
+    ]);
+    const buttonStyles = computed(() => ({
+      "--f-button-primary-color": `var(--f-color-${type4})`,
+      "--f-button-primary-hover": `var(--f-color-${type4}-hover)`,
+      "--f-button-primary-active": `var(--f-color-${type4}-active)`
+    }));
+    const handleClick = (event) => {
+      if (disabled || loading) return;
+      emit("click", event);
+    };
+    __expose({
+      ref: buttonRef
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        ref_key: "buttonRef",
+        ref: buttonRef,
+        class: normalizeClass(buttonClasses.value),
+        disabled: unref(disabled) || unref(loading),
+        type: unref(nativeType),
+        style: normalizeStyle(buttonStyles.value),
+        onClick: handleClick
+      }, [
+        unref(loading) ? renderSlot(_ctx.$slots, "loading", { key: 0 }, () => [
+          createElementVNode("span", {
+            class: normalizeClass(`${prefixCls}-loading-icon`)
+          }, [
+            !unref(loadingIcon) ? (openBlock(), createElementBlock("svg", {
+              key: 0,
+              class: normalizeClass(`${prefixCls}-loading-svg`),
+              viewBox: "0 0 16 16",
+              width: "1em",
+              height: "1em"
+            }, [..._cache[0] || (_cache[0] = [
+              createElementVNode("circle", {
+                cx: "8",
+                cy: "8",
+                r: "7",
+                stroke: "currentColor",
+                "stroke-width": "2",
+                fill: "none",
+                "stroke-linecap": "round",
+                "stroke-dasharray": "44",
+                "stroke-dashoffset": "11"
+              }, null, -1)
+            ])], 2)) : (openBlock(), createElementBlock("img", {
+              key: 1,
+              src: unref(loadingIcon),
+              alt: unref(loadingIcon),
+              class: normalizeClass(`${prefixCls}-loading-img`)
+            }, null, 10, _hoisted_2$4))
+          ], 2)
+        ], true) : unref(icon) ? renderSlot(_ctx.$slots, "icon", { key: 1 }, () => [
+          createElementVNode("span", {
+            class: normalizeClass(`${prefixCls}-icon`)
+          }, [
+            (openBlock(), createBlock(resolveDynamicComponent(unref(icon))))
+          ], 2)
+        ], true) : createCommentVNode("", true),
+        createElementVNode("span", {
+          class: normalizeClass(`${prefixCls}-content`)
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 2)
+      ], 14, _hoisted_1$5);
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const FButton = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__scopeId", "data-v-69f05370"]]);
+function withInstall(component) {
+  const comp = component;
+  comp.install = (app) => {
+    app.component(comp.name || comp.__name, component);
+  };
+  return component;
+}
+function registerComponent(app, component) {
+  const comp = component;
+  app.component(comp.name || comp.__name, component);
+}
+function registerComponents(app, components2) {
+  components2.forEach((component) => {
+    registerComponent(app, component);
+  });
+}
+function useNamespace(block) {
+  const b = computed(() => `fire-${block}`);
+  const e = (element) => {
+    return element ? `${b.value}__${element}` : b.value;
+  };
+  const m = (modifier) => {
+    return modifier ? `${b.value}--${modifier}` : b.value;
+  };
+  const em = (element, modifier) => {
+    return `${e(element)}--${modifier}`;
+  };
+  return {
+    b: b.value,
+    e,
+    m,
+    em
+  };
+}
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "row",
+  props: {
+    gutter: { default: 0 },
+    justify: { default: "start" },
+    align: { default: "top" },
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("row");
+    const props = __props;
+    const rowStyle = computed(() => {
+      const style = {};
+      if (props.gutter) {
+        const [horizontal, vertical] = Array.isArray(props.gutter) ? props.gutter : [props.gutter, props.gutter];
+        style["--fire-row-gutter-horizontal"] = `${horizontal}px`;
+        style["--fire-row-gutter-vertical"] = `${vertical}px`;
+      }
+      return style;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          {
+            [unref(ns).m(`justify-${__props.justify}`)]: __props.justify,
+            [unref(ns).m(`align-${__props.align}`)]: __props.align
+          }
+        ]),
+        style: normalizeStyle(rowStyle.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const Row = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__scopeId", "data-v-62576f0f"]]);
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "col",
+  props: {
+    span: { default: 24 },
+    offset: { default: 0 },
+    xs: {},
+    sm: {},
+    md: {},
+    lg: {},
+    xl: {},
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("col");
+    const props = __props;
+    const responsiveClasses = computed(() => {
+      const classes = [];
+      const breakpoints = ["xs", "sm", "md", "lg", "xl"];
+      breakpoints.forEach((breakpoint) => {
+        const value = props[breakpoint];
+        if (value) {
+          if (typeof value === "number") {
+            classes.push(ns.m(`${breakpoint}-span-${value}`));
+          } else {
+            if (value.span) {
+              classes.push(ns.m(`${breakpoint}-span-${value.span}`));
+            }
+            if (value.offset) {
+              classes.push(ns.m(`${breakpoint}-offset-${value.offset}`));
+            }
+          }
+        }
+      });
+      return classes;
+    });
+    const colStyle = computed(() => {
+      return {
+        padding: `calc(var(--fire-row-gutter-vertical, 0) * 0.5) calc(var(--fire-row-gutter-horizontal, 0) * 0.5)`
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          {
+            [unref(ns).m(`span-${__props.span}`)]: __props.span,
+            [unref(ns).m(`offset-${__props.offset}`)]: __props.offset
+          },
+          ...responsiveClasses.value
+        ]),
+        style: normalizeStyle(colStyle.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const Col = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__scopeId", "data-v-84066fd0"]]);
+const FireRow = withInstall(Row);
+const FireCol = withInstall(Col);
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  __name: "container",
+  props: {
+    direction: { default: "horizontal" },
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("container");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          unref(ns).m(`direction-${__props.direction}`)
+        ])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+const Container = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-6db987fb"]]);
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __name: "header",
+  props: {
+    height: { default: 64 },
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("header");
+    const props = __props;
+    const headerStyle = computed(() => {
+      const style = {};
+      if (props.height) {
+        style.height = typeof props.height === "number" ? `${props.height}px` : props.height;
+      }
+      return style;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("header", {
+        class: normalizeClass(unref(ns).b),
+        style: normalizeStyle(headerStyle.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const Header = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-aab8d9a5"]]);
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "aside",
+  props: {
+    width: { default: 240 },
+    collapsed: { type: Boolean, default: false },
+    class: {},
+    style: {}
+  },
+  emits: ["update:collapsed"],
+  setup(__props) {
+    const ns = useNamespace("aside");
+    const props = __props;
+    const asideStyle = computed(() => {
+      const style = {};
+      if (props.width) {
+        style.width = typeof props.width === "number" ? `${props.width}px` : props.width;
+      }
+      return style;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("aside", {
+        class: normalizeClass([
+          unref(ns).b,
+          {
+            [unref(ns).m("collapsed")]: __props.collapsed
+          }
+        ]),
+        style: normalizeStyle(asideStyle.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const Aside = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__scopeId", "data-v-ab32fa1d"]]);
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "main",
+  props: {
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("main");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("main", {
+        class: normalizeClass(unref(ns).b)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+const Main = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__scopeId", "data-v-13e2ee00"]]);
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "footer",
+  props: {
+    height: { default: 64 },
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const ns = useNamespace("footer");
+    const props = __props;
+    const footerStyle = computed(() => {
+      const style = {};
+      if (props.height) {
+        style.height = typeof props.height === "number" ? `${props.height}px` : props.height;
+      }
+      return style;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("footer", {
+        class: normalizeClass(unref(ns).b),
+        style: normalizeStyle(footerStyle.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const Footer = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-fe55d656"]]);
+const FireContainer = withInstall(Container);
+const FireHeader = withInstall(Header);
+const FireAside = withInstall(Aside);
+const FireMain = withInstall(Main);
+const FireFooter = withInstall(Footer);
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+const oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+const yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+  return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+const lrPlacement = ["left", "right"];
+const rlPlacement = ["right", "left"];
+const tbPlacement = ["top", "bottom"];
+const btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case "end":
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+const computePosition$1 = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    var _platform$detectOverf;
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: {
+        ...platform2,
+        detectOverflow: (_platform$detectOverf = platform2.detectOverflow) != null ? _platform$detectOverf : detectOverflow
+      },
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
+    }
+  }
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+const flip$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
+          if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
+          // overflows the main axis.
+          overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+            return {
+              data: {
+                index: nextIndex,
+                overflows: overflowsData
+              },
+              reset: {
+                placement: nextPlacement
+              }
+            };
+          }
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
+                }
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+const originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = originSides.has(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+const offset$1 = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+};
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+const invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+}
+const tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function isTableElement(element) {
+  return tableElements.has(getNodeName(element));
+}
+const topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+  return topLayerSelectors.some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch (_e) {
+      return false;
+    }
+  });
+}
+const transformProperties = ["transform", "translate", "scale", "rotate", "perspective"];
+const willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"];
+const containValues = ["paint", "layout", "strict", "content"];
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+const lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function isLastTraversableNode(node) {
+  return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+function getCssDimensions(element) {
+  const css = getComputedStyle$1(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement$1(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+  const domElement = unwrapElement$1(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement$1(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle$1(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed";
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle$1(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+const SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  const windowScrollbarX = getWindowScrollBarX(html);
+  if (windowScrollbarX <= 0) {
+    const doc = html.ownerDocument;
+    const body = doc.body;
+    const bodyStyles = getComputedStyle(body);
+    const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
+      width -= clippingStableScrollbarWidth;
+    }
+  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
+    width += windowScrollbarX;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+const absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === "viewport") {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle$1(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      result = result.filter((ancestor) => ancestor !== currentNode);
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  function setLeftRTLScrollbarOffset() {
+    offsets.x = getWindowScrollBarX(documentElement);
+  }
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      setLeftRTLScrollbarOffset();
+    }
+  }
+  if (isFixed && !isOffsetParentAnElement && documentElement) {
+    setLeftRTLScrollbarOffset();
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+const getElementRects = async function(data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+function isRTL(element) {
+  return getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        refresh();
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (_e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement$1(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+const offset = offset$1;
+const flip = flip$1;
+const computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+function isComponentPublicInstance(target) {
+  return target != null && typeof target === "object" && "$el" in target;
+}
+function unwrapElement(target) {
+  if (isComponentPublicInstance(target)) {
+    const element = target.$el;
+    return isNode(element) && getNodeName(element) === "#comment" ? null : element;
+  }
+  return target;
+}
+function toValue(source) {
+  return typeof source === "function" ? source() : unref(source);
+}
+function getDPR(element) {
+  if (typeof window === "undefined") {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+function useFloating(reference, floating, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const whileElementsMountedOption = options.whileElementsMounted;
+  const openOption = computed(() => {
+    var _toValue;
+    return (_toValue = toValue(options.open)) != null ? _toValue : true;
+  });
+  const middlewareOption = computed(() => toValue(options.middleware));
+  const placementOption = computed(() => {
+    var _toValue2;
+    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : "bottom";
+  });
+  const strategyOption = computed(() => {
+    var _toValue3;
+    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : "absolute";
+  });
+  const transformOption = computed(() => {
+    var _toValue4;
+    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+  });
+  const referenceElement = computed(() => unwrapElement(reference.value));
+  const floatingElement = computed(() => unwrapElement(floating.value));
+  const x = ref(0);
+  const y = ref(0);
+  const strategy = ref(strategyOption.value);
+  const placement = ref(placementOption.value);
+  const middlewareData = shallowRef({});
+  const isPositioned = ref(false);
+  const floatingStyles = computed(() => {
+    const initialStyles = {
+      position: strategy.value,
+      left: "0",
+      top: "0"
+    };
+    if (!floatingElement.value) {
+      return initialStyles;
+    }
+    const xVal = roundByDPR(floatingElement.value, x.value);
+    const yVal = roundByDPR(floatingElement.value, y.value);
+    if (transformOption.value) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + xVal + "px, " + yVal + "px)",
+        ...getDPR(floatingElement.value) >= 1.5 && {
+          willChange: "transform"
+        }
+      };
+    }
+    return {
+      position: strategy.value,
+      left: xVal + "px",
+      top: yVal + "px"
+    };
+  });
+  let whileElementsMountedCleanup;
+  function update() {
+    if (referenceElement.value == null || floatingElement.value == null) {
+      return;
+    }
+    const open = openOption.value;
+    computePosition(referenceElement.value, floatingElement.value, {
+      middleware: middlewareOption.value,
+      placement: placementOption.value,
+      strategy: strategyOption.value
+    }).then((position) => {
+      x.value = position.x;
+      y.value = position.y;
+      strategy.value = position.strategy;
+      placement.value = position.placement;
+      middlewareData.value = position.middlewareData;
+      isPositioned.value = open !== false;
+    });
+  }
+  function cleanup() {
+    if (typeof whileElementsMountedCleanup === "function") {
+      whileElementsMountedCleanup();
+      whileElementsMountedCleanup = void 0;
+    }
+  }
+  function attach() {
+    cleanup();
+    if (whileElementsMountedOption === void 0) {
+      update();
+      return;
+    }
+    if (referenceElement.value != null && floatingElement.value != null) {
+      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+      return;
+    }
+  }
+  function reset() {
+    if (!openOption.value) {
+      isPositioned.value = false;
+    }
+  }
+  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
+    flush: "sync"
+  });
+  watch([referenceElement, floatingElement], attach, {
+    flush: "sync"
+  });
+  watch(openOption, reset, {
+    flush: "sync"
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  return {
+    x: shallowReadonly(x),
+    y: shallowReadonly(y),
+    strategy: shallowReadonly(strategy),
+    placement: shallowReadonly(placement),
+    middlewareData: shallowReadonly(middlewareData),
+    isPositioned: shallowReadonly(isPositioned),
+    floatingStyles,
+    update
+  };
+}
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "tooltip",
+  props: {
+    content: { default: "" },
+    placement: { default: "top" },
+    trigger: { default: "hover" },
+    disabled: { type: Boolean, default: false },
+    visible: { type: Boolean, default: false },
+    offset: { default: 8 }
+  },
+  emits: ["update:visible", "show", "hide"],
+  setup(__props, { emit: __emit }) {
+    const ns = useNamespace("tooltip");
+    const props = __props;
+    const emit = __emit;
+    const reference = ref(null);
+    const floating = ref(null);
+    const isVisible = ref(props.visible);
+    const tooltipId = `fire-tooltip-${Math.random().toString(36).substr(2, 9)}`;
+    const position = ref(props.placement);
+    const { x, y, strategy } = useFloating(
+      reference,
+      floating,
+      {
+        placement: props.placement,
+        middleware: [
+          offset(props.offset),
+          flip()
+        ],
+        whileElementsMounted: autoUpdate
+      }
+    );
+    const floatingStyles = computed(() => ({
+      position: strategy.value,
+      left: `${x.value ?? 0}px`,
+      top: `${y.value ?? 0}px`
+    }));
+    const show = () => {
+      if (props.disabled) return;
+      isVisible.value = true;
+      emit("update:visible", true);
+      emit("show");
+    };
+    const hide = () => {
+      isVisible.value = false;
+      emit("update:visible", false);
+      emit("hide");
+    };
+    const handleMouseEnter = () => {
+      if (props.trigger === "hover") {
+        show();
+      }
+    };
+    const handleMouseLeave = () => {
+      if (props.trigger === "hover") {
+        hide();
+      }
+    };
+    const handleFocus = () => {
+      if (props.trigger === "focus") {
+        show();
+      }
+    };
+    const handleBlur = () => {
+      if (props.trigger === "focus") {
+        hide();
+      }
+    };
+    const handleClickOutside = (event) => {
+      if (reference.value && !reference.value.contains(event.target) && floating.value && !floating.value.contains(event.target)) {
+        hide();
+      }
+    };
+    onMounted(() => {
+      if (props.trigger === "click") {
+        document.addEventListener("click", handleClickOutside);
+      }
+    });
+    onUnmounted(() => {
+      if (props.trigger === "click") {
+        document.removeEventListener("click", handleClickOutside);
+      }
+    });
+    watch(() => props.visible, (val) => {
+      isVisible.value = val;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "reference",
+        ref: reference,
+        class: normalizeClass(unref(ns).b),
+        onMouseenter: handleMouseEnter,
+        onMouseleave: handleMouseLeave,
+        onFocus: handleFocus,
+        onBlur: handleBlur
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        (openBlock(), createBlock(Teleport, { to: "body" }, [
+          createVNode(Transition, { name: "fire-tooltip" }, {
+            default: withCtx(() => [
+              isVisible.value ? (openBlock(), createElementBlock("div", {
+                key: 0,
+                ref_key: "floating",
+                ref: floating,
+                class: normalizeClass([
+                  unref(ns).e("content"),
+                  unref(ns).m(position.value)
+                ]),
+                style: normalizeStyle(floatingStyles.value),
+                id: tooltipId,
+                role: "tooltip"
+              }, [
+                createElementVNode("div", {
+                  class: normalizeClass(unref(ns).e("arrow"))
+                }, null, 2),
+                createElementVNode("div", {
+                  class: normalizeClass(unref(ns).e("inner"))
+                }, [
+                  renderSlot(_ctx.$slots, "content", {}, () => [
+                    createTextVNode(toDisplayString(__props.content), 1)
+                  ], true)
+                ], 2)
+              ], 6)) : createCommentVNode("", true)
+            ]),
+            _: 3
+          })
+        ]))
+      ], 34);
+    };
+  }
+});
+const Tooltip = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-2e386c10"]]);
+const FireTooltip = withInstall(Tooltip);
+const _hoisted_1$4 = { class: "fire-tips-icon" };
+const _hoisted_2$3 = { class: "fire-tips-content" };
+const _hoisted_3$3 = {
+  key: 0,
+  class: "fire-tips-title"
+};
+const _hoisted_4$2 = {
+  key: 1,
+  class: "fire-tips-description"
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "tips",
+  props: {
+    type: { default: "info" },
+    closable: { type: Boolean, default: false },
+    icon: { default: void 0 },
+    title: { default: "" },
+    description: { default: "" },
+    class: {},
+    style: {}
+  },
+  emits: ["close"],
+  setup(__props, { emit: __emit }) {
+    const ns = useNamespace("tips");
+    const props = __props;
+    const emit = __emit;
+    const iconComponent = computed(() => {
+      switch (props.type) {
+        case "success":
+          return CheckCircle;
+        case "warning":
+          return AlertTriangle;
+        case "error":
+          return XCircle;
+        default:
+          return Info;
+      }
+    });
+    const handleClose = () => {
+      emit("close");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          unref(ns).m(__props.type),
+          {
+            [unref(ns).m("closable")]: __props.closable
+          }
+        ])
+      }, [
+        createElementVNode("div", _hoisted_1$4, [
+          renderSlot(_ctx.$slots, "icon", {}, () => [
+            !__props.icon ? (openBlock(), createBlock(resolveDynamicComponent(iconComponent.value), { key: 0 })) : (openBlock(), createBlock(resolveDynamicComponent(__props.icon), { key: 1 }))
+          ], true)
+        ]),
+        createElementVNode("div", _hoisted_2$3, [
+          __props.title || _ctx.$slots.title ? (openBlock(), createElementBlock("div", _hoisted_3$3, [
+            renderSlot(_ctx.$slots, "title", {}, () => [
+              createTextVNode(toDisplayString(__props.title), 1)
+            ], true)
+          ])) : createCommentVNode("", true),
+          __props.description || _ctx.$slots.description ? (openBlock(), createElementBlock("div", _hoisted_4$2, [
+            renderSlot(_ctx.$slots, "description", {}, () => [
+              createTextVNode(toDisplayString(__props.description), 1)
+            ], true)
+          ])) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        __props.closable ? (openBlock(), createElementBlock("button", {
+          key: 0,
+          class: "fire-tips-close",
+          onClick: handleClose,
+          "aria-label": "Close"
+        }, [
+          createVNode(unref(X), { size: 16 })
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const Tips = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-7c18dbd2"]]);
+const FireTips = withInstall(Tips);
+const _hoisted_1$3 = {
+  key: 0,
+  class: "fire-input__prefix"
+};
+const _hoisted_2$2 = ["type", "value", "placeholder", "disabled", "readonly", "maxlength", "minlength"];
+const _hoisted_3$2 = {
+  key: 1,
+  class: "fire-input__suffix"
+};
+const _hoisted_4$1 = {
+  key: 0,
+  class: "fire-input__word-limit"
+};
+const _hoisted_5$1 = {
+  key: 1,
+  class: "fire-input__password-toggle"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "input",
+  props: {
+    type: { default: "text" },
+    modelValue: { default: "" },
+    placeholder: { default: "" },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    password: { type: Boolean, default: false },
+    maxlength: { default: void 0 },
+    minlength: { default: void 0 },
+    showWordLimit: { type: Boolean, default: false },
+    size: { default: "medium" },
+    prefixIcon: { default: void 0 },
+    suffixIcon: { default: void 0 },
+    class: {},
+    style: {}
+  },
+  emits: ["update:modelValue", "input", "focus", "blur", "enter", "clear"],
+  setup(__props, { emit: __emit }) {
+    const ns = useNamespace("input");
+    const emit = __emit;
+    const inputRef = ref();
+    const showPassword = ref(false);
+    const handleInput = (event) => {
+      const target = event.target;
+      const value = target.value;
+      emit("update:modelValue", value);
+      emit("input", value);
+    };
+    const handleFocus = (event) => {
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      emit("blur", event);
+    };
+    const handleEnter = (event) => {
+      emit("enter", event);
+    };
+    const togglePassword = () => {
+      showPassword.value = !showPassword.value;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          unref(ns).m(__props.size),
+          {
+            [unref(ns).m("disabled")]: __props.disabled,
+            [unref(ns).m("prefix")]: _ctx.$slots.prefix || __props.prefixIcon,
+            [unref(ns).m("suffix")]: _ctx.$slots.suffix || __props.suffixIcon || __props.showWordLimit
+          }
+        ])
+      }, [
+        _ctx.$slots.prefix || __props.prefixIcon ? (openBlock(), createElementBlock("div", _hoisted_1$3, [
+          renderSlot(_ctx.$slots, "prefix", {}, () => [
+            __props.prefixIcon ? (openBlock(), createBlock(resolveDynamicComponent(__props.prefixIcon), { key: 0 })) : createCommentVNode("", true)
+          ], true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("input", {
+          ref_key: "inputRef",
+          ref: inputRef,
+          type: __props.password ? showPassword.value ? "text" : "password" : __props.type,
+          value: __props.modelValue,
+          placeholder: __props.placeholder,
+          disabled: __props.disabled,
+          readonly: __props.readonly,
+          maxlength: __props.maxlength,
+          minlength: __props.minlength,
+          onInput: handleInput,
+          onFocus: handleFocus,
+          onBlur: handleBlur,
+          onKeydown: withKeys(handleEnter, ["enter"]),
+          class: "fire-input__inner"
+        }, null, 40, _hoisted_2$2),
+        _ctx.$slots.suffix || __props.suffixIcon || __props.showWordLimit || __props.password && !__props.disabled ? (openBlock(), createElementBlock("div", _hoisted_3$2, [
+          __props.showWordLimit ? (openBlock(), createElementBlock("span", _hoisted_4$1, toDisplayString((__props.modelValue || "").toString().length) + "/" + toDisplayString(__props.maxlength), 1)) : createCommentVNode("", true),
+          __props.password && !__props.disabled ? (openBlock(), createElementBlock("div", _hoisted_5$1, [
+            createElementVNode("button", {
+              type: "button",
+              onClick: togglePassword,
+              class: "fire-input__password-icon",
+              "aria-label": "Toggle password visibility"
+            }, [
+              !showPassword.value ? (openBlock(), createBlock(unref(Eye), {
+                key: 0,
+                size: 16
+              })) : (openBlock(), createBlock(unref(EyeOff), {
+                key: 1,
+                size: 16
+              }))
+            ])
+          ])) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "suffix", {}, () => [
+            __props.suffixIcon ? (openBlock(), createBlock(resolveDynamicComponent(__props.suffixIcon), { key: 0 })) : createCommentVNode("", true)
+          ], true)
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const Input = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-01eb6da8"]]);
+const FireInput = withInstall(Input);
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+var formatRegExp = /%[sdj%]/g;
+var warning = function warning2() {
+};
+if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof window !== "undefined" && typeof document !== "undefined") {
+  warning = function warning3(type4, errors) {
+    if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
+      if (errors.every(function(e) {
+        return typeof e === "string";
+      })) {
+        console.warn(type4, errors);
+      }
+    }
+  };
+}
+function convertFieldsError(errors) {
+  if (!errors || !errors.length) return null;
+  var fields = {};
+  errors.forEach(function(error) {
+    var field = error.field;
+    fields[field] = fields[field] || [];
+    fields[field].push(error);
+  });
+  return fields;
+}
+function format(template) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  var i = 0;
+  var len = args.length;
+  if (typeof template === "function") {
+    return template.apply(null, args);
+  }
+  if (typeof template === "string") {
+    var str = template.replace(formatRegExp, function(x) {
+      if (x === "%%") {
+        return "%";
+      }
+      if (i >= len) {
+        return x;
+      }
+      switch (x) {
+        case "%s":
+          return String(args[i++]);
+        case "%d":
+          return Number(args[i++]);
+        case "%j":
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (_) {
+            return "[Circular]";
+          }
+          break;
+        default:
+          return x;
+      }
+    });
+    return str;
+  }
+  return template;
+}
+function isNativeStringType(type4) {
+  return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
+}
+function isEmptyValue(value, type4) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (type4 === "array" && Array.isArray(value) && !value.length) {
+    return true;
+  }
+  if (isNativeStringType(type4) && typeof value === "string" && !value) {
+    return true;
+  }
+  return false;
+}
+function asyncParallelArray(arr, func, callback) {
+  var results = [];
+  var total = 0;
+  var arrLength = arr.length;
+  function count(errors) {
+    results.push.apply(results, errors || []);
+    total++;
+    if (total === arrLength) {
+      callback(results);
+    }
+  }
+  arr.forEach(function(a) {
+    func(a, count);
+  });
+}
+function asyncSerialArray(arr, func, callback) {
+  var index2 = 0;
+  var arrLength = arr.length;
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+    var original = index2;
+    index2 = index2 + 1;
+    if (original < arrLength) {
+      func(arr[original], next);
+    } else {
+      callback([]);
+    }
+  }
+  next([]);
+}
+function flattenObjArr(objArr) {
+  var ret = [];
+  Object.keys(objArr).forEach(function(k) {
+    ret.push.apply(ret, objArr[k] || []);
+  });
+  return ret;
+}
+var AsyncValidationError = /* @__PURE__ */ (function(_Error) {
+  _inheritsLoose(AsyncValidationError2, _Error);
+  function AsyncValidationError2(errors, fields) {
+    var _this;
+    _this = _Error.call(this, "Async Validation Error") || this;
+    _this.errors = errors;
+    _this.fields = fields;
+    return _this;
+  }
+  return AsyncValidationError2;
+})(/* @__PURE__ */ _wrapNativeSuper(Error));
+function asyncMap(objArr, option, func, callback, source) {
+  if (option.first) {
+    var _pending = new Promise(function(resolve, reject) {
+      var next = function next2(errors) {
+        callback(errors);
+        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
+      };
+      var flattenArr = flattenObjArr(objArr);
+      asyncSerialArray(flattenArr, func, next);
+    });
+    _pending["catch"](function(e) {
+      return e;
+    });
+    return _pending;
+  }
+  var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
+  var objArrKeys = Object.keys(objArr);
+  var objArrLength = objArrKeys.length;
+  var total = 0;
+  var results = [];
+  var pending = new Promise(function(resolve, reject) {
+    var next = function next2(errors) {
+      results.push.apply(results, errors);
+      total++;
+      if (total === objArrLength) {
+        callback(results);
+        return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
+      }
+    };
+    if (!objArrKeys.length) {
+      callback(results);
+      resolve(source);
+    }
+    objArrKeys.forEach(function(key) {
+      var arr = objArr[key];
+      if (firstFields.indexOf(key) !== -1) {
+        asyncSerialArray(arr, func, next);
+      } else {
+        asyncParallelArray(arr, func, next);
+      }
+    });
+  });
+  pending["catch"](function(e) {
+    return e;
+  });
+  return pending;
+}
+function isErrorObj(obj) {
+  return !!(obj && obj.message !== void 0);
+}
+function getValue(value, path) {
+  var v = value;
+  for (var i = 0; i < path.length; i++) {
+    if (v == void 0) {
+      return v;
+    }
+    v = v[path[i]];
+  }
+  return v;
+}
+function complementError(rule, source) {
+  return function(oe) {
+    var fieldValue;
+    if (rule.fullFields) {
+      fieldValue = getValue(source, rule.fullFields);
+    } else {
+      fieldValue = source[oe.field || rule.fullField];
+    }
+    if (isErrorObj(oe)) {
+      oe.field = oe.field || rule.fullField;
+      oe.fieldValue = fieldValue;
+      return oe;
+    }
+    return {
+      message: typeof oe === "function" ? oe() : oe,
+      fieldValue,
+      field: oe.field || rule.fullField
+    };
+  };
+}
+function deepMerge(target, source) {
+  if (source) {
+    for (var s in source) {
+      if (source.hasOwnProperty(s)) {
+        var value = source[s];
+        if (typeof value === "object" && typeof target[s] === "object") {
+          target[s] = _extends({}, target[s], value);
+        } else {
+          target[s] = value;
+        }
+      }
+    }
+  }
+  return target;
+}
+var required$1 = function required(rule, value, source, errors, options, type4) {
+  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
+    errors.push(format(options.messages.required, rule.fullField));
+  }
+};
+var whitespace = function whitespace2(rule, value, source, errors, options) {
+  if (/^\s+$/.test(value) || value === "") {
+    errors.push(format(options.messages.whitespace, rule.fullField));
+  }
+};
+var urlReg;
+var getUrlRegex = (function() {
+  if (urlReg) {
+    return urlReg;
+  }
+  var word = "[a-fA-F\\d:]";
+  var b = function b2(options) {
+    return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : "";
+  };
+  var v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+  var v6seg = "[a-fA-F\\d]{1,4}";
+  var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
+  var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
+  var v4exact = new RegExp("^" + v4 + "$");
+  var v6exact = new RegExp("^" + v6 + "$");
+  var ip = function ip2(options) {
+    return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", "g");
+  };
+  ip.v4 = function(options) {
+    return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), "g");
+  };
+  ip.v6 = function(options) {
+    return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), "g");
+  };
+  var protocol = "(?:(?:[a-z]+:)?//)";
+  var auth = "(?:\\S+(?::\\S*)?@)?";
+  var ipv4 = ip.v4().source;
+  var ipv6 = ip.v6().source;
+  var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
+  var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
+  var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
+  var port = "(?::\\d{2,5})?";
+  var path = '(?:[/?#][^\\s"]*)?';
+  var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
+  urlReg = new RegExp("(?:^" + regex + "$)", "i");
+  return urlReg;
+});
+var pattern$2 = {
+  // http://emailregex.com/
+  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
+  // url: new RegExp(
+  //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
+  //   'i',
+  // ),
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
+};
+var types = {
+  integer: function integer(value) {
+    return types.number(value) && parseInt(value, 10) === value;
+  },
+  "float": function float(value) {
+    return types.number(value) && !types.integer(value);
+  },
+  array: function array(value) {
+    return Array.isArray(value);
+  },
+  regexp: function regexp(value) {
+    if (value instanceof RegExp) {
+      return true;
+    }
+    try {
+      return !!new RegExp(value);
+    } catch (e) {
+      return false;
+    }
+  },
+  date: function date(value) {
+    return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
+  },
+  number: function number(value) {
+    if (isNaN(value)) {
+      return false;
+    }
+    return typeof value === "number";
+  },
+  object: function object(value) {
+    return typeof value === "object" && !types.array(value);
+  },
+  method: function method(value) {
+    return typeof value === "function";
+  },
+  email: function email(value) {
+    return typeof value === "string" && value.length <= 320 && !!value.match(pattern$2.email);
+  },
+  url: function url(value) {
+    return typeof value === "string" && value.length <= 2048 && !!value.match(getUrlRegex());
+  },
+  hex: function hex(value) {
+    return typeof value === "string" && !!value.match(pattern$2.hex);
+  }
+};
+var type$1 = function type(rule, value, source, errors, options) {
+  if (rule.required && value === void 0) {
+    required$1(rule, value, source, errors, options);
+    return;
+  }
+  var custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
+  var ruleType = rule.type;
+  if (custom.indexOf(ruleType) > -1) {
+    if (!types[ruleType](value)) {
+      errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+    }
+  } else if (ruleType && typeof value !== rule.type) {
+    errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+  }
+};
+var range = function range2(rule, value, source, errors, options) {
+  var len = typeof rule.len === "number";
+  var min2 = typeof rule.min === "number";
+  var max2 = typeof rule.max === "number";
+  var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  var val = value;
+  var key = null;
+  var num = typeof value === "number";
+  var str = typeof value === "string";
+  var arr = Array.isArray(value);
+  if (num) {
+    key = "number";
+  } else if (str) {
+    key = "string";
+  } else if (arr) {
+    key = "array";
+  }
+  if (!key) {
+    return false;
+  }
+  if (arr) {
+    val = value.length;
+  }
+  if (str) {
+    val = value.replace(spRegexp, "_").length;
+  }
+  if (len) {
+    if (val !== rule.len) {
+      errors.push(format(options.messages[key].len, rule.fullField, rule.len));
+    }
+  } else if (min2 && !max2 && val < rule.min) {
+    errors.push(format(options.messages[key].min, rule.fullField, rule.min));
+  } else if (max2 && !min2 && val > rule.max) {
+    errors.push(format(options.messages[key].max, rule.fullField, rule.max));
+  } else if (min2 && max2 && (val < rule.min || val > rule.max)) {
+    errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
+  }
+};
+var ENUM$1 = "enum";
+var enumerable$1 = function enumerable(rule, value, source, errors, options) {
+  rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
+  if (rule[ENUM$1].indexOf(value) === -1) {
+    errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
+  }
+};
+var pattern$1 = function pattern(rule, value, source, errors, options) {
+  if (rule.pattern) {
+    if (rule.pattern instanceof RegExp) {
+      rule.pattern.lastIndex = 0;
+      if (!rule.pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    } else if (typeof rule.pattern === "string") {
+      var _pattern = new RegExp(rule.pattern);
+      if (!_pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    }
+  }
+};
+var rules = {
+  required: required$1,
+  whitespace,
+  type: type$1,
+  range,
+  "enum": enumerable$1,
+  pattern: pattern$1
+};
+var string = function string2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "string") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, "string");
+    if (!isEmptyValue(value, "string")) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+      rules.pattern(rule, value, source, errors, options);
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var method2 = function method3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var number2 = function number3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (value === "") {
+      value = void 0;
+    }
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _boolean = function _boolean2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var regexp2 = function regexp3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var integer2 = function integer3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var floatFn = function floatFn2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var array2 = function array3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((value === void 0 || value === null) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, "array");
+    if (value !== void 0 && value !== null) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var object2 = function object3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var ENUM = "enum";
+var enumerable2 = function enumerable3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules[ENUM](rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var pattern2 = function pattern3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "string") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, "string")) {
+      rules.pattern(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var date2 = function date3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "date") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, "date")) {
+      var dateObject;
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+      rules.type(rule, dateObject, source, errors, options);
+      if (dateObject) {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var required2 = function required3(rule, value, callback, source, options) {
+  var errors = [];
+  var type4 = Array.isArray(value) ? "array" : typeof value;
+  rules.required(rule, value, source, errors, options, type4);
+  callback(errors);
+};
+var type2 = function type3(rule, value, callback, source, options) {
+  var ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, ruleType);
+    if (!isEmptyValue(value, ruleType)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var any = function any2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+  }
+  callback(errors);
+};
+var validators = {
+  string,
+  method: method2,
+  number: number2,
+  "boolean": _boolean,
+  regexp: regexp2,
+  integer: integer2,
+  "float": floatFn,
+  array: array2,
+  object: object2,
+  "enum": enumerable2,
+  pattern: pattern2,
+  date: date2,
+  url: type2,
+  hex: type2,
+  email: type2,
+  required: required2,
+  any
+};
+function newMessages() {
+  return {
+    "default": "Validation error on field %s",
+    required: "%s is required",
+    "enum": "%s must be one of %s",
+    whitespace: "%s cannot be empty",
+    date: {
+      format: "%s date %s is invalid for format %s",
+      parse: "%s date could not be parsed, %s is invalid ",
+      invalid: "%s date %s is invalid"
+    },
+    types: {
+      string: "%s is not a %s",
+      method: "%s is not a %s (function)",
+      array: "%s is not an %s",
+      object: "%s is not an %s",
+      number: "%s is not a %s",
+      date: "%s is not a %s",
+      "boolean": "%s is not a %s",
+      integer: "%s is not an %s",
+      "float": "%s is not a %s",
+      regexp: "%s is not a valid %s",
+      email: "%s is not a valid %s",
+      url: "%s is not a valid %s",
+      hex: "%s is not a valid %s"
+    },
+    string: {
+      len: "%s must be exactly %s characters",
+      min: "%s must be at least %s characters",
+      max: "%s cannot be longer than %s characters",
+      range: "%s must be between %s and %s characters"
+    },
+    number: {
+      len: "%s must equal %s",
+      min: "%s cannot be less than %s",
+      max: "%s cannot be greater than %s",
+      range: "%s must be between %s and %s"
+    },
+    array: {
+      len: "%s must be exactly %s in length",
+      min: "%s cannot be less than %s in length",
+      max: "%s cannot be greater than %s in length",
+      range: "%s must be between %s and %s in length"
+    },
+    pattern: {
+      mismatch: "%s value %s does not match pattern %s"
+    },
+    clone: function clone() {
+      var cloned = JSON.parse(JSON.stringify(this));
+      cloned.clone = this.clone;
+      return cloned;
+    }
+  };
+}
+var messages = newMessages();
+var Schema = /* @__PURE__ */ (function() {
+  function Schema2(descriptor) {
+    this.rules = null;
+    this._messages = messages;
+    this.define(descriptor);
+  }
+  var _proto = Schema2.prototype;
+  _proto.define = function define(rules2) {
+    var _this = this;
+    if (!rules2) {
+      throw new Error("Cannot configure a schema with no rules");
+    }
+    if (typeof rules2 !== "object" || Array.isArray(rules2)) {
+      throw new Error("Rules must be an object");
+    }
+    this.rules = {};
+    Object.keys(rules2).forEach(function(name) {
+      var item = rules2[name];
+      _this.rules[name] = Array.isArray(item) ? item : [item];
+    });
+  };
+  _proto.messages = function messages2(_messages) {
+    if (_messages) {
+      this._messages = deepMerge(newMessages(), _messages);
+    }
+    return this._messages;
+  };
+  _proto.validate = function validate(source_, o, oc) {
+    var _this2 = this;
+    if (o === void 0) {
+      o = {};
+    }
+    if (oc === void 0) {
+      oc = function oc2() {
+      };
+    }
+    var source = source_;
+    var options = o;
+    var callback = oc;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (!this.rules || Object.keys(this.rules).length === 0) {
+      if (callback) {
+        callback(null, source);
+      }
+      return Promise.resolve(source);
+    }
+    function complete(results) {
+      var errors = [];
+      var fields = {};
+      function add(e) {
+        if (Array.isArray(e)) {
+          var _errors;
+          errors = (_errors = errors).concat.apply(_errors, e);
+        } else {
+          errors.push(e);
+        }
+      }
+      for (var i = 0; i < results.length; i++) {
+        add(results[i]);
+      }
+      if (!errors.length) {
+        callback(null, source);
+      } else {
+        fields = convertFieldsError(errors);
+        callback(errors, fields);
+      }
+    }
+    if (options.messages) {
+      var messages$1 = this.messages();
+      if (messages$1 === messages) {
+        messages$1 = newMessages();
+      }
+      deepMerge(messages$1, options.messages);
+      options.messages = messages$1;
+    } else {
+      options.messages = this.messages();
+    }
+    var series = {};
+    var keys = options.keys || Object.keys(this.rules);
+    keys.forEach(function(z) {
+      var arr = _this2.rules[z];
+      var value = source[z];
+      arr.forEach(function(r) {
+        var rule = r;
+        if (typeof rule.transform === "function") {
+          if (source === source_) {
+            source = _extends({}, source);
+          }
+          value = source[z] = rule.transform(value);
+        }
+        if (typeof rule === "function") {
+          rule = {
+            validator: rule
+          };
+        } else {
+          rule = _extends({}, rule);
+        }
+        rule.validator = _this2.getValidationMethod(rule);
+        if (!rule.validator) {
+          return;
+        }
+        rule.field = z;
+        rule.fullField = rule.fullField || z;
+        rule.type = _this2.getType(rule);
+        series[z] = series[z] || [];
+        series[z].push({
+          rule,
+          value,
+          source,
+          field: z
+        });
+      });
+    });
+    var errorFields = {};
+    return asyncMap(series, options, function(data, doIt) {
+      var rule = data.rule;
+      var deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
+      deep = deep && (rule.required || !rule.required && data.value);
+      rule.field = data.field;
+      function addFullField(key, schema) {
+        return _extends({}, schema, {
+          fullField: rule.fullField + "." + key,
+          fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
+        });
+      }
+      function cb(e) {
+        if (e === void 0) {
+          e = [];
+        }
+        var errorList = Array.isArray(e) ? e : [e];
+        if (!options.suppressWarning && errorList.length) {
+          Schema2.warning("async-validator:", errorList);
+        }
+        if (errorList.length && rule.message !== void 0) {
+          errorList = [].concat(rule.message);
+        }
+        var filledErrors = errorList.map(complementError(rule, source));
+        if (options.first && filledErrors.length) {
+          errorFields[rule.field] = 1;
+          return doIt(filledErrors);
+        }
+        if (!deep) {
+          doIt(filledErrors);
+        } else {
+          if (rule.required && !data.value) {
+            if (rule.message !== void 0) {
+              filledErrors = [].concat(rule.message).map(complementError(rule, source));
+            } else if (options.error) {
+              filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
+            }
+            return doIt(filledErrors);
+          }
+          var fieldsSchema = {};
+          if (rule.defaultField) {
+            Object.keys(data.value).map(function(key) {
+              fieldsSchema[key] = rule.defaultField;
+            });
+          }
+          fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
+          var paredFieldsSchema = {};
+          Object.keys(fieldsSchema).forEach(function(field) {
+            var fieldSchema = fieldsSchema[field];
+            var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
+            paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
+          });
+          var schema = new Schema2(paredFieldsSchema);
+          schema.messages(options.messages);
+          if (data.rule.options) {
+            data.rule.options.messages = options.messages;
+            data.rule.options.error = options.error;
+          }
+          schema.validate(data.value, data.rule.options || options, function(errs) {
+            var finalErrors = [];
+            if (filledErrors && filledErrors.length) {
+              finalErrors.push.apply(finalErrors, filledErrors);
+            }
+            if (errs && errs.length) {
+              finalErrors.push.apply(finalErrors, errs);
+            }
+            doIt(finalErrors.length ? finalErrors : null);
+          });
+        }
+      }
+      var res;
+      if (rule.asyncValidator) {
+        res = rule.asyncValidator(rule, data.value, cb, data.source, options);
+      } else if (rule.validator) {
+        try {
+          res = rule.validator(rule, data.value, cb, data.source, options);
+        } catch (error) {
+          console.error == null ? void 0 : console.error(error);
+          if (!options.suppressValidatorError) {
+            setTimeout(function() {
+              throw error;
+            }, 0);
+          }
+          cb(error.message);
+        }
+        if (res === true) {
+          cb();
+        } else if (res === false) {
+          cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
+        } else if (res instanceof Array) {
+          cb(res);
+        } else if (res instanceof Error) {
+          cb(res.message);
+        }
+      }
+      if (res && res.then) {
+        res.then(function() {
+          return cb();
+        }, function(e) {
+          return cb(e);
+        });
+      }
+    }, function(results) {
+      complete(results);
+    }, source);
+  };
+  _proto.getType = function getType(rule) {
+    if (rule.type === void 0 && rule.pattern instanceof RegExp) {
+      rule.type = "pattern";
+    }
+    if (typeof rule.validator !== "function" && rule.type && !validators.hasOwnProperty(rule.type)) {
+      throw new Error(format("Unknown rule type %s", rule.type));
+    }
+    return rule.type || "string";
+  };
+  _proto.getValidationMethod = function getValidationMethod(rule) {
+    if (typeof rule.validator === "function") {
+      return rule.validator;
+    }
+    var keys = Object.keys(rule);
+    var messageIndex = keys.indexOf("message");
+    if (messageIndex !== -1) {
+      keys.splice(messageIndex, 1);
+    }
+    if (keys.length === 1 && keys[0] === "required") {
+      return validators.required;
+    }
+    return validators[this.getType(rule)] || void 0;
+  };
+  return Schema2;
+})();
+Schema.register = function register(type4, validator) {
+  if (typeof validator !== "function") {
+    throw new Error("Cannot register a validator by type, validator is not a function");
+  }
+  validators[type4] = validator;
+};
+Schema.warning = warning;
+Schema.messages = messages;
+Schema.validators = validators;
+const formContextKey = Symbol("formContext");
+function useForm() {
+  const formItems = ref([]);
+  const formInstance = reactive({
+    validate: async (callback) => {
+      const errors = [];
+      const validatePromises = formItems.value.map((formItem) => {
+        return formItem.validate("submit").catch((errorMessage) => {
+          errors.push({ message: errorMessage, field: "" });
+        });
+      });
+      await Promise.all(validatePromises);
+      const valid = errors.length === 0;
+      if (callback) {
+        callback(valid, errors);
+      }
+      return valid;
+    },
+    validateField: async (props, callback) => {
+      const propsArray = Array.isArray(props) ? props : [props];
+      const errors = [];
+      const fields = {};
+      const validatePromises = formItems.value.filter((item) => {
+        const itemProp = item.prop;
+        return itemProp && propsArray.includes(itemProp);
+      }).map((formItem) => {
+        return formItem.validate("blur").catch((errorMessage) => {
+          const field = formItem.prop;
+          errors.push({ message: errorMessage, field });
+          if (field) {
+            if (!fields[field]) {
+              fields[field] = [];
+            }
+            fields[field].push({ message: errorMessage, field });
+          }
+        });
+      });
+      await Promise.all(validatePromises);
+      const valid = errors.length === 0;
+      if (callback) {
+        callback(valid ? null : errors[0], fields);
+      }
+      return valid;
+    },
+    resetFields: () => {
+      formItems.value.forEach((formItem) => {
+        formItem.resetField();
+      });
+    },
+    clearValidate: (props) => {
+      if (props) {
+        const propsArray = Array.isArray(props) ? props : [props];
+        formItems.value.filter((item) => {
+          const itemProp = item.prop;
+          return itemProp && propsArray.includes(itemProp);
+        }).forEach((formItem) => {
+          formItem.clearValidate();
+        });
+      } else {
+        formItems.value.forEach((formItem) => {
+          formItem.clearValidate();
+        });
+      }
+    },
+    scrollToField: (prop) => {
+      const formItem = formItems.value.find((item) => item.prop === prop);
+      if (formItem) {
+        const el = formItem.$el;
+        if (el) {
+          el.scrollIntoView({ behavior: "smooth", block: "center" });
+        }
+      }
+    }
+  });
+  const addFormItem = (formItem) => {
+    formItems.value.push(formItem);
+  };
+  const removeFormItem = (formItem) => {
+    const index2 = formItems.value.indexOf(formItem);
+    if (index2 > -1) {
+      formItems.value.splice(index2, 1);
+    }
+  };
+  return {
+    formInstance,
+    addFormItem,
+    removeFormItem
+  };
+}
+function provideForm(props) {
+  const { formInstance, addFormItem, removeFormItem } = useForm();
+  const formContext = reactive({
+    model: props.model || {},
+    rules: props.rules || {},
+    labelWidth: props.labelWidth || "",
+    labelPosition: props.labelPosition || "left",
+    requiredSymbol: props.requiredSymbol || "*",
+    statusIcon: props.statusIcon || false,
+    inline: props.inline || false,
+    hideRequiredAsterisk: props.hideRequiredAsterisk || false,
+    form: formInstance,
+    addFormItem,
+    removeFormItem
+  });
+  provide(formContextKey, readonly(formContext));
+  return formContext;
+}
+function useFormContext() {
+  const formContext = inject(formContextKey);
+  if (!formContext) {
+    throw new Error("FormItem must be used within Form");
+  }
+  return formContext;
+}
+function useFormItem(prop) {
+  const formContext = useFormContext();
+  const error = ref("");
+  const validated = ref(false);
+  const validate = async (_trigger = "blur", callback) => {
+    if (!prop || !formContext.model || !formContext.rules[prop]) {
+      const valid = true;
+      if (callback) {
+        callback(valid, "");
+      }
+      return valid;
+    }
+    const rules2 = formContext.rules[prop];
+    const value = getFieldValue(formContext.model, prop);
+    const schema = new Schema({
+      [prop]: rules2
+    });
+    try {
+      await schema.validate({
+        [prop]: value
+      }, {
+        first: true
+      });
+      error.value = "";
+      validated.value = true;
+      if (callback) {
+        callback(true, "");
+      }
+      return true;
+    } catch (err) {
+      error.value = err.errors[0];
+      validated.value = false;
+      if (callback) {
+        callback(false, err.errors[0]);
+      }
+      return false;
+    }
+  };
+  const resetField = () => {
+    if (!prop || !formContext.model) return;
+    setFieldValue(formContext.model, prop, "");
+    error.value = "";
+    validated.value = false;
+  };
+  const clearValidate = () => {
+    error.value = "";
+    validated.value = false;
+  };
+  return {
+    formContext,
+    error,
+    validated,
+    validate,
+    resetField,
+    clearValidate
+  };
+}
+function getFieldValue(obj, path) {
+  return path.split(".").reduce((prev, curr) => prev && prev[curr], obj);
+}
+function setFieldValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+  const target = keys.reduce((prev, curr) => {
+    if (!prev[curr]) {
+      prev[curr] = {};
+    }
+    return prev[curr];
+  }, obj);
+  target[lastKey] = value;
+}
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "form",
+  props: {
+    model: { default: () => ({}) },
+    rules: { default: () => ({}) },
+    labelWidth: { default: "" },
+    labelPosition: { default: "left" },
+    inline: { type: Boolean, default: false },
+    hideRequiredAsterisk: { type: Boolean, default: false },
+    requiredSymbol: {},
+    statusIcon: { type: Boolean },
+    class: {},
+    style: {}
+  },
+  emits: ["submit", "reset"],
+  setup(__props, { emit: __emit }) {
+    const ns = useNamespace("form");
+    const props = __props;
+    const emit = __emit;
+    const formContext = provideForm(props);
+    const handleSubmit = (evt) => {
+      emit("submit", evt);
+    };
+    const handleReset = () => {
+      formContext.form.resetFields();
+      emit("reset");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("form", {
+        class: normalizeClass([
+          unref(ns).b,
+          unref(ns).m(__props.labelPosition),
+          {
+            [unref(ns).m("inline")]: __props.inline
+          }
+        ]),
+        onSubmit: withModifiers(handleSubmit, ["prevent"]),
+        onReset: handleReset
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 34);
+    };
+  }
+});
+const Form = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-e8640a65"]]);
+const _hoisted_1$2 = {
+  key: 0,
+  class: "fire-form-item__asterisk"
+};
+const _hoisted_2$1 = { class: "fire-form-item__content" };
+const _hoisted_3$1 = {
+  key: 0,
+  class: "fire-form-item__error"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "form-item",
+  props: {
+    prop: { default: "" },
+    label: { default: "" },
+    labelWidth: { default: "" },
+    required: { type: Boolean, default: false },
+    error: { default: "" },
+    class: {},
+    style: {}
+  },
+  emits: ["validate"],
+  setup(__props) {
+    const ns = useNamespace("form-item");
+    const props = __props;
+    const { formContext, error, validate, resetField, clearValidate } = useFormItem(props.prop);
+    const errorMessage = computed(() => {
+      return props.error || error.value;
+    });
+    const isRequired = computed(() => {
+      if (props.required) return true;
+      if (!props.prop) return false;
+      const rules2 = formContext.rules[props.prop];
+      if (!rules2) return false;
+      const ruleArray = Array.isArray(rules2) ? rules2 : [rules2];
+      return ruleArray.some((rule) => rule.required);
+    });
+    const labelStyle = computed(() => {
+      const width = props.labelWidth || formContext.labelWidth;
+      return width ? { width: typeof width === "number" ? `${width}px` : width } : {};
+    });
+    onMounted(() => {
+      formContext.addFormItem({
+        validate,
+        resetField,
+        clearValidate
+      });
+    });
+    onUnmounted(() => {
+      formContext.removeFormItem({
+        validate,
+        resetField,
+        clearValidate
+      });
+    });
+    if (props.prop) {
+      watch(() => formContext.model[props.prop], () => {
+        validate("change");
+      });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          {
+            [unref(ns).m("error")]: errorMessage.value
+          }
+        ])
+      }, [
+        __props.label ? (openBlock(), createElementBlock("label", {
+          key: 0,
+          class: "fire-form-item__label",
+          style: normalizeStyle(labelStyle.value)
+        }, [
+          isRequired.value && !unref(formContext).hideRequiredAsterisk ? (openBlock(), createElementBlock("span", _hoisted_1$2, "*")) : createCommentVNode("", true),
+          createTextVNode(" " + toDisplayString(__props.label), 1)
+        ], 4)) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_2$1, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true),
+          errorMessage.value ? (openBlock(), createElementBlock("div", _hoisted_3$1, toDisplayString(errorMessage.value), 1)) : createCommentVNode("", true)
+        ])
+      ], 2);
+    };
+  }
+});
+const FormItem = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-074e5183"]]);
+const FireForm = withInstall(Form);
+const FireFormItem = withInstall(FormItem);
+const tableContextKey = Symbol("tableContext");
+function useTable() {
+  const columns = ref([]);
+  const currentRow = ref(null);
+  const oldCurrentRow = ref(null);
+  const tableInstance = reactive({
+    clearSort: () => {
+      columns.value.forEach((column) => {
+        if (column.column.sortable) {
+          column.updateColumn({ sortOrder: null });
+        }
+      });
+    },
+    clearFilter: (columnKey) => {
+      if (columnKey) {
+        const keys = Array.isArray(columnKey) ? columnKey : [columnKey];
+        columns.value.filter((column) => keys.includes(column.column.prop || "")).forEach((column) => {
+          column.updateColumn({ filteredValue: [] });
+        });
+      } else {
+        columns.value.forEach((column) => {
+          if (column.column.filters) {
+            column.updateColumn({ filteredValue: [] });
+          }
+        });
+      }
+    },
+    setCurrentRow: (row) => {
+      oldCurrentRow.value = currentRow.value;
+      currentRow.value = row;
+    },
+    doLayout: () => {
+    },
+    getRows: () => {
+      return [];
+    }
+  });
+  const addColumn = (column) => {
+    columns.value.push(column);
+  };
+  const removeColumn = (column) => {
+    const index2 = columns.value.indexOf(column);
+    if (index2 > -1) {
+      columns.value.splice(index2, 1);
+    }
+  };
+  return {
+    tableInstance,
+    columns,
+    currentRow,
+    oldCurrentRow,
+    addColumn,
+    removeColumn
+  };
+}
+function provideTable(props) {
+  const { tableInstance, currentRow, oldCurrentRow, addColumn, removeColumn } = useTable();
+  const tableContext = reactive({
+    data: props.data || [],
+    border: props.border || false,
+    stripe: props.stripe || false,
+    highlightCurrentRow: props.highlightCurrentRow || false,
+    currentRowKey: props.currentRowKey || "",
+    table: tableInstance,
+    addColumn,
+    removeColumn
+  });
+  provide(tableContextKey, readonly(tableContext));
+  return {
+    tableContext,
+    currentRow,
+    oldCurrentRow
+  };
+}
+function useTableContext() {
+  const tableContext = inject(tableContextKey);
+  if (!tableContext) {
+    throw new Error("TableColumn must be used within Table");
+  }
+  return tableContext;
+}
+function useTableColumn(props) {
+  const tableContext = useTableContext();
+  const columnInstance = reactive({
+    column: props,
+    updateColumn: (newProps) => {
+      Object.assign(columnInstance.column, newProps);
+    }
+  });
+  return {
+    tableContext,
+    columnInstance
+  };
+}
+const _hoisted_1$1 = { class: "fire-table__inner" };
+const _hoisted_2 = ["onClick"];
+const _hoisted_3 = { class: "fire-table__column-header" };
+const _hoisted_4 = { key: 1 };
+const _hoisted_5 = {
+  key: 0,
+  class: "fire-table__column-sorter"
+};
+const _hoisted_6 = ["onClick"];
+const _hoisted_7 = { key: 1 };
+const _hoisted_8 = {
+  key: 0,
+  class: "fire-table__empty"
+};
+const _hoisted_9 = ["colspan"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "table",
+  props: {
+    data: { default: () => [] },
+    border: { type: Boolean, default: false },
+    stripe: { type: Boolean, default: false },
+    highlightCurrentRow: { type: Boolean, default: false },
+    currentRowKey: { default: "" },
+    height: {},
+    maxHeight: {},
+    class: {},
+    style: {}
+  },
+  emits: ["row-click", "sort-change", "filter-change", "current-change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const ns = useNamespace("table");
+    const props = __props;
+    const emit = __emit;
+    const { tableContext, currentRow } = provideTable(props);
+    const columns = ref([]);
+    watch(() => props.data, (newData) => {
+      tableContext.data = newData;
+    });
+    watch(() => props.highlightCurrentRow, (value) => {
+      tableContext.highlightCurrentRow = value;
+    });
+    watch(() => props.currentRowKey, (key) => {
+      tableContext.currentRowKey = key;
+      if (key && props.data.length > 0) {
+        const row = props.data.find((item) => item.key === key || item.id === key);
+        if (row) {
+          currentRow.value = row;
+        }
+      }
+    });
+    watch(currentRow, (newRow, oldRow) => {
+      emit("current-change", newRow, oldRow);
+    });
+    const handleRowClick = (row, event) => {
+      if (props.highlightCurrentRow) {
+        currentRow.value = row;
+      }
+      emit("row-click", row, event);
+    };
+    const handleColumnClick = (column) => {
+      if (column.sortable) {
+        if (column.sortOrder === "ascending") {
+          column.sortOrder = "descending";
+        } else if (column.sortOrder === "descending") {
+          column.sortOrder = null;
+        } else {
+          column.sortOrder = "ascending";
+        }
+        columns.value.forEach((col) => {
+          if (col !== column) {
+            col.sortOrder = null;
+          }
+        });
+        emit("sort-change", column, column.sortOrder);
+      }
+    };
+    const registerColumn = (column) => {
+      columns.value.push(column);
+    };
+    const unregisterColumn = (column) => {
+      const index2 = columns.value.indexOf(column);
+      if (index2 > -1) {
+        columns.value.splice(index2, 1);
+      }
+    };
+    __expose({
+      registerColumn,
+      unregisterColumn
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b,
+          {
+            [unref(ns).m("border")]: __props.border,
+            [unref(ns).m("stripe")]: __props.stripe
+          }
+        ])
+      }, [
+        createElementVNode("table", _hoisted_1$1, [
+          createElementVNode("thead", null, [
+            createElementVNode("tr", null, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(columns.value, (column) => {
+                return openBlock(), createElementBlock("th", {
+                  key: column.prop || column.label,
+                  class: normalizeClass([
+                    "fire-table__column",
+                    {
+                      [`fire-table__column--fixed-${column.fixed}`]: column.fixed,
+                      [`fire-table__column--sortable`]: column.sortable
+                    }
+                  ]),
+                  style: normalizeStyle({ width: column.width }),
+                  onClick: ($event) => handleColumnClick(column)
+                }, [
+                  createElementVNode("div", _hoisted_3, [
+                    renderSlot(_ctx.$slots, `header-${column.prop}`, { column }, () => [
+                      column.$slots.header ? renderSlot(_ctx.$slots, "header", {
+                        key: 0,
+                        column
+                      }, void 0, true) : (openBlock(), createElementBlock("span", _hoisted_4, toDisplayString(column.label), 1))
+                    ], true),
+                    column.sortable ? (openBlock(), createElementBlock("div", _hoisted_5, [
+                      createElementVNode("span", {
+                        class: normalizeClass(["fire-table__column-sorter-icon", {
+                          "fire-table__column-sorter-icon--ascending": column.sortOrder === "ascending",
+                          "fire-table__column-sorter-icon--descending": column.sortOrder === "descending"
+                        }])
+                      }, [
+                        createVNode(unref(ChevronUp), { size: 12 }),
+                        createVNode(unref(ChevronDown), { size: 12 })
+                      ], 2)
+                    ])) : createCommentVNode("", true)
+                  ])
+                ], 14, _hoisted_2);
+              }), 128))
+            ])
+          ]),
+          createElementVNode("tbody", null, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.data, (row, index2) => {
+              return openBlock(), createElementBlock("tr", {
+                key: row.key || index2,
+                class: normalizeClass({
+                  "fire-table__row--current": __props.highlightCurrentRow && row === unref(currentRow)
+                }),
+                onClick: ($event) => handleRowClick(row, $event)
+              }, [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(columns.value, (column) => {
+                  return openBlock(), createElementBlock("td", {
+                    key: column.prop || column.label,
+                    class: normalizeClass([
+                      "fire-table__cell",
+                      {
+                        [`fire-table__cell--fixed-${column.fixed}`]: column.fixed
+                      }
+                    ]),
+                    style: normalizeStyle({ width: column.width })
+                  }, [
+                    renderSlot(_ctx.$slots, `default-${column.prop}`, {
+                      row,
+                      column,
+                      $index: index2
+                    }, () => [
+                      column.$slots.default ? renderSlot(_ctx.$slots, "default", {
+                        key: 0,
+                        row,
+                        column,
+                        $index: index2
+                      }, void 0, true) : (openBlock(), createElementBlock("span", _hoisted_7, toDisplayString(row[column.prop]), 1))
+                    ], true)
+                  ], 6);
+                }), 128))
+              ], 10, _hoisted_6);
+            }), 128)),
+            __props.data.length === 0 ? (openBlock(), createElementBlock("tr", _hoisted_8, [
+              createElementVNode("td", {
+                colspan: columns.value.length,
+                class: "fire-table__empty-cell"
+              }, [
+                renderSlot(_ctx.$slots, "empty", {}, () => [
+                  _cache[0] || (_cache[0] = createElementVNode("div", { class: "fire-table__empty-content" }, [
+                    createElementVNode("div", { style: { "font-size": "48px", "margin-bottom": "16px" } }, "📦"),
+                    createElementVNode("p", null, "暂无数据")
+                  ], -1))
+                ], true)
+              ], 8, _hoisted_9)
+            ])) : createCommentVNode("", true)
+          ])
+        ])
+      ], 2);
+    };
+  }
+});
+const Table = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-690936e8"]]);
+const _hoisted_1 = { style: { "display": "none" } };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "table-column",
+  props: {
+    prop: { default: "" },
+    label: { default: "" },
+    width: { default: "" },
+    fixed: { default: void 0 },
+    sortable: { type: Boolean, default: false },
+    sortMethod: {},
+    sortOrder: { default: null },
+    filters: { default: void 0 },
+    filterMethod: {},
+    filteredValue: { default: void 0 },
+    class: {},
+    style: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const tableContext = useTableContext();
+    const { columnInstance } = useTableColumn(props);
+    const columnWithSlots = computed(() => {
+      return {
+        ...columnInstance.column,
+        $slots: slots
+      };
+    });
+    onMounted(() => {
+      const table = tableContext.table;
+      if (table && table.registerColumn) {
+        table.registerColumn(columnWithSlots.value);
+      }
+      const tableElement = document.querySelector(".fire-table");
+      if (tableElement && tableElement.__vueParentComponent) {
+        const parent = tableElement.__vueParentComponent;
+        if (parent.proxy && parent.proxy.registerColumn) {
+          parent.proxy.registerColumn(columnWithSlots.value);
+        }
+      }
+    });
+    onUnmounted(() => {
+      const table = tableContext.table;
+      if (table && table.unregisterColumn) {
+        table.unregisterColumn(columnWithSlots.value);
+      }
+      const tableElement = document.querySelector(".fire-table");
+      if (tableElement && tableElement.__vueParentComponent) {
+        const parent = tableElement.__vueParentComponent;
+        if (parent.proxy && parent.proxy.unregisterColumn) {
+          parent.proxy.unregisterColumn(columnWithSlots.value);
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1);
+    };
+  }
+});
+const FireTable = withInstall(Table);
+const FireTableColumn = withInstall(_sfc_main);
+const components = [FButton, FireRow, FireCol, FireContainer, FireHeader, FireAside, FireMain, FireFooter, FireTooltip, FireTips, FireInput, FireForm, FireFormItem, FireTable, FireTableColumn];
+const install = (app) => {
+  components.forEach((component) => {
+    if (component && component.name) {
+      app.component(component.name, component);
+    }
+  });
+};
+const index = {
+  install,
+  version: "0.1.0"
+};
+export {
+  FButton,
+  FireAside,
+  FireCol,
+  FireContainer,
+  FireFooter,
+  FireForm,
+  FireFormItem,
+  FireHeader,
+  FireInput,
+  FireMain,
+  FireRow,
+  FireTable,
+  FireTableColumn,
+  FireTips,
+  FireTooltip,
+  index as default,
+  registerComponent,
+  registerComponents,
+  useNamespace,
+  withInstall
+};
+//# sourceMappingURL=fireui.es.mjs.map