@kine-design/core 0.0.1-beta.1

package/dist/core.js

@@ -0,0 +1,4270 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _source, _cacheMap, _config, _initialConfig, _Tree_instances, genTreeNodeData_fn, clearCache_fn, init_fn, genCacheMap_fn, getCacheList_fn, setParentChecked_fn, setChildrenStatus_fn;
+import { toRef, ref, computed, watch, onBeforeUnmount, onMounted, shallowRef, onBeforeMount, nextTick, onUnmounted, triggerRef, inject, provide } from "vue";
+import * as _interactjsModule from "interactjs";
+import { autoUpdate, arrow, computePosition } from "@floating-ui/dom";
+import dayjs from "dayjs";
+const props$O = {
+  shape: { type: String, default: "circle" },
+  size: { type: String, default: "medium" },
+  src: { type: String, default: "" },
+  alt: { type: String, default: "" }
+};
+const AvatarCore = {
+  props: props$O
+};
+const props$N = {
+  type: { type: String, default: "text" },
+  placeholder: { type: String, default: "" },
+  modelValue: { type: [String, Number], default: "" },
+  readonly: { type: Boolean, default: false },
+  disabled: { type: Boolean, default: false },
+  autofocus: { type: Boolean, default: false }
+};
+function useInput(props2, ctx) {
+  const isInput = props2.type !== "textarea";
+  const inputType = isInput ? "input" : "textarea";
+  const inputClass = isInput ? "m-input-inner" : "m-textarea-inner";
+  const rowInfo = isInput ? {} : { rows: 10 };
+  const baseProps = {
+    autofocus: props2.autofocus,
+    value: props2.modelValue,
+    placeholder: props2.placeholder,
+    disabled: props2.disabled,
+    type: props2.type,
+    readOnly: props2.readonly
+  };
+  const onInput = (e) => {
+    ctx.emit("update:modelValue", e.target.value);
+    ctx.emit("input", e.target.value);
+  };
+  const onFocus = (e) => {
+    ctx.emit("focus", e);
+  };
+  const onBlur = (e) => {
+    ctx.emit("blur", e);
+  };
+  return {
+    baseProps,
+    inputType,
+    inputClass,
+    rowInfo,
+    onInput,
+    onFocus,
+    onBlur
+  };
+}
+const InputCore = {
+  props: props$N,
+  useInput
+};
+const props$M = {
+  text: { type: String, default: "" },
+  link: { type: Boolean, default: false },
+  disabled: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false },
+  plain: { type: Boolean, default: false },
+  type: {
+    type: String,
+    default: "default",
+    enum: ["default", "primary", "success", "warning", "danger", "info"]
+  },
+  size: {
+    type: String,
+    default: "medium",
+    enum: ["large", "medium", "small"]
+  }
+};
+const defineHook = (hook) => {
+  return hook;
+};
+const useButton = defineHook((props2, { slots }) => {
+  var _a;
+  const domType = props2.link ? "a" : "button";
+  const slot = ((_a = slots.default) == null ? void 0 : _a.call(slots)) ?? props2.text;
+  const isDisabled = props2.disabled || props2.loading;
+  const domProps = {
+    class: [
+      "m-button",
+      { "m-button-disabled": isDisabled },
+      { "m-button-loading": props2.loading },
+      { "m-button-plain": props2.plain },
+      `m-button-${props2.type ?? "default"}`,
+      `m-button-${props2.size ?? "medium"}`
+    ],
+    disabled: isDisabled
+  };
+  return {
+    domType,
+    slot,
+    domProps,
+    isDisabled
+  };
+});
+const ButtonCore = {
+  props: props$M,
+  useButton
+};
+const props$L = {
+  modelValue: { type: void 0, default: "" },
+  options: { type: Array, default: () => [] },
+  inputParam: { type: String, default: void 0 },
+  optionParam: { type: String, default: void 0 },
+  valueParam: { type: String, default: void 0 },
+  readonly: { type: Boolean, default: true },
+  disabled: { type: Boolean, default: false },
+  placeholder: { type: String, default: "请选择..." },
+  toMatch: { type: Function, default: void 0 },
+  multiple: { type: Boolean, default: false },
+  checkbox: { type: Boolean, default: true },
+  filterable: { type: Boolean, default: false },
+  filter: { type: Function, default: void 0 },
+  optionsH: { type: [Number, String], default: void 0 },
+  needFetch: { type: Boolean, default: false },
+  fetch: { type: Function, default: void 0 }
+};
+function useSelectTools(props2) {
+  const getInfoWithKey = (option, key) => {
+    const paramKey = props2[key];
+    if (!paramKey) {
+      if (option && typeof option === "object") {
+        if ("label" in option) return option.label;
+        if ("name" in option) return option.name;
+        if ("text" in option) return option.text;
+      }
+      return option;
+    }
+    try {
+      return option[paramKey];
+    } catch {
+      return option;
+    }
+  };
+  const getInputValue = (option) => {
+    return String(getInfoWithKey(option, "inputParam") ?? "");
+  };
+  const getOptionValue = (option) => {
+    return String(getInfoWithKey(option, "optionParam") ?? "");
+  };
+  const getModelValue = (option) => {
+    if (props2.valueParam) {
+      return getInfoWithKey(option, "valueParam");
+    }
+    return option;
+  };
+  return { getInfoWithKey, getInputValue, getOptionValue, getModelValue };
+}
+function useSelect(props2, ctx) {
+  const tools = useSelectTools(props2);
+  const optionsRef = toRef(() => props2.options ?? []);
+  const modelValueRef = toRef(() => props2.modelValue);
+  const multipleRef = toRef(() => props2.multiple ?? false);
+  const inputReadonly = toRef(() => props2.filterable ? false : props2.readonly ?? true);
+  const inputValue = ref("");
+  const isOpen = ref(false);
+  const fetchLoading = ref(false);
+  const selectedIndices = ref(/* @__PURE__ */ new Set());
+  const isSelected = (option, index) => {
+    if (multipleRef.value) {
+      return selectedIndices.value.has(index);
+    }
+    if (props2.toMatch) {
+      return props2.toMatch(option, modelValueRef.value);
+    }
+    return modelValueRef.value === tools.getModelValue(option);
+  };
+  const allOptions = computed(() => {
+    return optionsRef.value.map((o, i) => ({
+      value: o,
+      index: i,
+      isSelected: isSelected(o, i)
+    }));
+  });
+  const displayOptions = computed(() => {
+    return allOptions.value.filter((o) => {
+      if (inputReadonly.value) return true;
+      if (!inputValue.value) return true;
+      if (props2.filter) {
+        return props2.filter(o.value, inputValue.value);
+      }
+      return tools.getOptionValue(o.value).toLowerCase().includes(inputValue.value.toLowerCase());
+    });
+  });
+  const selectedTags = computed(() => {
+    if (!multipleRef.value) return [];
+    return allOptions.value.filter((o) => o.isSelected);
+  });
+  const syncInputFromModelValue = () => {
+    if (multipleRef.value) {
+      inputValue.value = "";
+      return;
+    }
+    const mv = modelValueRef.value;
+    if (mv == null || mv === "") {
+      inputValue.value = "";
+      return;
+    }
+    const found = optionsRef.value.find((o) => {
+      if (props2.toMatch) return props2.toMatch(o, mv);
+      return tools.getModelValue(o) === mv;
+    });
+    inputValue.value = found ? tools.getInputValue(found) : "";
+  };
+  const syncSelectedFromModelValue = () => {
+    if (!multipleRef.value) return;
+    const mv = modelValueRef.value;
+    const newSet = /* @__PURE__ */ new Set();
+    if (Array.isArray(mv)) {
+      optionsRef.value.forEach((o, i) => {
+        const val = tools.getModelValue(o);
+        if (mv.includes(val)) {
+          newSet.add(i);
+        }
+        if (props2.toMatch && mv.some((v) => props2.toMatch(o, v))) {
+          newSet.add(i);
+        }
+      });
+    }
+    selectedIndices.value = newSet;
+  };
+  syncSelectedFromModelValue();
+  syncInputFromModelValue();
+  const onSelect = (index) => {
+    const option = optionsRef.value[index];
+    if (!option) return;
+    if (multipleRef.value) {
+      const newSet = new Set(selectedIndices.value);
+      if (newSet.has(index)) {
+        newSet.delete(index);
+      } else {
+        newSet.add(index);
+      }
+      selectedIndices.value = newSet;
+      inputValue.value = "";
+      const newModelValue = optionsRef.value.filter((_, i) => newSet.has(i)).map((o) => tools.getModelValue(o));
+      ctx.emit("update:modelValue", newModelValue);
+      ctx.emit("select", option);
+    } else {
+      inputValue.value = tools.getInputValue(option);
+      ctx.emit("update:modelValue", tools.getModelValue(option));
+      ctx.emit("select", option);
+      isOpen.value = false;
+    }
+  };
+  const onDeleteTag = (index) => {
+    const newSet = new Set(selectedIndices.value);
+    newSet.delete(index);
+    selectedIndices.value = newSet;
+    const newModelValue = optionsRef.value.filter((_, i) => newSet.has(i)).map((o) => tools.getModelValue(o));
+    ctx.emit("update:modelValue", newModelValue);
+  };
+  const onInput = () => {
+    ctx.emit("input", inputValue.value);
+  };
+  const onFocus = (e) => {
+    if (inputReadonly.value) return;
+    ctx.emit("focus", e, inputValue.value);
+  };
+  const onBlur = (e) => {
+    if (inputReadonly.value) return;
+    ctx.emit("blur", e, inputValue.value);
+    if (!multipleRef.value) {
+      const matched = displayOptions.value.find((o) => o.isSelected);
+      if (matched && inputValue.value === tools.getInputValue(matched.value)) return;
+      if (!inputValue.value) {
+        ctx.emit("update:modelValue", void 0);
+      }
+    }
+  };
+  const lastOptionRef = ref(null);
+  const optionsContainerRef = ref(null);
+  let fetchObserver;
+  const cleanupFetchObserver = () => {
+    if (fetchObserver) {
+      fetchObserver.disconnect();
+      fetchObserver = void 0;
+    }
+  };
+  const updateFetchObserver = () => {
+    cleanupFetchObserver();
+    if (!props2.needFetch || !lastOptionRef.value || !optionsContainerRef.value) return;
+    fetchObserver = new IntersectionObserver(
+      async (entries) => {
+        var _a;
+        const entry = entries[0];
+        if ((entry == null ? void 0 : entry.isIntersecting) && props2.needFetch) {
+          fetchLoading.value = true;
+          await ((_a = props2.fetch) == null ? void 0 : _a.call(props2));
+          fetchLoading.value = false;
+        }
+      },
+      { root: optionsContainerRef.value, threshold: 1 }
+    );
+    fetchObserver.observe(lastOptionRef.value);
+  };
+  watch(modelValueRef, () => {
+    syncSelectedFromModelValue();
+    syncInputFromModelValue();
+  });
+  watch(optionsRef, () => {
+    syncSelectedFromModelValue();
+    syncInputFromModelValue();
+  }, { deep: true });
+  watch(lastOptionRef, () => {
+    updateFetchObserver();
+  });
+  onBeforeUnmount(cleanupFetchObserver);
+  return {
+    // 状态
+    inputValue,
+    isOpen,
+    fetchLoading,
+    // 输入框是否只读（filterable=true 时为 false）
+    inputReadonly,
+    // 列表
+    displayOptions,
+    selectedTags,
+    // DOM refs（fetch 用）
+    lastOptionRef,
+    optionsContainerRef,
+    // 事件
+    onSelect,
+    onDeleteTag,
+    onInput,
+    onFocus,
+    onBlur,
+    // 工具
+    tools,
+    // fetch
+    updateFetchObserver
+  };
+}
+const SelectCore = {
+  props: props$L,
+  useSelect
+};
+const props$K = {
+  label: { type: String, default: "" },
+  checked: { type: Boolean, default: void 0 },
+  value: { type: null, default: void 0 },
+  modelValue: { type: null, default: void 0 },
+  indeterminate: { type: Boolean, default: false },
+  disabled: { type: Boolean, default: false }
+};
+const notEmpty = (value) => {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  const valueType = typeof value;
+  if (valueType === "string") {
+    return value !== "";
+  }
+  if (valueType === "number" || valueType === "bigint" || valueType === "boolean" || valueType === "function") {
+    return true;
+  }
+  if (valueType === "symbol") {
+    return value.toString() !== "Symbol()";
+  }
+  if (valueType === "object") {
+    if (value instanceof String || value instanceof Array) {
+      return value.length !== 0;
+    }
+    if (value instanceof Number || value instanceof Boolean) {
+      return true;
+    }
+    if (value instanceof Map || value instanceof Set) {
+      return value.size > 0;
+    }
+    if (value instanceof WeakMap || value instanceof WeakSet) {
+      console.error("WeakMap和WeakSet无法以通用的方式判断是否为空。");
+      return false;
+    }
+    if (value instanceof RegExp) {
+      return value.toString() !== "/(?:)/";
+    }
+    if (value instanceof Date) {
+      return value.toString() !== "Invalid Date";
+    }
+    const typedArrayTypes = [
+      Int8Array,
+      Uint8Array,
+      Uint8ClampedArray,
+      Int16Array,
+      Uint16Array,
+      Int32Array,
+      Uint32Array,
+      Float32Array,
+      Float64Array
+    ];
+    for (const arrayType of typedArrayTypes) {
+      if (value instanceof arrayType) {
+        return value.length;
+      }
+    }
+    return Object.keys(value).length > 0;
+  }
+};
+const isEmpty$1 = (value) => !notEmpty(value);
+const isBoolean = (val) => typeof val === "boolean";
+const initChecked = (props2) => {
+  if (props2.checked) {
+    return props2.checked;
+  }
+  if (notEmpty(props2.modelValue)) {
+    if (notEmpty(props2.value)) {
+      if (Array.isArray(props2.modelValue)) {
+        return props2.modelValue.includes(props2.value);
+      }
+      return props2.value === props2.modelValue;
+    }
+    if (isBoolean(props2.modelValue)) {
+      return props2.modelValue;
+    }
+  }
+  return false;
+};
+const getNewModelValue = (props2, checked) => {
+  if (props2.value) {
+    if (Array.isArray(props2.modelValue)) {
+      const arr = [...props2.modelValue];
+      if (checked) {
+        if (!arr.includes(props2.value)) arr.push(props2.value);
+      } else {
+        const idx = arr.indexOf(props2.value);
+        if (idx !== -1) arr.splice(idx, 1);
+      }
+      return arr;
+    }
+    return checked ? props2.value : void 0;
+  }
+  return checked;
+};
+function useCheckbox(props2, ctx) {
+  const checkboxClass = ["m-checkbox", { "m-disabled": props2.disabled }];
+  const checked = ref(initChecked(props2));
+  watch(() => props2.modelValue, () => {
+    checked.value = initChecked(props2);
+  });
+  const onClick = (e) => {
+    e.stopPropagation();
+    if (props2.disabled) {
+      return;
+    }
+    checked.value = !checked.value;
+    const newVal = getNewModelValue(props2, checked.value);
+    ctx.emit("change", newVal);
+    ctx.emit("update:modelValue", newVal);
+  };
+  return {
+    checkboxClass,
+    checked,
+    onClick
+  };
+}
+const CheckboxCore = {
+  props: props$K,
+  useCheckbox
+};
+const props$J = {
+  modelValue: { type: void 0, required: true },
+  disabled: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false },
+  activeInfo: { type: String, default: "" },
+  inactiveInfo: { type: String, default: "" },
+  activeValue: { type: void 0, default: void 0 },
+  inactiveValue: { type: void 0, default: void 0 },
+  onControl: { type: Boolean, default: false }
+};
+const switchIsBoolean = (value) => {
+  return typeof value === "boolean";
+};
+const getIsActive = (value, activeValue) => {
+  return value === activeValue;
+};
+function useSwitch(props2, ctx) {
+  const activeValue = ref(props2.activeValue);
+  const inactiveValue = ref(props2.inactiveValue);
+  const { slots, emit } = ctx;
+  const isBoolean2 = computed(() => switchIsBoolean(props2.modelValue));
+  if (isBoolean2.value) {
+    if (isEmpty$1(props2.activeValue) && isEmpty$1(props2.inactiveValue)) {
+      activeValue.value = true;
+      inactiveValue.value = false;
+    }
+  }
+  const isActive = computed(() => getIsActive(props2.modelValue, activeValue.value));
+  const changeSwitch = () => {
+    if (props2.disabled || props2.loading) {
+      return;
+    }
+    if (!props2.onControl) {
+      if (isBoolean2.value) {
+        emit("update:modelValue", !props2.modelValue);
+      }
+    }
+    emit("change", !isActive.value ? props2.activeValue ?? true : inactiveValue ?? false);
+  };
+  const getInfo = (key) => {
+    if (slots[key]) {
+      return slots[key]();
+    }
+    const info = props2[key];
+    if (!info) {
+      return;
+    }
+    return /* @__PURE__ */ React.createElement("span", { class: "m-switch-span" }, info);
+  };
+  const switchClass = computed(() => [
+    "m-switch",
+    isActive.value ? "m-switch-active" : "m-switch-inactive",
+    { "m-switch-loading": props2.loading },
+    { "m-switch-disabled": props2.disabled }
+  ]);
+  return {
+    getInfo,
+    changeSwitch,
+    switchClass
+  };
+}
+const SwitchCore = {
+  props: props$J,
+  switchIsBoolean,
+  getIsActive,
+  useSwitch
+};
+const props$I = {
+  type: { type: String, default: "default" },
+  size: { type: String, default: "medium" },
+  closable: { type: Boolean, default: false },
+  disabled: { type: Boolean, default: false }
+};
+const TagCore = {
+  props: props$I
+};
+const props$H = {
+  value: { type: Number, default: 0 },
+  max: { type: Number, default: 100 },
+  showInfo: { type: Boolean, default: true },
+  status: { type: String, default: "default" },
+  strokeWidth: { type: Number, default: 4 }
+};
+const clearZero = (num) => {
+  const str = num.toString();
+  const index = str.indexOf(".");
+  if (index === -1) {
+    return num;
+  }
+  return str.slice(0, index + 3);
+};
+function useProgress(props2) {
+  const percentage = computed(() => clearZero(props2.value * 100 / props2.max));
+  return {
+    percentage
+  };
+}
+const ProgressCore = {
+  props: props$H,
+  useProgress
+};
+const props$G = {
+  data: { type: Array, default: () => [] },
+  autoActive: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false }
+};
+const baseRender = (item) => {
+  if (["string", "number"].includes(typeof item)) {
+    return String(item);
+  }
+  if (typeof item === "object") {
+    return JSON.stringify(item);
+  }
+  return "";
+};
+function useList() {
+  const dataValidate = (data) => {
+    if (!Array.isArray(data)) {
+      console.warn("[shuimo-list] data必须是数组");
+      return false;
+    }
+    return true;
+  };
+  return {
+    baseRender,
+    dataValidate
+  };
+}
+const ListCore = {
+  props: props$G,
+  useList
+};
+const props$F = {
+  label: { type: [String, Number], default: "" },
+  name: { type: String, default: void 0 },
+  checked: { type: Boolean, default: void 0 },
+  value: { type: [String, Number], default: "" },
+  modelValue: { type: null, default: "" }
+};
+const createRadioId = () => `m-radio-${Math.random().toString(36).substring(2)}`;
+const RadioCore = {
+  props: props$F,
+  initChecked,
+  getNewModelValue,
+  createRadioId
+};
+const props$E = {
+  active: { type: Boolean, default: false },
+  marker: { type: Boolean, default: true }
+};
+const LiCore = {
+  props: props$E
+};
+const props$D = {
+  modelValue: { type: [Number, String], default: "", required: true },
+  placeholder: { type: String, default: "" },
+  max: { type: Number, default: Infinity },
+  min: { type: Number, default: -Infinity },
+  disabled: { type: Boolean, default: false },
+  readonly: { type: Boolean, default: false },
+  step: { type: Number, default: 1 },
+  precision: { type: Number, default: 0 }
+};
+function useInputNumber(props2, ctx) {
+  const currentValue = ref(props2.modelValue);
+  const updateInput = (oldVal) => {
+    ctx.emit("update:modelValue", currentValue.value);
+    ctx.emit("change", currentValue.value, oldVal);
+  };
+  const setCurrentValue = (newVal, e) => {
+    const oldVal = currentValue.value;
+    const { min, max, precision } = props2;
+    if (oldVal === newVal) {
+      return;
+    } else if (+newVal >= +max) {
+      newVal = max;
+    } else if (+newVal <= +min) {
+      newVal = min;
+    } else if (precision !== 0 && String(newVal).includes(".") && `${newVal}`.length - (`${newVal}`.indexOf(".") + 1) >= precision) {
+      newVal = Number(`${newVal}`.substring(0, `${newVal}`.indexOf(".") + (precision + 1)));
+    }
+    if (e) {
+      e.target.value = String(newVal);
+    }
+    currentValue.value = newVal;
+    updateInput(oldVal);
+  };
+  const validate = (value, e) => {
+    if (!isNaN(+value) || value === "" || value === "-") {
+      setCurrentValue(value, e);
+    } else {
+      if (e) e.target.value = String(currentValue.value);
+    }
+  };
+  const handleInputChange = (e) => {
+    let val = e.target.value;
+    if (val.indexOf(".") === 0) {
+      val = val.replace(/^\./g, "0.");
+    }
+    if (/^-?\d+$/.test(val) && val.indexOf("0") === 0) {
+      val = `${Number(val)}`;
+      e.target.value = val;
+    }
+    validate(val, e);
+  };
+  const handleInputBlur = () => {
+    if (currentValue.value === "-") {
+      currentValue.value = "";
+    } else if (currentValue.value === "-0") {
+      currentValue.value = 0;
+    }
+    const oldVal = currentValue.value;
+    const str = String(currentValue.value);
+    currentValue.value = str.indexOf(".") === str.length - 1 ? str.replace(/\.$/g, "") : currentValue.value;
+    updateInput(oldVal);
+  };
+  const increment = () => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    const base = currentValue.value === "" ? 0 : +currentValue.value;
+    const next = base + props2.step;
+    validate(next);
+  };
+  const decrement = () => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    const base = currentValue.value === "" ? 0 : +currentValue.value;
+    const next = base - props2.step;
+    validate(next);
+  };
+  const handleKeydown = (e) => {
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      increment();
+    } else if (e.key === "ArrowDown") {
+      e.preventDefault();
+      decrement();
+    }
+  };
+  watch(() => props2.modelValue, (val) => {
+    validate(val);
+  });
+  return {
+    currentValue,
+    handleInputChange,
+    handleInputBlur,
+    handleKeydown,
+    increment,
+    decrement,
+    validate
+  };
+}
+const InputNumberCore = {
+  props: props$D,
+  useInputNumber
+};
+const props$C = {
+  modelValue: { type: Number, default: 0 },
+  min: { type: Number, default: 0 },
+  max: { type: Number, default: 100 },
+  step: { type: Number, default: 1 },
+  disabled: { type: Boolean, default: false },
+  showInfo: { type: Boolean, default: false },
+  showStops: { type: Boolean, default: false }
+};
+function useResizeObserver(target, callback, options = {}) {
+  let observer;
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  watch(target, () => {
+    if (target.value) {
+      cleanup();
+      observer = new ResizeObserver(callback);
+      observer.observe(target.value, options);
+    }
+  });
+  return {
+    cleanup
+  };
+}
+function useElementSize(target) {
+  const w = ref(0);
+  const h = ref(0);
+  useResizeObserver(target, () => {
+    const ele = target.value;
+    if (window && ele) {
+      const styles = window.getComputedStyle(ele);
+      w.value = Number.parseFloat(styles.width);
+      h.value = Number.parseFloat(styles.height);
+    }
+  });
+  return {
+    w,
+    h
+  };
+}
+const interactjs = _interactjsModule.default ?? _interactjsModule;
+function useDrag(config) {
+  var _a;
+  const domRef = ((_a = config.value) == null ? void 0 : _a.domRef) ?? ref();
+  const init = (basePosition) => {
+    var _a2, _b;
+    if (!domRef.value) {
+      return;
+    }
+    const position = { x: (basePosition == null ? void 0 : basePosition.x) ?? 0, y: (basePosition == null ? void 0 : basePosition.y) ?? 0 };
+    return interactjs(domRef.value).styleCursor(false).draggable({
+      ...(_b = (_a2 = config.event) == null ? void 0 : _a2.getOption) == null ? void 0 : _b.call(_a2),
+      listeners: {
+        end: (event2) => {
+          var _a3, _b2;
+          (_b2 = (_a3 = config.event) == null ? void 0 : _a3.onDragLeave) == null ? void 0 : _b2.call(_a3, event2);
+        },
+        move: (event2) => {
+          var _a3, _b2;
+          const { x, y } = ((_b2 = (_a3 = config.event) == null ? void 0 : _a3.movePositionHandler) == null ? void 0 : _b2.call(_a3, event2, position)) ?? {
+            x: position.x + event2.dx,
+            y: position.y + event2.dy
+          };
+          position.x = x;
+          position.y = y;
+          event2.target.style.transform = `translate(${position.x}px, ${position.y}px)`;
+        }
+      }
+    });
+  };
+  return {
+    domRef,
+    init
+  };
+}
+function useSlider(props2, ctx) {
+  const sliderRef = ref(null);
+  const sliderSize = useElementSize(sliderRef);
+  const perRef = ref(0);
+  const option = { startAxis: "x", lockAxis: "x" };
+  const btnW = 20;
+  const sub = props2.max - props2.min;
+  const movePositionHandler = (event2, position) => {
+    const totalW = sliderSize.w.value - btnW;
+    let positionX = position.x + event2.dx;
+    if (positionX > totalW) {
+      positionX = totalW;
+    } else if (positionX < 0) {
+      positionX = 0;
+    }
+    perRef.value = positionX / totalW;
+    ctx.emit("update:modelValue", getValue());
+    return { x: positionX > 0 ? positionX : 0, y: 0 };
+  };
+  const getValue = () => {
+    const addStep = Math.round(perRef.value * sub / props2.step) * props2.step;
+    return props2.min + addStep;
+  };
+  const { init: initDrag, domRef: btnRef } = useDrag({
+    event: {
+      getOption: () => option,
+      movePositionHandler
+    }
+  });
+  const init = () => {
+    if (btnRef.value) {
+      const { max, min, modelValue } = props2;
+      const per = (modelValue - min) / (max - min);
+      if (window && sliderRef.value) {
+        const w = Number.parseFloat(window.getComputedStyle(sliderRef.value).width);
+        const totalW = w - btnW;
+        perRef.value = per;
+        const x = per * totalW;
+        btnRef.value.style.transform = `translate(${x}px, 0)`;
+        initDrag({ x });
+      }
+    }
+  };
+  onMounted(() => {
+    init();
+  });
+  return {
+    btnRef,
+    sliderRef,
+    perRef
+  };
+}
+const SliderCore = {
+  props: props$C,
+  useSlider
+};
+const messageProps = {
+  content: { type: String, required: true },
+  type: { type: String, default: "info" },
+  duration: { type: Number, default: 3e3 },
+  direction: { type: String, default: "top-right" }
+};
+const messageListProps = {
+  direction: { type: String, default: "top-right" }
+};
+function useMessageQueue() {
+  const messages = ref([]);
+  let nextId = 0;
+  const add = (props2) => {
+    const id = nextId++;
+    const item = {
+      id,
+      type: props2.type ?? "info",
+      content: props2.content,
+      duration: props2.duration ?? 3e3
+    };
+    messages.value.push(item);
+    if (item.duration > 0) {
+      setTimeout(() => remove(id), item.duration);
+    }
+    return id;
+  };
+  const remove = (id) => {
+    const idx = messages.value.findIndex((m) => m.id === id);
+    if (idx !== -1) {
+      messages.value.splice(idx, 1);
+    }
+  };
+  return { messages, add, remove };
+}
+const MessageCore = {
+  messageProps,
+  messageListProps,
+  useMessageQueue
+};
+const formProps = {
+  inline: { type: Boolean, default: false },
+  submit: { type: Boolean, default: false },
+  model: { type: Object, default: void 0 },
+  labelWidth: { type: String, default: void 0 }
+};
+const formItemProps = {
+  label: { type: String, default: "" },
+  prop: { type: String, default: "" },
+  required: { type: Boolean, default: false }
+};
+const FormCore = {
+  props: formProps,
+  formItemProps
+};
+const props$B = {
+  placement: {
+    type: String,
+    default: "bottom"
+  },
+  mountRender: { type: Boolean, default: false },
+  disableClickAway: { type: Boolean, default: false },
+  hover: { type: Boolean, default: false },
+  show: { type: Boolean, default: null },
+  content: { type: String, default: "" },
+  popper: {
+    type: Object,
+    default: () => ({})
+  },
+  teleport: { type: [Object, Boolean], default: void 0 },
+  title: { type: String, default: void 0 }
+};
+const usePopper = (triggerNode, popperNode, update, arrowNode, config) => {
+  const getPositionStyle = async () => {
+    var _a, _b;
+    if (arrowNode && (config == null ? void 0 : config.middleware)) {
+      config.middleware.push(arrow({ element: arrowNode }));
+    }
+    const { x, y, placement, middlewareData } = await computePosition(triggerNode, popperNode, config);
+    const res = {
+      style: {
+        left: `${x}px`,
+        top: `${y}px`,
+        display: "block",
+        position: "absolute"
+      },
+      arrowStyle: {
+        left: `${((_a = middlewareData.arrow) == null ? void 0 : _a.x) ?? 0}px`,
+        top: `${((_b = middlewareData.arrow) == null ? void 0 : _b.y) ?? 0}px`,
+        display: "block",
+        position: "absolute"
+      },
+      placement
+    };
+    update(res);
+    return res;
+  };
+  const clear = autoUpdate(triggerNode, popperNode, getPositionStyle);
+  return {
+    getPositionStyle,
+    clear
+  };
+};
+function useEventListener(options) {
+  const getTarget = () => {
+    if (typeof options.target === "function") {
+      return options.target();
+    }
+    return options.target;
+  };
+  const add = () => {
+    getTarget().addEventListener(options.event, options.handler);
+  };
+  const remove = () => {
+    getTarget().removeEventListener(options.event, options.handler);
+  };
+  const onMounted2 = () => {
+    add();
+  };
+  const onBeforeDestroy = () => {
+    remove();
+  };
+  return {
+    add,
+    remove,
+    onMounted: onMounted2,
+    onBeforeDestroy
+  };
+}
+const event = "pointerdown";
+function useClickAway(options) {
+  if (typeof window === "undefined" || !window) {
+    return;
+  }
+  const listener = (event2) => {
+    const el = typeof options.target === "function" ? options.target() : options.target;
+    if (!el) {
+      return;
+    }
+    if (el === event2.target || event2.composedPath().includes(el)) {
+      return;
+    }
+    options.handler(event2);
+  };
+  return useEventListener({
+    target: window,
+    event,
+    handler: listener
+  });
+}
+let PopoverImpl$1 = class PopoverImpl {
+  constructor(val, active, content, arrow2, config, lifecycle) {
+    __publicField(this, "_active");
+    __publicField(this, "_content");
+    __publicField(this, "_arrow");
+    __publicField(this, "popperInstance");
+    __publicField(this, "style");
+    __publicField(this, "arrowStyle");
+    __publicField(this, "placement");
+    __publicField(this, "visible", false);
+    __publicField(this, "onShow");
+    __publicField(this, "onHide");
+    if (!content) {
+      throw new Error("MPopover: content is required");
+    }
+    if (!active) {
+      throw new Error("MPopover: active is required");
+    }
+    this._active = active;
+    this._content = content;
+    this._arrow = arrow2;
+    this.popperInstance = usePopper(
+      this._active,
+      this._content,
+      (positionStyle) => this.update(positionStyle),
+      this._arrow,
+      config
+    );
+    this.style = val.style;
+    this.arrowStyle = val.arrowStyle;
+    this.placement = val.placement;
+    this.visible = val.show;
+    this.onShow = lifecycle == null ? void 0 : lifecycle.onShow;
+    this.onHide = lifecycle == null ? void 0 : lifecycle.onHide;
+  }
+  get content() {
+    return this._content;
+  }
+  async show() {
+    var _a;
+    this.style.value = { display: "block", opacity: "0" };
+    this.arrowStyle.value = { display: "block", opacity: "0" };
+    this.visible = true;
+    await this.popperInstance.getPositionStyle();
+    (_a = this.onShow) == null ? void 0 : _a.call(this);
+  }
+  update(positionStyle) {
+    if (!this.visible) {
+      this.hide();
+      return;
+    }
+    this.style.value = positionStyle.style;
+    this.arrowStyle.value = positionStyle.arrowStyle;
+    this.placement.value = positionStyle.placement;
+  }
+  hide() {
+    var _a;
+    this.style.value = void 0;
+    this.arrowStyle.value = void 0;
+    this.visible = false;
+    (_a = this.onHide) == null ? void 0 : _a.call(this);
+  }
+  async toggle() {
+    if (this.visible) {
+      this.hide();
+    } else {
+      await this.show();
+    }
+  }
+  destroy() {
+  }
+};
+function usePopover$1(props2, ctx) {
+  const style = ref();
+  const arrowStyle = ref();
+  const placement = ref(props2.placement);
+  let instance = null;
+  let clickAwayInstance;
+  const popperInstance = shallowRef();
+  const popoverRef = ref();
+  const contentRef = ref();
+  const arrowRef = ref();
+  const createPopover = (active, content, arrow2, config) => {
+    instance = new PopoverImpl$1(
+      { style, arrowStyle, placement, show: props2.show },
+      active,
+      content,
+      arrow2,
+      config,
+      {
+        onShow: () => {
+          clickAwayInstance == null ? void 0 : clickAwayInstance.add();
+          ctx.emit("update:show", true);
+        },
+        onHide: () => {
+          clickAwayInstance == null ? void 0 : clickAwayInstance.remove();
+          ctx.emit("update:show", false);
+        }
+      }
+    );
+    return instance;
+  };
+  const popoverEnter = () => {
+    if (props2.hover) {
+      instance == null ? void 0 : instance.show();
+    }
+  };
+  const popoverLeave = () => {
+    if (props2.hover) {
+      instance == null ? void 0 : instance.hide();
+    }
+  };
+  onMounted(() => {
+    if (!popoverRef.value || !contentRef.value) {
+      return;
+    }
+    popperInstance.value = createPopover(popoverRef.value, contentRef.value, arrowRef.value, {
+      ...props2.popper,
+      placement: props2.placement
+    });
+    if (props2.disableClickAway) {
+      return;
+    }
+    clickAwayInstance = useClickAway({
+      target: () => {
+        var _a;
+        return (_a = instance == null ? void 0 : instance.content) == null ? void 0 : _a.parentElement;
+      },
+      handler: () => {
+        instance == null ? void 0 : instance.hide();
+      }
+    });
+  });
+  onBeforeMount(() => {
+    if (clickAwayInstance) {
+      const { onBeforeDestroy } = clickAwayInstance;
+      onBeforeDestroy();
+    }
+  });
+  return {
+    popoverEnter,
+    popoverLeave,
+    popoverRef,
+    contentRef,
+    arrowRef,
+    popperInstance,
+    style,
+    arrowStyle,
+    placement
+  };
+}
+const PopoverCore = {
+  props: props$B,
+  usePopover: usePopover$1
+};
+const props$A = {
+  content: { type: String, default: "" },
+  placement: {
+    type: String,
+    default: "top"
+  },
+  disabled: { type: Boolean, default: false }
+};
+function calcPosition(rect, tooltipEl, placement) {
+  const gap = 8;
+  const tooltipRect = tooltipEl.getBoundingClientRect();
+  let left = 0;
+  let top = 0;
+  switch (placement) {
+    case "top":
+      left = rect.left + rect.width / 2 - tooltipRect.width / 2;
+      top = rect.top - tooltipRect.height - gap;
+      break;
+    case "bottom":
+      left = rect.left + rect.width / 2 - tooltipRect.width / 2;
+      top = rect.bottom + gap;
+      break;
+    case "left":
+      left = rect.left - tooltipRect.width - gap;
+      top = rect.top + rect.height / 2 - tooltipRect.height / 2;
+      break;
+    case "right":
+      left = rect.right + gap;
+      top = rect.top + rect.height / 2 - tooltipRect.height / 2;
+      break;
+  }
+  return {
+    position: "fixed",
+    left: `${left}px`,
+    top: `${top}px`,
+    zIndex: "9999"
+  };
+}
+function useTooltip(props2) {
+  const visible = ref(false);
+  const tooltipStyle = ref({});
+  const triggerRef2 = ref(null);
+  const tooltipRef = ref(null);
+  const show = async () => {
+    if (props2.disabled) return;
+    visible.value = true;
+    await nextTick();
+    if (!triggerRef2.value || !tooltipRef.value) return;
+    const rect = triggerRef2.value.getBoundingClientRect();
+    tooltipStyle.value = calcPosition(rect, tooltipRef.value, props2.placement);
+  };
+  const hide = () => {
+    visible.value = false;
+    tooltipStyle.value = {};
+  };
+  return {
+    visible,
+    tooltipStyle,
+    triggerRef: triggerRef2,
+    tooltipRef,
+    show,
+    hide
+  };
+}
+const TooltipCore = {
+  props: props$A,
+  useTooltip
+};
+const props$z = {
+  vertical: { type: Boolean, default: false },
+  align: { type: String, default: "center" }
+};
+const DividerCore = {
+  props: props$z
+};
+const props$y = {
+  modelValue: { type: Boolean, default: false },
+  size: { type: String, default: "medium" },
+  mask: { type: Boolean, default: false },
+  text: { type: String, default: void 0 }
+};
+const LoadingCore = {
+  props: props$y
+};
+const props$x = {
+  visible: { type: Boolean, default: false },
+  mask: { type: Object, default: () => ({ show: true, clickClose: true }) },
+  closeBtn: { type: Boolean, default: true },
+  teleport: { type: Object, default: () => ({ to: "body" }) },
+  title: { type: String, default: void 0 },
+  width: { type: String, default: void 0 }
+};
+const DialogCore = {
+  props: props$x
+};
+const props$w = {
+  visible: { type: Boolean, default: false },
+  mask: {
+    type: Object,
+    default: () => ({ show: true, clickClose: true })
+  },
+  drawerClass: { type: Array, default: () => [] },
+  direction: {
+    type: String,
+    default: "right"
+  },
+  teleport: {
+    type: Object,
+    default: () => ({ to: "body" })
+  },
+  title: { type: String, default: void 0 },
+  width: { type: String, default: void 0 },
+  height: { type: String, default: void 0 }
+};
+const DrawerCore = {
+  props: props$w
+};
+const props$v = {
+  visible: { type: Boolean, default: false },
+  mask: { type: Object, default: () => ({ show: true, clickClose: false }) },
+  teleport: { type: Object, default: () => ({ to: "body" }) },
+  content: { type: String, default: "" },
+  confirmText: { type: String, default: "确定" },
+  cancelText: { type: String, default: "取消" },
+  title: { type: String, default: void 0 },
+  loading: { type: Boolean, default: false }
+};
+const ConfirmCore = {
+  props: props$v
+};
+const props$u = {
+  modelValue: { type: Boolean, default: false },
+  autoMode: { type: Boolean, default: false },
+  initHandler: { type: Function, default: void 0 },
+  storageKey: { type: String, default: void 0 }
+};
+function applyDarkAttr(isDark) {
+  if (typeof document === "undefined") return;
+  const html = document.querySelector("html");
+  if (!html) return;
+  if (isDark) {
+    html.setAttribute("dark", "");
+  } else {
+    html.removeAttribute("dark");
+  }
+}
+function readStorage(storageKey) {
+  if (typeof window === "undefined") return null;
+  const stored = localStorage.getItem(storageKey);
+  if (stored === null) return null;
+  return stored === "true";
+}
+function writeStorage(storageKey, isDark) {
+  if (typeof window === "undefined") return;
+  localStorage.setItem(storageKey, isDark.toString());
+}
+function useDarkMode(props2, ctx) {
+  const isDark = ref(props2.modelValue ?? false);
+  const toggle = () => {
+    isDark.value = !isDark.value;
+    ctx.emit("update:modelValue", isDark.value);
+    ctx.emit("change", isDark.value);
+  };
+  watch(
+    () => props2.modelValue,
+    (val) => {
+      if (val !== void 0 && val !== isDark.value) {
+        isDark.value = val;
+      }
+    }
+  );
+  watch(isDark, (val) => {
+    applyDarkAttr(val);
+    if (props2.storageKey) {
+      writeStorage(props2.storageKey, val);
+    }
+  });
+  let mediaQuery = null;
+  const onSystemChange = (event2) => {
+    isDark.value = event2.matches;
+    ctx.emit("update:modelValue", isDark.value);
+    ctx.emit("change", isDark.value);
+  };
+  onMounted(() => {
+    if (props2.initHandler) {
+      const shouldAutoInit = props2.initHandler();
+      if (!shouldAutoInit) {
+        applyDarkAttr(isDark.value);
+        return;
+      }
+    } else if (props2.storageKey) {
+      const stored = readStorage(props2.storageKey);
+      if (stored !== null) {
+        isDark.value = stored;
+        applyDarkAttr(isDark.value);
+        return;
+      }
+    }
+    if (props2.autoMode && typeof window !== "undefined") {
+      mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      isDark.value = mediaQuery.matches;
+      ctx.emit("update:modelValue", isDark.value);
+      ctx.emit("change", isDark.value);
+      mediaQuery.addEventListener("change", onSystemChange);
+    }
+    applyDarkAttr(isDark.value);
+  });
+  onUnmounted(() => {
+    if (mediaQuery) {
+      mediaQuery.removeEventListener("change", onSystemChange);
+      mediaQuery = null;
+    }
+  });
+  return {
+    isDark,
+    toggle,
+    applyDarkAttr
+  };
+}
+const DarkModeCore = {
+  props: props$u,
+  useDarkMode
+};
+const props$t = {
+  separator: { type: String, default: "/" },
+  items: { type: Array, default: () => [] }
+};
+const BreadcrumbCore = {
+  props: props$t
+};
+const props$s = {
+  h: { type: Number, default: void 0 },
+  w: { type: Number, default: void 0 },
+  gap: { type: [Number, String], default: 0 },
+  colGap: { type: [Number, String], default: void 0 },
+  rowGap: { type: [Number, String], default: void 0 },
+  direction: { type: String, default: "row" },
+  cols: { type: Number, default: void 0 }
+};
+const GridCore = {
+  props: props$s
+};
+const props$r = {
+  total: { type: Number, default: 0 },
+  modelValue: { type: Number, default: void 0 },
+  defaultCurrent: { type: Number, default: 1 },
+  pageSize: { type: Number, default: 10 },
+  pageSizes: { type: Array, default: () => [10, 20, 30, 40, 50, 100] },
+  layout: { type: String, default: "prev, pager, next, total" },
+  foldedMaxPageBtn: { type: Number, default: 5 },
+  maxPageBtn: { type: Number, default: 10 },
+  showEdgePageNum: { type: Boolean, default: true }
+};
+const oddNum = (num) => {
+  return num % 2 === 0 ? num + 1 : num;
+};
+function usePagination(props2, currentValue) {
+  const getPageBtnLength = () => {
+    const total = props2.total ?? 0;
+    const pageSize = props2.pageSize ?? 10;
+    return Math.ceil(total / pageSize);
+  };
+  const toPager = (value, config) => {
+    return {
+      value,
+      type: (config == null ? void 0 : config.type) ?? "number",
+      isCurrent: currentValue.value === value,
+      jump: (config == null ? void 0 : config.jump) ?? value
+    };
+  };
+  const toFoldedPager = (jump) => {
+    return toPager("...", { type: "folded", jump });
+  };
+  const getPageNumListRange = (start, length) => {
+    return Array.from({ length }, (_, i) => toPager(i + start));
+  };
+  const getPageNumList = () => {
+    const pageBtnLength = getPageBtnLength();
+    const total = props2.total ?? 0;
+    const pageSize = props2.pageSize ?? 10;
+    const foldedMaxPageBtn = props2.foldedMaxPageBtn ?? 5;
+    const maxPageBtn = props2.maxPageBtn ?? 10;
+    const showEdgePageNum = props2.showEdgePageNum ?? true;
+    if (total <= pageSize) {
+      return [toPager(1)];
+    }
+    if (!maxPageBtn || pageBtnLength <= maxPageBtn || foldedMaxPageBtn && foldedMaxPageBtn >= pageBtnLength - 1) {
+      return getPageNumListRange(1, pageBtnLength);
+    }
+    const foldedMaxPageBtnOdd = Math.max(oddNum(foldedMaxPageBtn ?? 5), 1);
+    const edgeConfig = {
+      // showEdgePageNum 时首尾各占 1 个槽位
+      length: showEdgePageNum ? 1 : 0,
+      // 右侧起始位置的偏移修正
+      rightStartSub: showEdgePageNum ? 0 : 1
+    };
+    const btnNumWithoutEdge = foldedMaxPageBtnOdd - (showEdgePageNum ? 2 : 0);
+    const pageEdge = (btnNumWithoutEdge - 1) / 2;
+    const leftEdgeNum = pageEdge + 2;
+    const rightEdgeNum = pageBtnLength - pageEdge - 1;
+    const rightStart = pageBtnLength - foldedMaxPageBtnOdd + 2 - edgeConfig.rightStartSub;
+    if (currentValue.value <= leftEdgeNum) {
+      const numLength = foldedMaxPageBtnOdd - edgeConfig.length;
+      const res2 = [
+        ...getPageNumListRange(1, numLength),
+        toFoldedPager(1 + numLength)
+      ];
+      if (showEdgePageNum) {
+        res2.push(toPager(pageBtnLength));
+      }
+      return res2;
+    }
+    if (currentValue.value >= rightEdgeNum) {
+      const res2 = [];
+      if (showEdgePageNum) {
+        res2.push(toPager(1));
+      }
+      res2.push(toFoldedPager(rightStart - 1), ...getPageNumListRange(rightStart, foldedMaxPageBtnOdd - edgeConfig.length));
+      return res2;
+    }
+    const leftStart = currentValue.value - pageEdge;
+    const rightEnd = currentValue.value + pageEdge;
+    const leftFolded = Math.abs(leftStart - 1) > 2 || !showEdgePageNum ? toFoldedPager(leftStart - 1) : toPager(showEdgePageNum ? 2 : 1);
+    const rightFolded = Math.abs(rightEnd - pageBtnLength) > 2 || !showEdgePageNum ? toFoldedPager(rightEnd + 1) : toPager(showEdgePageNum ? pageBtnLength - 1 : pageBtnLength);
+    const res = [];
+    if (showEdgePageNum) {
+      res.push(toPager(1));
+    }
+    res.push(
+      leftFolded,
+      ...getPageNumListRange(leftStart, foldedMaxPageBtnOdd - edgeConfig.length * 2),
+      rightFolded
+    );
+    if (showEdgePageNum) {
+      res.push(toPager(pageBtnLength));
+    }
+    return res;
+  };
+  return {
+    getPageNumList,
+    getPageBtnLength
+  };
+}
+const PaginationCore = {
+  props: props$r,
+  usePagination
+};
+const DEFAULT_MENU_CONFIG = {
+  key: "key",
+  label: "label",
+  children: "children"
+};
+const props$q = {
+  data: { type: Array, default: () => [] },
+  config: { type: Object, default: () => ({ ...DEFAULT_MENU_CONFIG }) },
+  checkbox: { type: Boolean, default: false },
+  defaultExpandAll: { type: Boolean, default: false },
+  checkedKeys: { type: Array, default: () => [] },
+  mode: { type: String, default: "vertical" },
+  active: { type: [String, Number], default: void 0 }
+};
+const DEFAULT_CONFIG$1 = { key: "key", label: "label", children: "children" };
+function buildNodes(data, config, nodeMap, defaultExpandAll = false, parent) {
+  return data.map((item) => {
+    const key = item[config.key];
+    const childrenKey = config.children;
+    const node = {
+      ...item,
+      expand: defaultExpandAll,
+      isActive: false,
+      checked: false,
+      indeterminate: false,
+      parent,
+      isRoot: !parent
+    };
+    nodeMap.set(key, node);
+    const rawChildren = item[childrenKey];
+    if (Array.isArray(rawChildren) && rawChildren.length > 0) {
+      node.children = buildNodes(
+        rawChildren,
+        config,
+        nodeMap,
+        defaultExpandAll,
+        node
+      );
+    }
+    return node;
+  });
+}
+function useMenu(props2, emit) {
+  const config = { ...DEFAULT_CONFIG$1, ...props2.config };
+  const nodeMap = /* @__PURE__ */ new Map();
+  const nodesRef = shallowRef([]);
+  const initNodes = (data = []) => {
+    var _a;
+    nodeMap.clear();
+    nodesRef.value = buildNodes(data, config, nodeMap, props2.defaultExpandAll ?? false, null);
+    if ((_a = props2.checkedKeys) == null ? void 0 : _a.length) {
+      props2.checkedKeys.forEach((key) => {
+        const node = nodeMap.get(key);
+        if (node) {
+          node.checked = true;
+        }
+      });
+    }
+    triggerRef(nodesRef);
+  };
+  initNodes(props2.data ?? []);
+  if (props2.active !== void 0) {
+    const activeNode = nodeMap.get(props2.active);
+    if (activeNode) {
+      activeNode.isActive = true;
+    }
+  }
+  const toggleExpand = (node) => {
+    node.expand = !node.expand;
+    triggerRef(nodesRef);
+  };
+  const setActive = (node) => {
+    nodeMap.forEach((n) => {
+      n.isActive = false;
+    });
+    node.isActive = true;
+    triggerRef(nodesRef);
+    if (emit) {
+      const key = node[config.key];
+      emit("update:active", key);
+    }
+  };
+  const toggleChecked = (node, checked) => {
+    node.checked = checked;
+    node.indeterminate = false;
+    triggerRef(nodesRef);
+  };
+  const getCheckedKeys = () => {
+    const keys = [];
+    nodeMap.forEach((node, key) => {
+      if (node.checked && !node.indeterminate) {
+        keys.push(key);
+      }
+    });
+    return keys;
+  };
+  const getNodesByKeys = (keys) => {
+    return keys.map((key) => nodeMap.get(key)).filter((n) => n !== void 0);
+  };
+  return {
+    nodesRef,
+    nodeMap,
+    initNodes,
+    toggleExpand,
+    setActive,
+    toggleChecked,
+    getCheckedKeys,
+    getNodesByKeys,
+    config
+  };
+}
+const MenuCore = {
+  props: props$q,
+  useMenu
+};
+const props$p = {
+  modelValue: { type: [String, Date], default: "" },
+  placeholder: { type: String, default: "请选择日期..." },
+  format: { type: String, default: void 0 },
+  type: { type: String, default: "date" },
+  disabled: { type: Boolean, default: false }
+};
+const BASE_WEEK_NAME = [
+  { day: "日", isCurrentMonth: true },
+  { day: "壹", isCurrentMonth: true },
+  { day: "贰", isCurrentMonth: true },
+  { day: "叁", isCurrentMonth: true },
+  { day: "肆", isCurrentMonth: true },
+  { day: "伍", isCurrentMonth: true },
+  { day: "陆", isCurrentMonth: true }
+];
+const BASE_MONTH_NAME = [
+  "1月",
+  "2月",
+  "3月",
+  "4月",
+  "5月",
+  "6月",
+  "7月",
+  "8月",
+  "9月",
+  "10月",
+  "11月",
+  "12月"
+];
+const toDayjs = (value) => {
+  return dayjs(value);
+};
+const isEmpty = (value) => {
+  return value === "" || value === null || value === void 0;
+};
+const generateTimeColumn = (max, step) => {
+  const result = [];
+  for (let i = 0; i < max; i += step) {
+    result.push(i);
+  }
+  return result;
+};
+function useDatePicker(props2) {
+  const today = dayjs();
+  const dateRef = ref({
+    year: today.year(),
+    month: today.month() + 1,
+    day: today.date()
+  });
+  const displayValue = ref("");
+  const spanClass = ref([]);
+  const currentRef = ref(toDayjs(props2.modelValue));
+  const calendarTypeRef = ref(
+    props2.type === "datetime" ? "date" : props2.type ?? "date"
+  );
+  const yearsRef = ref([]);
+  let needPlaceholder = false;
+  const format = computed(() => {
+    if (props2.format) return props2.format;
+    switch (props2.type) {
+      case "month":
+        return "YYYY-MM";
+      case "datetime":
+        return "YYYY-MM-DD HH:mm:ss";
+      case "date":
+      default:
+        return "YYYY-MM-DD";
+    }
+  });
+  const timeRef = ref({ hours: 0, minutes: 0, seconds: 0 });
+  const updateDateRef = (value) => {
+    if (isEmpty(value)) {
+      displayValue.value = props2.placeholder ?? "请选择日期...";
+      needPlaceholder = true;
+    } else {
+      needPlaceholder = false;
+      const dayjsValue = dayjs(value);
+      if (dayjsValue.isValid()) {
+        displayValue.value = dayjsValue.format(format.value).toString();
+        dateRef.value = {
+          year: dayjsValue.year(),
+          month: dayjsValue.month() + 1,
+          day: dayjsValue.date()
+        };
+        if (props2.type === "datetime") {
+          timeRef.value = {
+            hours: dayjsValue.hour(),
+            minutes: dayjsValue.minute(),
+            seconds: dayjsValue.second()
+          };
+        }
+      }
+    }
+    spanClass.value = [
+      "m-date-picker-span",
+      needPlaceholder ? "m-date-picker-placeholder" : void 0
+    ];
+  };
+  updateDateRef(props2.modelValue);
+  const getCalendar = (MDateRefValue) => {
+    const dr = MDateRefValue.value;
+    const monthDayjs = dayjs().set("year", dr.year).set("month", dr.month - 1);
+    const dateDayjs = monthDayjs.set("date", dr.day);
+    const firstDayWeek = dateDayjs.startOf("month");
+    const firstDayWeekDay = firstDayWeek.day();
+    const prevDaysYear = dr.month === 1 ? dr.year - 1 : dr.year;
+    const lastMonthDayjs = dateDayjs.subtract(1, "month");
+    const lastMonth = lastMonthDayjs.month() + 1;
+    const prevDays = Array.from({ length: firstDayWeekDay }, (_, i) => {
+      const day = firstDayWeek.subtract(firstDayWeekDay - i, "day").date();
+      return { day, isCurrentMonth: false, month: lastMonth, year: prevDaysYear };
+    });
+    const isCurrent = (dayNum) => {
+      if (dr.year !== currentRef.value.year()) return false;
+      if (dr.month !== currentRef.value.month() + 1) return false;
+      return dayNum === currentRef.value.date();
+    };
+    const currentDays = Array.from({ length: monthDayjs.daysInMonth() }, (_, i) => ({
+      day: i + 1,
+      isCurrentMonth: true,
+      isCurrent: isCurrent(i + 1),
+      month: dr.month,
+      year: dr.year
+    }));
+    const nextDaysYear = dr.month === 12 ? dr.year + 1 : dr.year;
+    const lastDayOfMonth = dayjs(`${dr.year}-${dr.month}`).daysInMonth();
+    const lastDayWeekDay = dayjs(`${dr.year}-${dr.month}-${lastDayOfMonth}`).day();
+    const nextDays = Array.from({ length: 6 - lastDayWeekDay }, (_, i) => ({
+      day: i + 1,
+      isCurrentMonth: false,
+      month: dr.month === 12 ? 1 : dr.month + 1,
+      year: nextDaysYear
+    }));
+    if (prevDays.length + currentDays.length + nextDays.length < 42) {
+      if (firstDayWeekDay === 0) {
+        const lastMonthDays = lastMonthDayjs.daysInMonth();
+        prevDays.unshift(...Array.from({ length: 7 }, (_, i) => ({
+          day: lastMonthDays - 6 + i,
+          isCurrentMonth: false,
+          month: lastMonth,
+          year: prevDaysYear
+        })));
+      } else {
+        const nextMonth = dateDayjs.add(1, "month");
+        const nextMonthFirstDayWeek = nextMonth.set("date", 1).day();
+        const baseDay = nextMonthFirstDayWeek === 0 ? 0 : 6 - nextMonthFirstDayWeek;
+        nextDays.push(...Array.from({ length: 7 }, (_, i) => ({
+          day: i + baseDay + 1,
+          isCurrentMonth: false,
+          month: dr.month === 12 ? 1 : dr.month + 1,
+          year: nextDaysYear
+        })));
+      }
+    }
+    const allDays = [...prevDays, ...currentDays, ...nextDays];
+    const result = [];
+    for (let i = 0; i < allDays.length; i += 7) {
+      result.push(allDays.slice(i, i + 7));
+    }
+    return result;
+  };
+  const toPrevMonth = () => {
+    if (!dateRef.value) return;
+    dateRef.value.month -= 1;
+    if (dateRef.value.month === 0) {
+      dateRef.value.month = 12;
+      dateRef.value.year -= 1;
+    }
+  };
+  const toNextMonth = () => {
+    if (!dateRef.value) return;
+    dateRef.value.month += 1;
+    if (dateRef.value.month === 13) {
+      dateRef.value.month = 1;
+      dateRef.value.year += 1;
+    }
+  };
+  const toNextYear = () => {
+    if (!dateRef.value) return;
+    dateRef.value.year += 1;
+    if (calendarTypeRef.value === "year") {
+      if (!yearsRef.value.includes(dateRef.value.year)) {
+        const startYear = dateRef.value.year;
+        yearsRef.value = Array.from({ length: 12 }, (_, i) => startYear + i);
+      }
+    }
+  };
+  const toPrevYear = () => {
+    if (!dateRef.value) return;
+    dateRef.value.year -= 1;
+    if (calendarTypeRef.value === "year") {
+      if (!yearsRef.value.includes(dateRef.value.year)) {
+        const startYear = dateRef.value.year - 11;
+        yearsRef.value = Array.from({ length: 12 }, (_, i) => startYear + i);
+      }
+    }
+  };
+  const getValue = (item) => {
+    let d = dayjs().set("year", item.year).set("month", item.month - 1).set("date", Number(item.day));
+    if (props2.type === "datetime") {
+      d = d.set("hour", timeRef.value.hours).set("minute", timeRef.value.minutes).set("second", timeRef.value.seconds);
+    }
+    return d.format(format.value);
+  };
+  const getDateTimeValue = () => {
+    return dayjs().set("year", dateRef.value.year).set("month", dateRef.value.month - 1).set("date", dateRef.value.day).set("hour", timeRef.value.hours).set("minute", timeRef.value.minutes).set("second", timeRef.value.seconds).format(format.value);
+  };
+  const selectHour = (hour) => {
+    timeRef.value = { ...timeRef.value, hours: hour };
+  };
+  const selectMinute = (minute) => {
+    timeRef.value = { ...timeRef.value, minutes: minute };
+  };
+  const selectSecond = (second) => {
+    timeRef.value = { ...timeRef.value, seconds: second };
+  };
+  const clickCurrentYear = (year) => {
+    calendarTypeRef.value = "year";
+    const startYear = year - 6;
+    const endYear = year + 5;
+    yearsRef.value = Array.from({ length: endYear - startYear + 1 }, (_, i) => startYear + i);
+  };
+  const clickYearItem = (year) => {
+    if (!dateRef.value) return;
+    dateRef.value.year = year;
+    if (props2.type === "date" || props2.type === "datetime") calendarTypeRef.value = "date";
+    else if (props2.type === "month") calendarTypeRef.value = "month";
+  };
+  const clickCurrentMonth = (_month) => {
+    calendarTypeRef.value = "month";
+  };
+  const clickMonthItem = (month) => {
+    dateRef.value.month = month;
+    if (props2.type === "date" || props2.type === "datetime") calendarTypeRef.value = "date";
+  };
+  return {
+    // 状态
+    dateRef,
+    displayValue,
+    spanClass,
+    currentRef,
+    calendarTypeRef,
+    yearsRef,
+    // datetime 时间状态
+    timeRef,
+    // 方法
+    updateDateRef,
+    getCalendar,
+    toPrevMonth,
+    toNextMonth,
+    toPrevYear,
+    toNextYear,
+    getValue,
+    getDateTimeValue,
+    clickCurrentYear,
+    clickYearItem,
+    clickCurrentMonth,
+    clickMonthItem,
+    // datetime 时间选择方法
+    selectHour,
+    selectMinute,
+    selectSecond,
+    // 工具
+    toDayjs
+  };
+}
+const DatePickerCore = {
+  props: props$p,
+  useDatePicker
+};
+const DEFAULT_CONFIG = {
+  key: "key",
+  label: "label",
+  value: "value",
+  children: "children",
+  expand: "expand"
+};
+const mergeConfig = (config) => {
+  if (config === DEFAULT_CONFIG) {
+    return DEFAULT_CONFIG;
+  }
+  return {
+    key: config.key ?? DEFAULT_CONFIG.key,
+    label: config.label ?? DEFAULT_CONFIG.label,
+    value: config.value ?? DEFAULT_CONFIG.value,
+    children: config.children ?? DEFAULT_CONFIG.children,
+    expand: config.expand ?? DEFAULT_CONFIG.expand
+  };
+};
+class Tree {
+  constructor(options) {
+    __privateAdd(this, _Tree_instances);
+    /** 源数据（已深拷贝） */
+    __privateAdd(this, _source);
+    /** 节点缓存 Map，key 为节点标识 */
+    __privateAdd(this, _cacheMap);
+    /** 字段映射配置 */
+    __privateAdd(this, _config, DEFAULT_CONFIG);
+    /** 初始化配置（defaultExpandAll / checkStrictly） */
+    __privateAdd(this, _initialConfig);
+    const {
+      data,
+      config = DEFAULT_CONFIG,
+      defaultExpandAll = false,
+      checkStrictly = true
+    } = options;
+    __privateSet(this, _cacheMap, /* @__PURE__ */ new Map());
+    __privateSet(this, _source, Array.isArray(data) ? data : [data]);
+    __privateSet(this, _config, mergeConfig(config));
+    __privateSet(this, _initialConfig, { defaultExpandAll, checkStrictly });
+    __privateMethod(this, _Tree_instances, init_fn).call(this);
+  }
+  /** 暴露配置，供组件层读取 */
+  get config() {
+    return __privateGet(this, _config);
+  }
+  // ==================== 公开方法 ====================
+  /** 获取某节点的直接子节点 key 列表 */
+  getChildrenKeys(node) {
+    const { children: c, key: k } = __privateGet(this, _config);
+    const children = node[c];
+    if (children) {
+      return children.map((it) => it[k]);
+    }
+    return [];
+  }
+  /** 根据 key 数组批量获取节点 */
+  getNodesByKeys(keys) {
+    return keys.map((key) => __privateGet(this, _cacheMap).get(key));
+  }
+  /**
+   * 获取树形数据
+   * @param keys 若传入则返回对应 key 的节点列表，否则返回所有根节点
+   */
+  getTreeData(keys) {
+    if (keys) {
+      return this.getNodesByKeys(keys);
+    }
+    return __privateMethod(this, _Tree_instances, getCacheList_fn).call(this).filter((it) => it.isRoot);
+  }
+  /** 获取当前所有选中 key 和展开 key */
+  getKeys() {
+    const expandKeys = [];
+    const checkedKeys = [];
+    const iterator = __privateGet(this, _cacheMap)[Symbol.iterator]();
+    let next = iterator.next();
+    while (!next.done) {
+      const [, node] = next.value;
+      const key = Reflect.get(node, __privateGet(this, _config).key);
+      if (node.checked && !node.indeterminate) {
+        checkedKeys.push(key);
+      }
+      if (node.children && node.expand) {
+        expandKeys.push(key);
+      }
+      next = iterator.next();
+    }
+    return { checkedKeys, expandKeys };
+  }
+  /** 切换节点展开/收起状态 */
+  toggleExpand(node, value) {
+    if (value !== void 0) {
+      node.expand = value;
+    } else {
+      node.expand = !node.expand;
+    }
+  }
+  /**
+   * 设置节点 checkbox 选中状态
+   * checkStrictly=true（默认）时级联更新子节点和父节点状态
+   */
+  setNodeCheckbox(node, checked) {
+    node.checked = checked;
+    node.indeterminate = false;
+    const { checkStrictly } = __privateGet(this, _initialConfig);
+    if (!checkStrictly) {
+      return;
+    }
+    if (node.children) {
+      __privateMethod(this, _Tree_instances, setChildrenStatus_fn).call(this, "checked", node.children, checked);
+    }
+    if (node.parent) {
+      __privateMethod(this, _Tree_instances, setParentChecked_fn).call(this, node.parent);
+    }
+  }
+  /** 根据 key 数组批量设置节点为选中状态 */
+  setCheckedByKeys(keys) {
+    const nodes = this.getNodesByKeys(keys);
+    nodes.forEach((node) => {
+      if (node) {
+        this.setNodeCheckbox(node, true);
+      }
+    });
+  }
+}
+_source = new WeakMap();
+_cacheMap = new WeakMap();
+_config = new WeakMap();
+_initialConfig = new WeakMap();
+_Tree_instances = new WeakSet();
+/** 递归生成单个 TreeNodeData，并写入 cacheMap */
+genTreeNodeData_fn = function(data, parentKey) {
+  const { defaultExpandAll } = __privateGet(this, _initialConfig);
+  const { key: k, children: c, expand: e } = __privateGet(this, _config);
+  const node = {
+    ...data,
+    expand: defaultExpandAll || !!data[e],
+    selected: false,
+    checked: false,
+    indeterminate: false,
+    parent: parentKey ? __privateGet(this, _cacheMap).get(parentKey) : void 0,
+    isRoot: !parentKey
+  };
+  __privateGet(this, _cacheMap).set(node[k], node);
+  const nodeChildren = node[c];
+  if (nodeChildren && nodeChildren.length > 0) {
+    node[c] = __privateMethod(this, _Tree_instances, genCacheMap_fn).call(this, nodeChildren, node[k]);
+  }
+  return node;
+};
+/** 清空缓存 */
+clearCache_fn = function() {
+  __privateGet(this, _cacheMap).clear();
+};
+/** 初始化：清空缓存后重新构建 */
+init_fn = function() {
+  __privateMethod(this, _Tree_instances, clearCache_fn).call(this);
+  __privateMethod(this, _Tree_instances, genCacheMap_fn).call(this);
+};
+/** 递归批量构建节点并填充 cacheMap */
+genCacheMap_fn = function(data = __privateGet(this, _source), parentKey) {
+  const len = data.length;
+  const treeNodeData = [];
+  for (let i = 0; i < len; i++) {
+    const treeNode = __privateMethod(this, _Tree_instances, genTreeNodeData_fn).call(this, data[i], parentKey);
+    treeNodeData.push(treeNode);
+  }
+  return treeNodeData;
+};
+/** 获取所有缓存节点列表 */
+getCacheList_fn = function() {
+  return Array.from(__privateGet(this, _cacheMap).values());
+};
+/**
+ * 向上递归更新父节点的选中/半选状态
+ * 规则：所有子节点选中 → 父节点选中；部分选中或有半选 → 父节点半选
+ */
+setParentChecked_fn = function(parent) {
+  if (parent.disabled) {
+    return;
+  }
+  const { children: c } = __privateGet(this, _config);
+  const children = parent[c] ?? [];
+  const allChecked = children.every((child) => child.checked);
+  const oneChecked = children.some((child) => child.checked);
+  const onIndeterminate = children.some((child) => child.indeterminate);
+  if (allChecked) {
+    parent.indeterminate = false;
+    parent.checked = true;
+  } else {
+    parent.indeterminate = oneChecked || onIndeterminate;
+    parent.checked = false;
+  }
+  if (parent.parent) {
+    __privateMethod(this, _Tree_instances, setParentChecked_fn).call(this, parent.parent);
+  }
+};
+/** 递归设置子节点的某个状态字段 */
+setChildrenStatus_fn = function(statusKey, nodes, value) {
+  const { children: c } = __privateGet(this, _config);
+  nodes.forEach((node) => {
+    if (node.disabled) {
+      return;
+    }
+    node[statusKey] = value;
+    const nodeChildren = node[c];
+    if (nodeChildren) {
+      __privateMethod(this, _Tree_instances, setChildrenStatus_fn).call(this, statusKey, nodeChildren, value);
+    }
+  });
+};
+const DEFAULT_TREE_CONFIG = DEFAULT_CONFIG;
+const props$o = {
+  data: { type: [Object, Array], default: () => [] },
+  config: { type: Object, default: () => DEFAULT_CONFIG },
+  checkbox: { type: Boolean, default: false },
+  defaultExpandAll: { type: Boolean, default: false },
+  checkedKeys: { type: Array, default: () => [] },
+  checkStrictly: { type: Boolean, default: true }
+};
+const treeNodeProps = {
+  data: { type: Array, default: () => [] },
+  config: { type: Object, default: () => DEFAULT_CONFIG },
+  checkbox: { type: Boolean, default: false },
+  getNodesByKeys: {
+    type: Function,
+    required: true
+  },
+  handleCheck: {
+    type: Function,
+    required: true
+  },
+  handleExpand: {
+    type: Function,
+    required: true
+  },
+  handleItemClick: {
+    type: Function,
+    required: true
+  }
+};
+const _fixKey = (data, key = "key", prefixKey) => {
+  let keyStart = 0;
+  return data.map((d) => {
+    if (!d[key]) {
+      d[key] = `${prefixKey}${keyStart++}`;
+    }
+    if (d.children) {
+      d.children = _fixKey(d.children, key, d[key]);
+    }
+    return d;
+  });
+};
+const fixKey = (data, key, prefixKey = "") => {
+  return Array.isArray(data) ? _fixKey(data, key ?? "key", prefixKey) : _fixKey([data], key ?? "key", prefixKey)[0];
+};
+const useTree = (options) => {
+  const { props: props2, event: event2 } = options;
+  const treeRef = shallowRef();
+  const initTreeRef = (data = props2.data) => {
+    var _a;
+    const rawArr = Array.isArray(data) ? data : data ? [data] : [];
+    const cloned = JSON.parse(JSON.stringify(rawArr));
+    const keyField = ((_a = props2.config) == null ? void 0 : _a.key) ?? "key";
+    const fixed = fixKey(cloned, keyField);
+    treeRef.value = new Tree({
+      data: fixed,
+      config: props2.config,
+      defaultExpandAll: props2.defaultExpandAll,
+      checkStrictly: props2.checkStrictly
+    });
+  };
+  initTreeRef();
+  const handleToggleExpand = (node, e) => {
+    var _a;
+    e.stopPropagation();
+    (_a = treeRef.value) == null ? void 0 : _a.toggleExpand(node);
+    event2.triggerTree();
+  };
+  const handleToggleChecked = (node, checked) => {
+    var _a;
+    (_a = treeRef.value) == null ? void 0 : _a.setNodeCheckbox(node, checked);
+    event2.triggerTree();
+  };
+  const getNodesByKeys = (keys) => {
+    return treeRef.value.getTreeData(keys);
+  };
+  return {
+    treeRef,
+    getNodesByKeys,
+    handleToggleExpand,
+    handleToggleChecked,
+    initTreeRef
+  };
+};
+const TreeCore = {
+  props: props$o,
+  treeNodeProps,
+  useTree
+};
+const props$n = {
+  data: { type: Array, default: () => [] },
+  height: { type: String, default: null },
+  paramClass: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false }
+};
+function useTable() {
+  const error = (msg) => console.warn(`[水墨UI表格组件] ${msg}`);
+  const initTable = (renders, columns, data) => {
+    const tbodyTrList = [];
+    data.forEach(() => {
+      tbodyTrList.push([]);
+    });
+    const getData = (i, param) => {
+      if (data[i] && data[i][param]) {
+        return data[i][param];
+      }
+      return "";
+    };
+    const pushTd = (param, bodySlot, style) => {
+      if (param) {
+        tbodyTrList.forEach((t, i) => {
+          t.push(renders.tbodyTr({
+            data: getData(i, param),
+            style,
+            param,
+            slot: bodySlot,
+            slotInfo: {
+              data: data[i],
+              index: i
+            }
+          }));
+        });
+      } else {
+        error("param is undefined, column without param will be ignored!");
+      }
+    };
+    const getStyle = (options) => {
+      if (!options || !options.width) {
+        return {};
+      }
+      const numberWidth = Number(options.width);
+      if (!isNaN(numberWidth)) {
+        return { width: numberWidth + "px" };
+      }
+      return { width: options.width };
+    };
+    const initTHead = () => {
+      const ths = (columns ?? []).filter((column) => {
+        if (!column.props) {
+          error("column.props is undefined, column without param will be ignored!");
+          return false;
+        }
+        return true;
+      }).map((column) => {
+        const slots = renders.initSlot(column);
+        let bodySlot;
+        let headSlot;
+        const style = getStyle(column.props);
+        if (slots) {
+          bodySlot = slots.body;
+          headSlot = slots.head;
+        }
+        pushTd(column.props.param, bodySlot, style);
+        return renders.theadTh({
+          label: column.props.label,
+          param: column.props.param,
+          slot: headSlot,
+          style
+        });
+      });
+      return renders.thead(ths);
+    };
+    const thead = initTHead();
+    const tbody = tbodyTrList.length > 0 ? renders.tbody(tbodyTrList.map((tds, i) => renders.tbodyTrs(tds, i))) : renders.empty;
+    return {
+      thead,
+      tbody
+    };
+  };
+  return {
+    initTable,
+    error
+  };
+}
+const TableCore = {
+  props: props$n,
+  useTable
+};
+const props$m = {
+  width: { type: String, default: "" },
+  param: { type: String, default: "" },
+  label: { type: String, default: "" }
+};
+const TableColumnCore = {
+  props: props$m
+};
+const props$l = {
+  top: { type: [Boolean, String], default: true },
+  right: { type: [Boolean, String], default: true },
+  bottom: { type: [Boolean, String], default: true },
+  left: { type: [Boolean, String], default: true },
+  insteadMain: { type: [Boolean, String], default: false }
+};
+const BorderCore = {
+  props: props$l
+};
+const props$k = {
+  list: { type: Array, default: () => [] },
+  estimatedHeight: { type: Number, default: 40 },
+  overScan: { type: Number, default: 1 }
+};
+function createHeightCache(total, estimatedHeight) {
+  const heights = new Array(total).fill(null);
+  const getHeight = (index) => {
+    return heights[index] ?? estimatedHeight;
+  };
+  const update = (index, height) => {
+    if (index >= 0 && index < heights.length) {
+      heights[index] = height;
+    }
+  };
+  const getOffset = (index) => {
+    let offset = 0;
+    const end = Math.min(index, heights.length);
+    for (let i = 0; i < end; i++) {
+      offset += getHeight(i);
+    }
+    return offset;
+  };
+  const getTotalHeight = () => {
+    return getOffset(heights.length);
+  };
+  const findIndex = (scrollTop) => {
+    let low = 0;
+    let high = heights.length - 1;
+    while (low <= high) {
+      const mid = low + high >>> 1;
+      const offset = getOffset(mid);
+      const offsetEnd = offset + getHeight(mid);
+      if (offsetEnd <= scrollTop) {
+        low = mid + 1;
+      } else if (offset > scrollTop) {
+        high = mid - 1;
+      } else {
+        return mid;
+      }
+    }
+    return Math.min(low, heights.length - 1);
+  };
+  const reset = (newTotal) => {
+    heights.length = newTotal;
+    heights.fill(null);
+  };
+  return { update, getHeight, getOffset, getTotalHeight, findIndex, reset };
+}
+function useSentinelObserver(options) {
+  let ob;
+  const cleanup = () => {
+    if (ob) {
+      ob.disconnect();
+      ob = void 0;
+    }
+  };
+  const initObserver = () => {
+    const container = options.containerRef.value;
+    if (!container) return;
+    cleanup();
+    ob = new IntersectionObserver(
+      (entries) => {
+        var _a;
+        for (const entry of entries) {
+          if (!entry.isIntersecting) continue;
+          if (entry.target === options.bottomSentinelRef.value) {
+            options.onUpdate();
+            (_a = options.onReachBottom) == null ? void 0 : _a.call(options);
+          } else if (entry.target === options.topSentinelRef.value) {
+            options.onUpdate();
+          }
+        }
+      },
+      {
+        root: container,
+        threshold: 0
+      }
+    );
+    if (options.topSentinelRef.value) {
+      ob.observe(options.topSentinelRef.value);
+    }
+    if (options.bottomSentinelRef.value) {
+      ob.observe(options.bottomSentinelRef.value);
+    }
+  };
+  const reobserve = () => {
+    initObserver();
+  };
+  watch(options.containerRef, () => {
+    if (options.containerRef.value) {
+      initObserver();
+    }
+  });
+  onBeforeUnmount(cleanup);
+  return { reobserve, cleanup };
+}
+function useVirtualList(options) {
+  const { props: props2, onReachBottom } = options;
+  const containerRef = ref(null);
+  const wrapperRef = ref(null);
+  const topSentinelRef = ref(null);
+  const bottomSentinelRef = ref(null);
+  const listRef = toRef(() => props2.list ?? []);
+  const estimatedHeight = props2.estimatedHeight ?? 40;
+  const overScan = props2.overScan ?? 1;
+  const heightCache = createHeightCache(listRef.value.length, estimatedHeight);
+  const renderFrom = ref(0);
+  const renderEnd = ref(0);
+  const totalHeight = ref(0);
+  const offsetY = ref(0);
+  const calcRange = () => {
+    const container = containerRef.value;
+    if (!container) return;
+    const list = listRef.value;
+    const total = list.length;
+    if (total === 0) {
+      renderFrom.value = 0;
+      renderEnd.value = 0;
+      totalHeight.value = 0;
+      offsetY.value = 0;
+      return;
+    }
+    const scrollTop = container.scrollTop;
+    const containerHeight = container.clientHeight;
+    const startIndex = heightCache.findIndex(scrollTop);
+    let visibleEnd = startIndex;
+    let accHeight = 0;
+    while (visibleEnd < total && accHeight < containerHeight) {
+      accHeight += heightCache.getHeight(visibleEnd);
+      visibleEnd++;
+    }
+    const visibleCount = visibleEnd - startIndex;
+    const overScanCount = Math.max(1, Math.floor(visibleCount * overScan));
+    const from = Math.max(0, startIndex - overScanCount);
+    const end = Math.min(total, visibleEnd + overScanCount);
+    renderFrom.value = from;
+    renderEnd.value = end;
+    totalHeight.value = heightCache.getTotalHeight();
+    offsetY.value = heightCache.getOffset(from);
+  };
+  const displayList = computed(() => {
+    const list = listRef.value;
+    return list.slice(renderFrom.value, renderEnd.value).map((d, i) => ({ data: d, index: i + renderFrom.value }));
+  });
+  const measureItems = () => {
+    const wrapper = wrapperRef.value;
+    const container = containerRef.value;
+    if (!wrapper || !container) return;
+    const scrollTop = container.scrollTop;
+    const firstVisibleIndex = heightCache.findIndex(scrollTop);
+    const oldOffset = heightCache.getOffset(firstVisibleIndex);
+    const children = wrapper.children;
+    let hasChange = false;
+    for (let i = 1; i < children.length - 1; i++) {
+      const child = children[i];
+      const index = renderFrom.value + (i - 1);
+      const height = child.getBoundingClientRect().height;
+      if (height > 0) {
+        const oldHeight = heightCache.getHeight(index);
+        if (Math.abs(oldHeight - height) > 0.5) {
+          heightCache.update(index, height);
+          hasChange = true;
+        }
+      }
+    }
+    if (hasChange) {
+      const newOffset = heightCache.getOffset(firstVisibleIndex);
+      const delta = newOffset - oldOffset;
+      if (Math.abs(delta) > 0.5) {
+        container.scrollTop = scrollTop + delta;
+      }
+    }
+    totalHeight.value = heightCache.getTotalHeight();
+  };
+  const update = () => {
+    measureItems();
+    calcRange();
+    nextTick(() => {
+      measureItems();
+    });
+  };
+  const { reobserve } = useSentinelObserver({
+    containerRef,
+    topSentinelRef,
+    bottomSentinelRef,
+    onUpdate: update,
+    onReachBottom
+  });
+  let rafId = null;
+  let scrollHandler;
+  let scrollendHandler;
+  const setupScrollListener = () => {
+    const container = containerRef.value;
+    if (!container) return;
+    scrollHandler = () => {
+      if (rafId !== null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        calcRange();
+      });
+    };
+    container.addEventListener("scroll", scrollHandler, { passive: true });
+    scrollendHandler = () => {
+      measureItems();
+      calcRange();
+    };
+    container.addEventListener("scrollend", scrollendHandler);
+  };
+  const cleanupScrollListener = () => {
+    const container = containerRef.value;
+    if (container) {
+      if (scrollHandler) container.removeEventListener("scroll", scrollHandler);
+      if (scrollendHandler) container.removeEventListener("scrollend", scrollendHandler);
+    }
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  };
+  onMounted(() => {
+    const list = listRef.value;
+    heightCache.reset(list.length);
+    calcRange();
+    nextTick(() => {
+      measureItems();
+      calcRange();
+      reobserve();
+      setupScrollListener();
+    });
+  });
+  watch(listRef, (newList) => {
+    heightCache.reset(newList.length);
+    if (containerRef.value) {
+      containerRef.value.scrollTop = 0;
+    }
+    calcRange();
+    nextTick(() => {
+      measureItems();
+      calcRange();
+      reobserve();
+    });
+  });
+  onBeforeUnmount(cleanupScrollListener);
+  return {
+    displayList,
+    containerRef,
+    wrapperRef,
+    topSentinelRef,
+    bottomSentinelRef,
+    totalHeight,
+    offsetY
+  };
+}
+const VirtualListCore = {
+  props: props$k,
+  useVirtualList
+};
+const props$j = {
+  placement: {
+    type: String,
+    default: "bottom"
+    // validator: (value: string) =>
+    //   [
+    //     'auto',
+    //     'auto-start',
+    //     'auto-end',
+    //     'top',
+    //     'top-start',
+    //     'top-end',
+    //     'bottom',
+    //     'bottom-start',
+    //     'bottom-end',
+    //     'right',
+    //     'right-start',
+    //     'right-end',
+    //     'left',
+    //     'left-start',
+    //     'left-end'
+    //   ].includes(value)
+  },
+  mountRender: { type: Boolean, default: false },
+  disableClickAway: { type: Boolean, default: false },
+  // offsetSkid: { type: String, default: '0' },
+  // offsetDistance: { type: String, default: '0' },
+  hover: { type: Boolean, default: false },
+  show: { type: Boolean, default: null },
+  // disabled: { type: Boolean, default: false },
+  // openDelay: { type: Number, default: 0 },
+  // closeDelay: { type: Number, default: 0 },
+  // interactive: { type: Boolean, default: true },
+  // locked: { type: Boolean, default: false },
+  content: { type: String, default: "" },
+  popper: {
+    type: Object,
+    default: () => ({})
+  },
+  teleport: { type: [Object, Boolean], default: void 0 },
+  title: { type: String, default: void 0 }
+};
+class PopoverImpl2 {
+  constructor(val, active, content, arrow2, config, lifecycle) {
+    __publicField(this, "_active");
+    __publicField(this, "_content");
+    __publicField(this, "_arrow");
+    __publicField(this, "popperInstance");
+    __publicField(this, "style");
+    __publicField(this, "arrowStyle");
+    __publicField(this, "placement");
+    __publicField(this, "visible", false);
+    __publicField(this, "onShow");
+    __publicField(this, "onHide");
+    if (!content) {
+      throw new Error("MPopover: content is required");
+    }
+    if (!active) {
+      throw new Error("MPopover: active is required");
+    }
+    this._active = active;
+    this._content = content;
+    this._arrow = arrow2;
+    this.popperInstance = usePopper(
+      this._active,
+      this._content,
+      (positionStyle) => this.update(positionStyle),
+      this._arrow,
+      config
+    );
+    this.style = val.style;
+    this.arrowStyle = val.arrowStyle;
+    this.placement = val.placement;
+    this.visible = val.show;
+    this.onShow = lifecycle == null ? void 0 : lifecycle.onShow;
+    this.onHide = lifecycle == null ? void 0 : lifecycle.onHide;
+  }
+  get content() {
+    return this._content;
+  }
+  async show() {
+    var _a;
+    this.style.value = { display: "block", opacity: "0" };
+    this.arrowStyle.value = { display: "block", opacity: "0" };
+    this.visible = true;
+    await this.popperInstance.getPositionStyle();
+    (_a = this.onShow) == null ? void 0 : _a.call(this);
+  }
+  update(positionStyle) {
+    if (!this.visible) {
+      this.hide();
+      return;
+    }
+    this.style.value = positionStyle.style;
+    this.arrowStyle.value = positionStyle.arrowStyle;
+    this.placement.value = positionStyle.placement;
+  }
+  hide() {
+    var _a;
+    this.style.value = void 0;
+    this.arrowStyle.value = void 0;
+    this.visible = false;
+    (_a = this.onHide) == null ? void 0 : _a.call(this);
+  }
+  async toggle() {
+    if (this.visible) {
+      this.hide();
+    } else {
+      await this.show();
+    }
+  }
+  destroy() {
+  }
+}
+function usePopover(options, lifecycle) {
+  const style = ref();
+  const arrowStyle = ref();
+  const placement = ref(options.value.placement);
+  let instance = null;
+  let clickAwayInstance;
+  const popperInstance = shallowRef();
+  const popoverRef = ref();
+  const contentRef = ref();
+  const arrowRef = ref();
+  const createPopover = (active, content, arrow2, config) => {
+    instance = new PopoverImpl2(
+      { style, arrowStyle, placement, show: options.props.show },
+      active,
+      content,
+      arrow2,
+      config,
+      {
+        onShow: () => {
+          var _a;
+          clickAwayInstance == null ? void 0 : clickAwayInstance.add();
+          (_a = lifecycle == null ? void 0 : lifecycle.onShow) == null ? void 0 : _a.call(lifecycle);
+        },
+        onHide: () => {
+          var _a;
+          clickAwayInstance == null ? void 0 : clickAwayInstance.remove();
+          (_a = lifecycle == null ? void 0 : lifecycle.onHide) == null ? void 0 : _a.call(lifecycle);
+        }
+      }
+    );
+    return instance;
+  };
+  const props2 = options.props;
+  const popoverEnter = () => {
+    if (props2.hover) {
+      instance == null ? void 0 : instance.show();
+    }
+  };
+  const popoverLeave = () => {
+    if (props2.hover) {
+      instance == null ? void 0 : instance.hide();
+    }
+  };
+  const onBeforeDestroyEvents = [];
+  onMounted(() => {
+    if (!popoverRef.value || !contentRef.value) {
+      return;
+    }
+    popperInstance.value = createPopover(popoverRef.value, contentRef.value, arrowRef.value, {
+      ...props2.popper,
+      placement: props2.placement
+    });
+    if (options.props.disableClickAway) {
+      return;
+    }
+    clickAwayInstance = useClickAway({
+      target: () => {
+        var _a;
+        return (_a = instance == null ? void 0 : instance.content) == null ? void 0 : _a.parentElement;
+      },
+      handler: () => {
+        instance == null ? void 0 : instance.hide();
+      }
+    });
+  });
+  onBeforeMount(() => {
+    if (clickAwayInstance) {
+      const { onBeforeDestroy } = clickAwayInstance;
+      onBeforeDestroy();
+    }
+  });
+  const getContent = (props22, getContentSlot, useTeleport, _instance = instance) => {
+    const contentTeleportWrapper = () => {
+      if (props22.teleport) {
+        return useTeleport({
+          teleportProps: props22.teleport,
+          slot: getContentSlot()
+        });
+      }
+      return getContentSlot();
+    };
+    if (props22.mountRender) {
+      return contentTeleportWrapper();
+    }
+    if (!_instance || !_instance.visible) {
+      return null;
+    }
+    return contentTeleportWrapper();
+  };
+  return {
+    getContent,
+    popoverEnter,
+    popoverLeave,
+    popoverRef,
+    contentRef,
+    arrowRef,
+    popperInstance,
+    style,
+    arrowStyle,
+    lifecycle: {
+      onBeforeDestroyEvents
+    }
+  };
+}
+const MessagePopoverCore = {
+  props: props$j,
+  usePopover
+};
+const props$i = {
+  modelValue: { type: [String, Number], required: true },
+  items: { type: Array, default: () => [] },
+  type: { type: String, default: "line" }
+};
+const tabPaneProps = {
+  label: { type: String, required: true },
+  name: { type: [String, Number], required: true },
+  disabled: { type: Boolean, default: false },
+  lazy: { type: Boolean, default: false }
+};
+function useTabs(props2, ctx) {
+  const { emit } = ctx;
+  const activeTab = computed(() => props2.modelValue);
+  const isActive = (name) => activeTab.value === name;
+  const switchTab = (name, disabled) => {
+    if (disabled) {
+      return;
+    }
+    if (name === activeTab.value) {
+      return;
+    }
+    emit("update:modelValue", name);
+    emit("change", name);
+  };
+  const tabsClass = computed(() => {
+    const type = props2.type ?? "line";
+    return [
+      "m-tabs",
+      `m-tabs-${type}`
+    ];
+  });
+  const navClass = "m-tabs-nav";
+  const getNavItemClass = (name, disabled) => [
+    "m-tabs-nav-item",
+    isActive(name) ? "m-tabs-nav-item-active" : "",
+    disabled ? "m-tabs-nav-item-disabled" : ""
+  ].filter(Boolean);
+  const contentClass = "m-tabs-content";
+  return {
+    activeTab,
+    isActive,
+    switchTab,
+    tabsClass,
+    navClass,
+    getNavItemClass,
+    contentClass
+  };
+}
+const TabsCore = {
+  props: props$i,
+  tabPaneProps,
+  useTabs
+};
+const props$h = {
+  trigger: {
+    type: String,
+    default: "click"
+  },
+  placement: {
+    type: String,
+    default: "bottom"
+  },
+  disabled: { type: Boolean, default: false }
+};
+const itemProps$1 = {
+  label: { type: String, default: "" },
+  disabled: { type: Boolean, default: false },
+  divided: { type: Boolean, default: false },
+  command: { type: [String, Number], default: void 0 },
+  type: {
+    type: String,
+    default: "default"
+  }
+};
+function useDropdown(props2, ctx) {
+  const { emit } = ctx;
+  const visible = ref(false);
+  const triggerRef2 = ref();
+  const menuRef = ref();
+  const open = () => {
+    if (props2.disabled) {
+      return;
+    }
+    visible.value = true;
+  };
+  const close = () => {
+    visible.value = false;
+  };
+  const toggle = () => {
+    if (visible.value) {
+      close();
+    } else {
+      open();
+    }
+  };
+  let clickAwayInstance;
+  onMounted(() => {
+    clickAwayInstance = useClickAway({
+      // 以 trigger 容器为边界，点击 trigger 或 menu 内部不触发关闭
+      target: () => {
+        var _a;
+        return (_a = triggerRef2.value) == null ? void 0 : _a.parentElement;
+      },
+      handler: () => {
+        close();
+      }
+    });
+    clickAwayInstance == null ? void 0 : clickAwayInstance.add();
+  });
+  onBeforeUnmount(() => {
+    clickAwayInstance == null ? void 0 : clickAwayInstance.remove();
+  });
+  const handleTriggerClick = () => {
+    if (props2.trigger !== "click") {
+      return;
+    }
+    toggle();
+  };
+  const handleMouseenter = () => {
+    if (props2.trigger !== "hover") {
+      return;
+    }
+    open();
+  };
+  const handleMouseleave = () => {
+    if (props2.trigger !== "hover") {
+      return;
+    }
+    close();
+  };
+  const handleItemClick = (item) => {
+    if (item.disabled) {
+      return;
+    }
+    emit("command", item.command);
+    close();
+  };
+  const dropdownClass = computed(() => [
+    "m-dropdown",
+    { "m-dropdown-open": visible.value },
+    { "m-dropdown-disabled": props2.disabled }
+  ]);
+  const menuClass = computed(() => ["m-dropdown-menu"]);
+  const getItemClass = (item) => [
+    "m-dropdown-item",
+    { "m-dropdown-item-disabled": item.disabled },
+    { "m-dropdown-item-divided": item.divided }
+  ];
+  return {
+    visible,
+    triggerRef: triggerRef2,
+    menuRef,
+    open,
+    close,
+    toggle,
+    handleTriggerClick,
+    handleMouseenter,
+    handleMouseleave,
+    handleItemClick,
+    dropdownClass,
+    menuClass,
+    getItemClass
+  };
+}
+const DropdownCore = {
+  props: props$h,
+  itemProps: itemProps$1,
+  useDropdown
+};
+const props$g = {
+  modelValue: { type: [Array, String, Number], required: true },
+  accordion: { type: Boolean, default: false }
+};
+const itemProps = {
+  name: { type: [String, Number], required: true },
+  title: { type: String, default: "" },
+  disabled: { type: Boolean, default: false }
+};
+function useCollapse(props2, ctx) {
+  const { emit } = ctx;
+  const activeNames = computed(() => {
+    const val = props2.modelValue;
+    if (Array.isArray(val)) {
+      return val;
+    }
+    if (val === void 0 || val === null || val === "") {
+      return [];
+    }
+    return [val];
+  });
+  const isActive = (name) => {
+    return activeNames.value.includes(name);
+  };
+  const toggle = (name, disabled) => {
+    if (disabled) {
+      return;
+    }
+    let next;
+    if (props2.accordion) {
+      next = isActive(name) ? [] : [name];
+    } else {
+      if (isActive(name)) {
+        next = activeNames.value.filter((n) => n !== name);
+      } else {
+        next = [...activeNames.value, name];
+      }
+    }
+    emit("update:modelValue", props2.accordion ? next[0] ?? "" : next);
+    emit("change", next);
+  };
+  const collapseClass = computed(() => ["m-collapse"]);
+  const getItemClass = (name, disabled) => [
+    "m-collapse-item",
+    { "m-collapse-item-active": isActive(name) },
+    { "m-collapse-item-disabled": disabled }
+  ];
+  const headerClass = ["m-collapse-header"];
+  const contentClass = ["m-collapse-content"];
+  return {
+    activeNames,
+    isActive,
+    toggle,
+    collapseClass,
+    getItemClass,
+    headerClass,
+    contentClass
+  };
+}
+const CollapseCore = {
+  props: props$g,
+  itemProps,
+  useCollapse
+};
+const stepsProps = {
+  active: { type: Number, default: 0 },
+  direction: { type: String, default: "horizontal" },
+  finishStatus: { type: String, default: "finish" },
+  processStatus: { type: String, default: "process" }
+};
+const stepProps = {
+  title: { type: String, required: true },
+  description: { type: String, default: "" },
+  icon: { type: String, default: "" },
+  status: { type: String, default: void 0 }
+};
+const stepsContextKey = Symbol("stepsContext");
+function useSteps(props2) {
+  const context = {
+    get active() {
+      return props2.active ?? 0;
+    },
+    get finishStatus() {
+      return props2.finishStatus ?? "finish";
+    },
+    get processStatus() {
+      return props2.processStatus ?? "process";
+    },
+    get direction() {
+      return props2.direction ?? "horizontal";
+    },
+    total: 0
+  };
+  provide(stepsContextKey, context);
+  const stepsClass = computed(() => [
+    "m-steps",
+    `m-steps-${props2.direction ?? "horizontal"}`
+  ]);
+  return { stepsClass, context };
+}
+function resolveStepStatus(index, overrideStatus, ctx) {
+  if (overrideStatus) return overrideStatus;
+  const active = ctx.active;
+  if (index < active) return ctx.finishStatus;
+  if (index === active) return ctx.processStatus;
+  return "wait";
+}
+function useStep(index, overrideStatus) {
+  const ctx = inject(stepsContextKey, null);
+  const status = computed(() => {
+    if (!ctx) {
+      return overrideStatus ?? "wait";
+    }
+    return resolveStepStatus(index, overrideStatus, ctx);
+  });
+  const stepClass = computed(() => [
+    "m-step",
+    `m-step-${status.value}`
+  ]);
+  const isLast = computed(() => {
+    if (!ctx) return true;
+    return index >= ctx.total - 1;
+  });
+  return { status, stepClass, isLast, ctx };
+}
+const StepsCore = {
+  stepsProps,
+  stepProps,
+  useSteps,
+  useStep,
+  stepsContextKey,
+  resolveStepStatus
+};
+const notificationProps = {
+  title: { type: String, required: true },
+  message: { type: String, default: "" },
+  type: { type: String, default: "info" },
+  duration: { type: Number, default: 4500 },
+  position: { type: String, default: "top-right" },
+  closable: { type: Boolean, default: true },
+  offset: { type: Number, default: 16 }
+};
+function useNotificationQueue() {
+  const notifications = ref([]);
+  let nextId = 0;
+  const add = (options) => {
+    const id = nextId++;
+    const item = {
+      id,
+      title: options.title,
+      message: options.message ?? "",
+      type: options.type ?? "info",
+      duration: options.duration ?? 4500,
+      position: options.position ?? "top-right",
+      closable: options.closable ?? true
+    };
+    notifications.value.push(item);
+    if (item.duration > 0) {
+      setTimeout(() => remove(id), item.duration);
+    }
+    return id;
+  };
+  const remove = (id) => {
+    const idx = notifications.value.findIndex((n) => n.id === id);
+    if (idx !== -1) {
+      notifications.value.splice(idx, 1);
+    }
+  };
+  return { notifications, add, remove };
+}
+const NotificationCore = {
+  notificationProps,
+  useNotificationQueue
+};
+const props$f = {
+  loading: { type: Boolean, default: true },
+  rows: { type: Number, default: 3 },
+  animated: { type: Boolean, default: true },
+  avatar: { type: Boolean, default: false },
+  title: { type: Boolean, default: true }
+};
+const SkeletonCore = {
+  props: props$f
+};
+const timelineProps = {
+  reverse: { type: Boolean, default: false }
+};
+const timelineItemProps = {
+  timestamp: { type: String, default: "" },
+  hideTimestamp: { type: Boolean, default: false },
+  placement: { type: String, default: "bottom" },
+  type: { type: String, default: "primary" },
+  size: { type: String, default: "normal" },
+  icon: { type: String, default: "" },
+  hollow: { type: Boolean, default: false }
+};
+const TimelineCore = {
+  timelineProps,
+  timelineItemProps
+};
+const descriptionsProps = {
+  title: { type: String, default: "" },
+  column: { type: Number, default: 3 },
+  direction: { type: String, default: "horizontal" },
+  border: { type: Boolean, default: false },
+  size: { type: String, default: "medium" }
+};
+const descriptionsItemProps = {
+  label: { type: String, required: true },
+  span: { type: Number, default: 1 }
+};
+const DescriptionsCore = {
+  descriptionsProps,
+  descriptionsItemProps
+};
+const props$e = {
+  title: { type: String, default: void 0 },
+  shadow: { type: String, default: "never" },
+  bodyStyle: { type: Object, default: void 0 },
+  bordered: { type: Boolean, default: true }
+};
+const CardCore = {
+  props: props$e
+};
+const props$d = {
+  type: { type: String, default: "info" },
+  title: { type: String, default: void 0 },
+  description: { type: String, default: void 0 },
+  closable: { type: Boolean, default: false },
+  showIcon: { type: Boolean, default: false }
+};
+const AlertCore = {
+  props: props$d
+};
+const props$c = {
+  value: { type: [String, Number], default: void 0 },
+  max: { type: Number, default: 99 },
+  dot: { type: Boolean, default: false },
+  hidden: { type: Boolean, default: false },
+  showZero: { type: Boolean, default: false },
+  type: {
+    type: String,
+    default: "danger"
+  }
+};
+const BadgeCore = {
+  props: props$c
+};
+const props$b = {
+  description: { type: String, default: "暂无数据" },
+  image: { type: String, default: void 0 }
+};
+const EmptyCore = {
+  props: props$b
+};
+const props$a = {
+  direction: { type: String, default: "horizontal" },
+  size: { type: [String, Number], default: "medium" },
+  wrap: { type: Boolean, default: false },
+  align: { type: String, default: "center" }
+};
+const SpaceCore = {
+  props: props$a
+};
+const props$9 = {
+  modelValue: { type: String, default: "" },
+  placeholder: { type: String, default: "请输入..." },
+  disabled: { type: Boolean, default: false },
+  clearable: { type: Boolean, default: false },
+  debounce: { type: Number, default: 300 },
+  fetchSuggestions: {
+    type: Function,
+    default: void 0
+  },
+  triggerOnFocus: { type: Boolean, default: false },
+  highlight: { type: Boolean, default: false }
+};
+function useAutoComplete(props2, ctx) {
+  const modelValueRef = toRef(() => props2.modelValue ?? "");
+  const inputValue = ref(modelValueRef.value);
+  const isOpen = ref(false);
+  const loading = ref(false);
+  const suggestions = ref([]);
+  let debounceTimer;
+  const clearDebounce = () => {
+    if (debounceTimer !== void 0) {
+      clearTimeout(debounceTimer);
+      debounceTimer = void 0;
+    }
+  };
+  const doSearch = async (query) => {
+    if (!props2.fetchSuggestions) return;
+    loading.value = true;
+    try {
+      const result = await props2.fetchSuggestions(query);
+      suggestions.value = result ?? [];
+      isOpen.value = true;
+    } catch {
+      suggestions.value = [];
+    } finally {
+      loading.value = false;
+    }
+  };
+  const debouncedSearch = (query) => {
+    clearDebounce();
+    const delay = props2.debounce ?? 300;
+    debounceTimer = setTimeout(() => {
+      doSearch(query);
+      ctx.emit("search", query);
+    }, delay);
+  };
+  const onInput = (e) => {
+    const value = e.target.value;
+    inputValue.value = value;
+    ctx.emit("update:modelValue", value);
+    debouncedSearch(value);
+  };
+  const onFocus = (e) => {
+    if (props2.disabled) return;
+    ctx.emit("focus", e);
+    if (props2.triggerOnFocus) {
+      doSearch(inputValue.value);
+      ctx.emit("search", inputValue.value);
+    }
+  };
+  const onBlur = (e) => {
+    if (props2.disabled) return;
+    setTimeout(() => {
+      isOpen.value = false;
+    }, 150);
+    ctx.emit("blur", e);
+  };
+  const onSelect = (item) => {
+    inputValue.value = item.value;
+    ctx.emit("update:modelValue", item.value);
+    ctx.emit("select", item);
+    isOpen.value = false;
+    clearDebounce();
+  };
+  const onClear = () => {
+    inputValue.value = "";
+    suggestions.value = [];
+    isOpen.value = false;
+    clearDebounce();
+    ctx.emit("update:modelValue", "");
+  };
+  const close = () => {
+    isOpen.value = false;
+  };
+  onBeforeUnmount(() => {
+    clearDebounce();
+  });
+  return {
+    // 状态
+    inputValue,
+    isOpen,
+    loading,
+    suggestions,
+    // 事件
+    onInput,
+    onFocus,
+    onBlur,
+    onSelect,
+    onClear,
+    close
+  };
+}
+const AutoCompleteCore = {
+  props: props$9,
+  useAutoComplete
+};
+const props$8 = {
+  autoplay: { type: Boolean, default: true },
+  interval: { type: Number, default: 3e3 },
+  loop: { type: Boolean, default: true },
+  direction: {
+    type: String,
+    default: "horizontal",
+    enum: ["horizontal", "vertical"]
+  },
+  initialIndex: { type: Number, default: 0 },
+  showIndicators: { type: Boolean, default: true },
+  showArrows: {
+    type: [Boolean, String],
+    default: "hover"
+  }
+};
+function useCarousel(props2, emit, count) {
+  const activeIndex = ref(props2.initialIndex);
+  let timer = null;
+  const setActive = (index) => {
+    const total = count();
+    if (total === 0) {
+      return;
+    }
+    let next2 = index;
+    if (props2.loop) {
+      next2 = (index % total + total) % total;
+    } else {
+      next2 = Math.max(0, Math.min(index, total - 1));
+    }
+    if (next2 !== activeIndex.value) {
+      activeIndex.value = next2;
+      emit("change", next2);
+    }
+  };
+  const prev = () => setActive(activeIndex.value - 1);
+  const next = () => setActive(activeIndex.value + 1);
+  const startAutoplay = () => {
+    if (!props2.autoplay || props2.interval <= 0) {
+      return;
+    }
+    timer = setInterval(next, props2.interval);
+  };
+  const stopAutoplay = () => {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  watch(() => props2.autoplay, (val) => {
+    val ? startAutoplay() : stopAutoplay();
+  });
+  onMounted(startAutoplay);
+  onUnmounted(stopAutoplay);
+  const arrowsClass = computed(() => {
+    if (props2.showArrows === "hover") {
+      return "k-carousel-arrows-hover";
+    }
+    if (props2.showArrows === false) {
+      return "k-carousel-arrows-hidden";
+    }
+    return "k-carousel-arrows-always";
+  });
+  return {
+    activeIndex,
+    prev,
+    next,
+    setActive,
+    startAutoplay,
+    stopAutoplay,
+    arrowsClass
+  };
+}
+const CarouselCore = {
+  props: props$8,
+  useCarousel
+};
+const props$7 = {
+  src: { type: String, required: true },
+  alt: { type: String, default: "" },
+  fit: {
+    type: String,
+    default: "cover",
+    enum: ["contain", "cover", "fill", "none", "scale-down"]
+  },
+  lazy: { type: Boolean, default: false },
+  previewSrcList: { type: Array, default: () => [] },
+  zIndex: { type: Number, default: 2e3 }
+};
+function useImage(props2, emit) {
+  const status = ref("loading");
+  const previewVisible = ref(false);
+  const previewIndex = ref(0);
+  const previewScale = ref(1);
+  const previewRotate = ref(0);
+  const reset = () => {
+    status.value = "loading";
+  };
+  const handleLoad = (e) => {
+    status.value = "loaded";
+    emit("load", e);
+  };
+  const handleError = (e) => {
+    status.value = "error";
+    emit("error", e);
+  };
+  const openPreview = () => {
+    if (!props2.previewSrcList || props2.previewSrcList.length === 0) {
+      return;
+    }
+    const idx = props2.previewSrcList.indexOf(props2.src);
+    previewIndex.value = idx >= 0 ? idx : 0;
+    previewScale.value = 1;
+    previewRotate.value = 0;
+    previewVisible.value = true;
+  };
+  const closePreview = () => {
+    previewVisible.value = false;
+  };
+  const previewPrev = () => {
+    const total = props2.previewSrcList.length;
+    if (total === 0) {
+      return;
+    }
+    previewIndex.value = (previewIndex.value - 1 + total) % total;
+    previewScale.value = 1;
+    previewRotate.value = 0;
+    emit("switch", previewIndex.value);
+  };
+  const previewNext = () => {
+    const total = props2.previewSrcList.length;
+    if (total === 0) {
+      return;
+    }
+    previewIndex.value = (previewIndex.value + 1) % total;
+    previewScale.value = 1;
+    previewRotate.value = 0;
+    emit("switch", previewIndex.value);
+  };
+  const zoomIn = () => {
+    previewScale.value = Math.min(previewScale.value + 0.25, 5);
+  };
+  const zoomOut = () => {
+    previewScale.value = Math.max(previewScale.value - 0.25, 0.25);
+  };
+  const rotate = () => {
+    previewRotate.value = (previewRotate.value + 90) % 360;
+  };
+  watch(() => props2.src, reset);
+  onMounted(() => {
+    if (props2.lazy) {
+      status.value = "loading";
+    }
+  });
+  return {
+    status,
+    previewVisible,
+    previewIndex,
+    previewScale,
+    previewRotate,
+    handleLoad,
+    handleError,
+    openPreview,
+    closePreview,
+    previewPrev,
+    previewNext,
+    zoomIn,
+    zoomOut,
+    rotate
+  };
+}
+const ImageCore = {
+  props: props$7,
+  useImage
+};
+const props$6 = {
+  status: {
+    type: String,
+    default: "info",
+    enum: ["success", "warning", "error", "info", "404"]
+  },
+  title: { type: String, default: "" },
+  subTitle: { type: String, default: "" }
+};
+const ResultCore = {
+  props: props$6
+};
+const props$5 = {
+  modelValue: { type: void 0, default: () => [] },
+  options: { type: Array, default: () => [] },
+  placeholder: { type: String, default: "请选择" },
+  disabled: { type: Boolean, default: false },
+  clearable: { type: Boolean, default: false },
+  filterable: { type: Boolean, default: false },
+  separator: { type: String, default: "/" },
+  expandTrigger: { type: String, default: "click" },
+  showAllLevels: { type: Boolean, default: true },
+  multiple: { type: Boolean, default: false }
+};
+const flattenOptions = (options, path = []) => {
+  const result = [];
+  for (const option of options) {
+    const currentPath = [...path, option];
+    if (!option.children || option.children.length === 0 || option.leaf) {
+      result.push({
+        path: currentPath,
+        pathLabel: currentPath.map((o) => o.label).join(" ")
+      });
+    } else {
+      result.push(...flattenOptions(option.children, currentPath));
+    }
+  }
+  return result;
+};
+const findPathByValues = (options, values) => {
+  var _a;
+  if (!values.length) return null;
+  const [head, ...rest] = values;
+  const found = options.find((o) => o.value === head);
+  if (!found) return null;
+  if (!rest.length) return [found];
+  if (!((_a = found.children) == null ? void 0 : _a.length)) return null;
+  const subPath = findPathByValues(found.children, rest);
+  return subPath ? [found, ...subPath] : null;
+};
+function useCascader(props2, ctx) {
+  const optionsRef = toRef(() => props2.options ?? []);
+  const modelValueRef = toRef(() => props2.modelValue ?? []);
+  const multipleRef = toRef(() => props2.multiple ?? false);
+  const isOpen = ref(false);
+  const searchQuery = ref("");
+  const activePath = ref([]);
+  const columns = computed(() => {
+    var _a;
+    const cols = [optionsRef.value];
+    for (const node of activePath.value) {
+      if ((_a = node.children) == null ? void 0 : _a.length) {
+        cols.push(node.children);
+      }
+    }
+    return cols;
+  });
+  const flatOptions = computed(() => {
+    if (!props2.filterable) return [];
+    return flattenOptions(optionsRef.value);
+  });
+  const filteredOptions = computed(() => {
+    if (!searchQuery.value) return flatOptions.value;
+    const q = searchQuery.value.toLowerCase();
+    return flatOptions.value.filter(
+      (item) => item.pathLabel.toLowerCase().includes(q)
+    );
+  });
+  const isSearching = computed(() => props2.filterable && searchQuery.value.length > 0);
+  const selectedPath = computed(() => {
+    if (multipleRef.value) return [];
+    const mv = modelValueRef.value;
+    if (!mv.length) return [];
+    return findPathByValues(optionsRef.value, mv) ?? [];
+  });
+  const selectedPaths = computed(() => {
+    if (!multipleRef.value) return [];
+    const mv = modelValueRef.value;
+    return mv.map((vals) => findPathByValues(optionsRef.value, vals)).filter((p) => p !== null);
+  });
+  const displayLabel = computed(() => {
+    var _a;
+    if (multipleRef.value) return "";
+    if (!selectedPath.value.length) return "";
+    if (props2.showAllLevels) {
+      return selectedPath.value.map((o) => o.label).join(` ${props2.separator ?? "/"} `);
+    }
+    return ((_a = selectedPath.value[selectedPath.value.length - 1]) == null ? void 0 : _a.label) ?? "";
+  });
+  const selectedTags = computed(() => {
+    if (!multipleRef.value) return [];
+    return selectedPaths.value.map((path) => {
+      var _a;
+      if (props2.showAllLevels) {
+        return path.map((o) => o.label).join(` ${props2.separator ?? "/"} `);
+      }
+      return ((_a = path[path.length - 1]) == null ? void 0 : _a.label) ?? "";
+    });
+  });
+  const initActivePath = () => {
+    if (multipleRef.value || !selectedPath.value.length) {
+      activePath.value = [];
+      return;
+    }
+    activePath.value = selectedPath.value.slice(0, -1);
+  };
+  const open = () => {
+    if (props2.disabled) return;
+    initActivePath();
+    isOpen.value = true;
+  };
+  const close = () => {
+    isOpen.value = false;
+    searchQuery.value = "";
+  };
+  const onTriggerClick = () => {
+    if (isOpen.value) {
+      close();
+    } else {
+      open();
+    }
+  };
+  const onOptionEnter = (option, colIndex) => {
+    if (option.disabled) return;
+    activePath.value = [...activePath.value.slice(0, colIndex), option];
+  };
+  const onOptionClick = (option, colIndex) => {
+    var _a;
+    if (option.disabled) return;
+    onOptionEnter(option, colIndex);
+    const isLeaf = !((_a = option.children) == null ? void 0 : _a.length) || option.leaf;
+    if (!isLeaf) return;
+    const fullPath = [...activePath.value.slice(0, colIndex), option];
+    const valuePath = fullPath.map((o) => o.value);
+    if (multipleRef.value) {
+      const currentMv = modelValueRef.value ?? [];
+      const existIndex = currentMv.findIndex(
+        (p) => p.length === valuePath.length && p.every((v, i) => v === valuePath[i])
+      );
+      let newMv;
+      if (existIndex >= 0) {
+        newMv = currentMv.filter((_, i) => i !== existIndex);
+      } else {
+        newMv = [...currentMv, valuePath];
+      }
+      ctx.emit("update:modelValue", newMv);
+      ctx.emit("change", newMv);
+    } else {
+      ctx.emit("update:modelValue", valuePath);
+      ctx.emit("change", valuePath);
+      close();
+    }
+  };
+  const onFlatOptionClick = (item) => {
+    const valuePath = item.path.map((o) => o.value);
+    if (multipleRef.value) {
+      const currentMv = modelValueRef.value ?? [];
+      const existIndex = currentMv.findIndex(
+        (p) => p.length === valuePath.length && p.every((v, i) => v === valuePath[i])
+      );
+      let newMv;
+      if (existIndex >= 0) {
+        newMv = currentMv.filter((_, i) => i !== existIndex);
+      } else {
+        newMv = [...currentMv, valuePath];
+      }
+      ctx.emit("update:modelValue", newMv);
+      ctx.emit("change", newMv);
+    } else {
+      ctx.emit("update:modelValue", valuePath);
+      ctx.emit("change", valuePath);
+      close();
+    }
+  };
+  const onDeleteTag = (tagIndex) => {
+    const currentMv = modelValueRef.value ?? [];
+    const newMv = currentMv.filter((_, i) => i !== tagIndex);
+    ctx.emit("update:modelValue", newMv);
+    ctx.emit("change", newMv);
+  };
+  const onClear = (e) => {
+    e.stopPropagation();
+    const emptyValue = multipleRef.value ? [] : [];
+    ctx.emit("update:modelValue", emptyValue);
+    ctx.emit("change", emptyValue);
+    close();
+  };
+  const isActiveOption = (option, colIndex) => {
+    var _a;
+    return ((_a = activePath.value[colIndex]) == null ? void 0 : _a.value) === option.value;
+  };
+  const isSelectedOption = (option, colIndex) => {
+    var _a;
+    if (multipleRef.value) {
+      return selectedPaths.value.some((path) => {
+        var _a2;
+        return ((_a2 = path[colIndex]) == null ? void 0 : _a2.value) === option.value;
+      });
+    }
+    return ((_a = selectedPath.value[colIndex]) == null ? void 0 : _a.value) === option.value;
+  };
+  const isFlatOptionSelected = (item) => {
+    const valuePath = item.path.map((o) => o.value);
+    if (multipleRef.value) {
+      const currentMv = modelValueRef.value ?? [];
+      return currentMv.some(
+        (p) => p.length === valuePath.length && p.every((v, i) => v === valuePath[i])
+      );
+    }
+    const mv = modelValueRef.value;
+    return mv.length === valuePath.length && valuePath.every((v, i) => v === mv[i]);
+  };
+  watch(activePath, (newPath) => {
+    ctx.emit("expandChange", newPath.map((o) => o.value));
+  });
+  return {
+    // 状态
+    isOpen,
+    searchQuery,
+    activePath,
+    // 计算
+    columns,
+    filteredOptions,
+    isSearching,
+    selectedPath,
+    selectedPaths,
+    displayLabel,
+    selectedTags,
+    // 事件
+    open,
+    close,
+    onTriggerClick,
+    onOptionEnter,
+    onOptionClick,
+    onFlatOptionClick,
+    onDeleteTag,
+    onClear,
+    // 工具
+    isActiveOption,
+    isSelectedOption,
+    isFlatOptionSelected
+  };
+}
+const CascaderCore = {
+  props: props$5,
+  useCascader
+};
+const props$4 = {
+  modelValue: { type: Array, default: () => [] },
+  data: { type: Array, default: () => [] },
+  titles: { type: Array, default: () => ["源列表", "目标列表"] },
+  filterable: { type: Boolean, default: false },
+  filterPlaceholder: { type: String, default: "请输入搜索内容" }
+};
+function useTransfer(props2, ctx) {
+  const dataRef = toRef(() => props2.data ?? []);
+  const modelValueRef = toRef(() => props2.modelValue ?? []);
+  const leftSearch = ref("");
+  const rightSearch = ref("");
+  const leftChecked = ref(/* @__PURE__ */ new Set());
+  const rightChecked = ref(/* @__PURE__ */ new Set());
+  const rightData = computed(() => {
+    const rightKeys = new Set(modelValueRef.value);
+    return dataRef.value.filter((item) => rightKeys.has(item.key));
+  });
+  const leftData = computed(() => {
+    const rightKeys = new Set(modelValueRef.value);
+    return dataRef.value.filter((item) => !rightKeys.has(item.key));
+  });
+  const filteredLeftData = computed(() => {
+    if (!props2.filterable || !leftSearch.value) return leftData.value;
+    const q = leftSearch.value.toLowerCase();
+    return leftData.value.filter((item) => item.label.toLowerCase().includes(q));
+  });
+  const filteredRightData = computed(() => {
+    if (!props2.filterable || !rightSearch.value) return rightData.value;
+    const q = rightSearch.value.toLowerCase();
+    return rightData.value.filter((item) => item.label.toLowerCase().includes(q));
+  });
+  const isLeftAllChecked = computed(() => {
+    const checkable = filteredLeftData.value.filter((item) => !item.disabled);
+    return checkable.length > 0 && checkable.every((item) => leftChecked.value.has(item.key));
+  });
+  const isLeftIndeterminate = computed(() => {
+    const checkable = filteredLeftData.value.filter((item) => !item.disabled);
+    const checkedCount = checkable.filter((item) => leftChecked.value.has(item.key)).length;
+    return checkedCount > 0 && checkedCount < checkable.length;
+  });
+  const isRightAllChecked = computed(() => {
+    const checkable = filteredRightData.value.filter((item) => !item.disabled);
+    return checkable.length > 0 && checkable.every((item) => rightChecked.value.has(item.key));
+  });
+  const isRightIndeterminate = computed(() => {
+    const checkable = filteredRightData.value.filter((item) => !item.disabled);
+    const checkedCount = checkable.filter((item) => rightChecked.value.has(item.key)).length;
+    return checkedCount > 0 && checkedCount < checkable.length;
+  });
+  const toggleLeftCheck = (key, disabled) => {
+    if (disabled) return;
+    const newSet = new Set(leftChecked.value);
+    if (newSet.has(key)) {
+      newSet.delete(key);
+    } else {
+      newSet.add(key);
+    }
+    leftChecked.value = newSet;
+  };
+  const toggleRightCheck = (key, disabled) => {
+    if (disabled) return;
+    const newSet = new Set(rightChecked.value);
+    if (newSet.has(key)) {
+      newSet.delete(key);
+    } else {
+      newSet.add(key);
+    }
+    rightChecked.value = newSet;
+  };
+  const toggleLeftAll = () => {
+    const checkable = filteredLeftData.value.filter((item) => !item.disabled);
+    if (isLeftAllChecked.value) {
+      const newSet = new Set(leftChecked.value);
+      checkable.forEach((item) => newSet.delete(item.key));
+      leftChecked.value = newSet;
+    } else {
+      const newSet = new Set(leftChecked.value);
+      checkable.forEach((item) => newSet.add(item.key));
+      leftChecked.value = newSet;
+    }
+  };
+  const toggleRightAll = () => {
+    const checkable = filteredRightData.value.filter((item) => !item.disabled);
+    if (isRightAllChecked.value) {
+      const newSet = new Set(rightChecked.value);
+      checkable.forEach((item) => newSet.delete(item.key));
+      rightChecked.value = newSet;
+    } else {
+      const newSet = new Set(rightChecked.value);
+      checkable.forEach((item) => newSet.add(item.key));
+      rightChecked.value = newSet;
+    }
+  };
+  const moveToRight = () => {
+    if (!leftChecked.value.size) return;
+    const movedKeys = [...leftChecked.value];
+    const newModelValue = [...modelValueRef.value, ...movedKeys];
+    ctx.emit("update:modelValue", newModelValue);
+    ctx.emit("change", newModelValue, "right", movedKeys);
+    leftChecked.value = /* @__PURE__ */ new Set();
+  };
+  const moveToLeft = () => {
+    if (!rightChecked.value.size) return;
+    const movedKeys = [...rightChecked.value];
+    const movedSet = new Set(movedKeys);
+    const newModelValue = modelValueRef.value.filter((key) => !movedSet.has(key));
+    ctx.emit("update:modelValue", newModelValue);
+    ctx.emit("change", newModelValue, "left", movedKeys);
+    rightChecked.value = /* @__PURE__ */ new Set();
+  };
+  const hasLeftChecked = computed(() => leftChecked.value.size > 0);
+  const hasRightChecked = computed(() => rightChecked.value.size > 0);
+  return {
+    // 搜索
+    leftSearch,
+    rightSearch,
+    // 数据
+    leftData,
+    rightData,
+    filteredLeftData,
+    filteredRightData,
+    // 勾选状态
+    leftChecked,
+    rightChecked,
+    hasLeftChecked,
+    hasRightChecked,
+    // 全选
+    isLeftAllChecked,
+    isLeftIndeterminate,
+    isRightAllChecked,
+    isRightIndeterminate,
+    // 事件
+    toggleLeftCheck,
+    toggleRightCheck,
+    toggleLeftAll,
+    toggleRightAll,
+    moveToRight,
+    moveToLeft
+  };
+}
+const TransferCore = {
+  props: props$4,
+  useTransfer
+};
+const props$3 = {
+  modelValue: { type: Number, default: 0 },
+  count: { type: Number, default: 5 },
+  allowHalf: { type: Boolean, default: false },
+  readonly: { type: Boolean, default: false },
+  disabled: { type: Boolean, default: false }
+};
+function useRate(props2, emit) {
+  const hoverValue = ref(null);
+  const getValueFromEvent = (e, index) => {
+    if (!props2.allowHalf) {
+      return index + 1;
+    }
+    const target = e.currentTarget;
+    const { left, width } = target.getBoundingClientRect();
+    const isHalf = (e.clientX - left) / width <= 0.5;
+    return isHalf ? index + 0.5 : index + 1;
+  };
+  const onMouseEnter = (e, index) => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    hoverValue.value = getValueFromEvent(e, index);
+  };
+  const onMouseMove = (e, index) => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    hoverValue.value = getValueFromEvent(e, index);
+  };
+  const onMouseLeave = () => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    hoverValue.value = null;
+  };
+  const onClick = (e, index) => {
+    if (props2.disabled || props2.readonly) {
+      return;
+    }
+    const value = getValueFromEvent(e, index);
+    emit("update:modelValue", value);
+    emit("change", value);
+  };
+  const getStarState = (index) => {
+    const current = hoverValue.value ?? props2.modelValue;
+    const starValue = index + 1;
+    if (current >= starValue) {
+      return "full";
+    }
+    if (props2.allowHalf && current >= starValue - 0.5) {
+      return "half";
+    }
+    return "empty";
+  };
+  return {
+    hoverValue,
+    getStarState,
+    onMouseEnter,
+    onMouseMove,
+    onMouseLeave,
+    onClick
+  };
+}
+const RateCore = {
+  props: props$3,
+  useRate
+};
+const props$2 = {
+  target: { type: String, default: "" },
+  visibilityHeight: { type: Number, default: 200 },
+  right: { type: Number, default: 40 },
+  bottom: { type: Number, default: 40 }
+};
+function useBackTop(props2) {
+  const visible = ref(false);
+  const getScrollTarget = () => {
+    if (props2.target) {
+      const el = document.querySelector(props2.target);
+      if (el) {
+        return el;
+      }
+    }
+    return window;
+  };
+  const getScrollTop = () => {
+    const target = getScrollTarget();
+    if (target === window) {
+      return window.scrollY;
+    }
+    return target.scrollTop;
+  };
+  const onScroll = () => {
+    visible.value = getScrollTop() >= props2.visibilityHeight;
+  };
+  const scrollToTop = () => {
+    const target = getScrollTarget();
+    if (target === window) {
+      window.scrollTo({ top: 0, behavior: "smooth" });
+    } else {
+      target.scrollTo({ top: 0, behavior: "smooth" });
+    }
+  };
+  onMounted(() => {
+    const target = getScrollTarget();
+    target.addEventListener("scroll", onScroll, { passive: true });
+    onScroll();
+  });
+  onUnmounted(() => {
+    const target = getScrollTarget();
+    target.removeEventListener("scroll", onScroll);
+  });
+  return {
+    visible,
+    scrollToTop
+  };
+}
+const BackTopCore = {
+  props: props$2,
+  useBackTop
+};
+const props$1 = {
+  offsetTop: { type: Number, default: void 0 },
+  offsetBottom: { type: Number, default: void 0 },
+  target: { type: String, default: "" }
+};
+function useAffix(props2, emit) {
+  const affixed = ref(false);
+  const placeholderHeight = ref(0);
+  const affixStyle = ref({});
+  const wrapRef = ref(null);
+  const getScrollTarget = () => {
+    if (props2.target) {
+      const el = document.querySelector(props2.target);
+      if (el) {
+        return el;
+      }
+    }
+    return window;
+  };
+  const getContainerRect = () => {
+    const t = getScrollTarget();
+    if (t === window) {
+      return new DOMRect(0, 0, window.innerWidth, window.innerHeight);
+    }
+    return t.getBoundingClientRect();
+  };
+  const update = () => {
+    if (!wrapRef.value) {
+      return;
+    }
+    const wrapRect = wrapRef.value.getBoundingClientRect();
+    const containerRect = getContainerRect();
+    let shouldAffix = false;
+    const style = {};
+    if (props2.offsetTop !== void 0) {
+      const threshold = containerRect.top + props2.offsetTop;
+      if (wrapRect.top < threshold) {
+        shouldAffix = true;
+        style.position = "fixed";
+        style.top = `${containerRect.top + props2.offsetTop}px`;
+        style.width = `${wrapRect.width}px`;
+        style.zIndex = "100";
+      }
+    } else if (props2.offsetBottom !== void 0) {
+      const threshold = containerRect.bottom - props2.offsetBottom;
+      if (wrapRect.bottom > threshold) {
+        shouldAffix = true;
+        style.position = "fixed";
+        style.bottom = `${window.innerHeight - containerRect.bottom + props2.offsetBottom}px`;
+        style.width = `${wrapRect.width}px`;
+        style.zIndex = "100";
+      }
+    }
+    if (shouldAffix !== affixed.value) {
+      if (shouldAffix) {
+        placeholderHeight.value = wrapRect.height;
+      } else {
+        placeholderHeight.value = 0;
+      }
+      affixed.value = shouldAffix;
+      emit("change", shouldAffix);
+    }
+    affixStyle.value = shouldAffix ? style : {};
+  };
+  onMounted(() => {
+    const target = getScrollTarget();
+    target.addEventListener("scroll", update, { passive: true });
+    window.addEventListener("resize", update, { passive: true });
+    update();
+  });
+  onUnmounted(() => {
+    const target = getScrollTarget();
+    target.removeEventListener("scroll", update);
+    window.removeEventListener("resize", update);
+  });
+  return {
+    wrapRef,
+    affixed,
+    affixStyle,
+    placeholderHeight
+  };
+}
+const AffixCore = {
+  props: props$1,
+  useAffix
+};
+const props = {
+  offsetTop: { type: Number, default: 0 },
+  bounds: { type: Number, default: 5 }
+};
+const anchorLinkProps = {
+  href: { type: String, required: true },
+  title: { type: String, default: "" }
+};
+function useAnchor(props2, emit) {
+  const currentLink = ref("");
+  const links = ref([]);
+  const registerLink = (href) => {
+    if (!links.value.includes(href)) {
+      links.value.push(href);
+    }
+  };
+  const unregisterLink = (href) => {
+    const idx = links.value.indexOf(href);
+    if (idx !== -1) {
+      links.value.splice(idx, 1);
+    }
+  };
+  const getTargetEl = (href) => {
+    if (!href.startsWith("#")) {
+      return null;
+    }
+    return document.querySelector(href);
+  };
+  const onScroll = () => {
+    const scrollTop = window.scrollY + props2.offsetTop + props2.bounds;
+    let active = "";
+    for (let i = links.value.length - 1; i >= 0; i--) {
+      const href = links.value[i];
+      const el = getTargetEl(href);
+      if (el && el.offsetTop <= scrollTop) {
+        active = href;
+        break;
+      }
+    }
+    if (active !== currentLink.value) {
+      currentLink.value = active;
+      emit("change", active);
+    }
+  };
+  const handleClick = (href) => {
+    emit("click", href);
+    const el = getTargetEl(href);
+    if (el) {
+      const top = el.offsetTop - props2.offsetTop;
+      window.scrollTo({ top, behavior: "smooth" });
+    }
+  };
+  onMounted(() => {
+    window.addEventListener("scroll", onScroll, { passive: true });
+    onScroll();
+  });
+  onUnmounted(() => {
+    window.removeEventListener("scroll", onScroll);
+  });
+  return {
+    currentLink,
+    registerLink,
+    unregisterLink,
+    handleClick
+  };
+}
+const AnchorCore = {
+  props,
+  anchorLinkProps,
+  useAnchor
+};
+export {
+  AffixCore,
+  AlertCore,
+  AnchorCore,
+  AutoCompleteCore,
+  AvatarCore,
+  BASE_MONTH_NAME,
+  BASE_WEEK_NAME,
+  BackTopCore,
+  BadgeCore,
+  BorderCore,
+  BreadcrumbCore,
+  ButtonCore,
+  CardCore,
+  CarouselCore,
+  CascaderCore,
+  CheckboxCore,
+  CollapseCore,
+  ConfirmCore,
+  DEFAULT_MENU_CONFIG,
+  DEFAULT_TREE_CONFIG,
+  DarkModeCore,
+  DatePickerCore,
+  DescriptionsCore,
+  DialogCore,
+  DividerCore,
+  DrawerCore,
+  DropdownCore,
+  EmptyCore,
+  FormCore,
+  GridCore,
+  ImageCore,
+  InputCore,
+  InputNumberCore,
+  LiCore,
+  ListCore,
+  LoadingCore,
+  MenuCore,
+  MessageCore,
+  MessagePopoverCore,
+  NotificationCore,
+  PaginationCore,
+  PopoverCore,
+  ProgressCore,
+  RadioCore,
+  RateCore,
+  ResultCore,
+  SelectCore,
+  SkeletonCore,
+  SliderCore,
+  SpaceCore,
+  StepsCore,
+  SwitchCore,
+  TableColumnCore,
+  TableCore,
+  TabsCore,
+  TagCore,
+  TimelineCore,
+  TooltipCore,
+  TransferCore,
+  Tree,
+  TreeCore,
+  VirtualListCore,
+  createRadioId,
+  fixKey,
+  generateTimeColumn,
+  getNewModelValue,
+  initChecked,
+  toDayjs,
+  treeNodeProps,
+  props$o as treeProps,
+  useDatePicker,
+  useMenu,
+  useMessageQueue,
+  useNotificationQueue,
+  usePagination,
+  useTable,
+  useTree,
+  useVirtualList
+};