"use strict";
(self["webpackChunkpj_process"] = self["webpackChunkpj_process"] || []).push([[4085],{

/***/ 28000:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "Z": () => (/* binding */ vc_tour_Tour),
  "w": () => (/* binding */ tourProps)
});

// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(62081);
// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 1 modules
var objectSpread2 = __webpack_require__(38295);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-core@3.3.1/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var runtime_core_esm_bundler = __webpack_require__(27520);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+reactivity@3.3.1/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
var reactivity_esm_bundler = __webpack_require__(83270);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-trigger/interface.js
var vc_trigger_interface = __webpack_require__(21916);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-trigger/index.js + 9 modules
var vc_trigger = __webpack_require__(63179);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/classNames.js
var classNames = __webpack_require__(64334);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/hooks/useMergedState.js
var useMergedState = __webpack_require__(7738);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/util.js
function isInViewPort(element) {
  const viewWidth = window.innerWidth || document.documentElement.clientWidth;
  const viewHeight = window.innerHeight || document.documentElement.clientHeight;
  const {
    top,
    right,
    bottom,
    left
  } = element.getBoundingClientRect();
  return top >= 0 && left >= 0 && right <= viewWidth && bottom <= viewHeight;
}
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/hooks/useState.js
var useState = __webpack_require__(3112);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/hooks/useTarget.js



function useTarget(target, open, gap, scrollIntoViewOptions) {
  // ========================= Target =========================
  // We trade `undefined` as not get target by function yet.
  // `null` as empty target.
  const [targetElement, setTargetElement] = (0,useState/* default */.Z)(undefined);
  (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
    const nextElement = typeof target.value === 'function' ? target.value() : target.value;
    setTargetElement(nextElement || null);
  }, {
    flush: 'post'
  });
  // ========================= Align ==========================
  const [posInfo, setPosInfo] = (0,useState/* default */.Z)(null);
  const updatePos = () => {
    if (!open.value) {
      setPosInfo(null);
      return;
    }
    if (targetElement.value) {
      // Exist target element. We should scroll and get target position
      if (!isInViewPort(targetElement.value) && open.value) {
        targetElement.value.scrollIntoView(scrollIntoViewOptions.value);
      }
      const {
        left,
        top,
        width,
        height
      } = targetElement.value.getBoundingClientRect();
      const nextPosInfo = {
        left,
        top,
        width,
        height,
        radius: 0
      };
      if (JSON.stringify(posInfo.value) !== JSON.stringify(nextPosInfo)) {
        setPosInfo(nextPosInfo);
      }
    } else {
      // Not exist target which means we just show in center
      setPosInfo(null);
    }
  };
  (0,runtime_core_esm_bundler/* onMounted */.bv)(() => {
    (0,runtime_core_esm_bundler/* watch */.YP)([open, targetElement], () => {
      updatePos();
    }, {
      flush: 'post',
      immediate: true
    });
    // update when window resize
    window.addEventListener('resize', updatePos);
  });
  (0,runtime_core_esm_bundler/* onBeforeUnmount */.Jd)(() => {
    window.removeEventListener('resize', updatePos);
  });
  // ======================== PosInfo =========================
  const mergedPosInfo = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
    var _a, _b;
    if (!posInfo.value) {
      return posInfo.value;
    }
    const gapOffset = ((_a = gap.value) === null || _a === void 0 ? void 0 : _a.offset) || 6;
    const gapRadius = ((_b = gap.value) === null || _b === void 0 ? void 0 : _b.radius) || 2;
    return {
      left: posInfo.value.left - gapOffset,
      top: posInfo.value.top - gapOffset,
      width: posInfo.value.width + gapOffset * 2,
      height: posInfo.value.height + gapOffset * 2,
      radius: gapRadius
    };
  });
  return [mergedPosInfo, targetElement];
}
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/interface.js
var vc_tour_interface = __webpack_require__(32625);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/TourStep/DefaultPanel.js





const DefaultPanel = (0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  name: 'DefaultPanel',
  inheritAttrs: false,
  props: (0,vc_tour_interface/* tourStepProps */.N)(),
  setup(props, _ref) {
    let {
      attrs
    } = _ref;
    return () => {
      const {
        prefixCls,
        current,
        total,
        title,
        description,
        onClose,
        onPrev,
        onNext,
        onFinish
      } = props;
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, attrs), {}, {
        "class": (0,classNames/* default */.Z)(`${prefixCls}-content`, attrs.class)
      }), [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-inner`
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("button", {
        "type": "button",
        "onClick": onClose,
        "aria-label": "Close",
        "class": `${prefixCls}-close`
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "class": `${prefixCls}-close-x`
      }, [(0,runtime_core_esm_bundler/* createTextVNode */.Uk)("\xD7")])]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-header`
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-title`
      }, [title])]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-description`
      }, [description]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-footer`
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-sliders`
      }, [total > 1 ? [...Array.from({
        length: total
      }).keys()].map((item, index) => {
        return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
          "key": item,
          "class": index === current ? 'active' : ''
        }, null);
      }) : null]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-buttons`
      }, [current !== 0 ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("button", {
        "class": `${prefixCls}-prev-btn`,
        "onClick": onPrev
      }, [(0,runtime_core_esm_bundler/* createTextVNode */.Uk)("Prev")]) : null, current === total - 1 ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("button", {
        "class": `${prefixCls}-finish-btn`,
        "onClick": onFinish
      }, [(0,runtime_core_esm_bundler/* createTextVNode */.Uk)("Finish")]) : (0,runtime_core_esm_bundler/* createVNode */.Wm)("button", {
        "class": `${prefixCls}-next-btn`,
        "onClick": onNext
      }, [(0,runtime_core_esm_bundler/* createTextVNode */.Uk)("Next")])])])])]);
    };
  }
});
/* harmony default export */ const TourStep_DefaultPanel = (DefaultPanel);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/TourStep/index.js






const TourStep = (0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  name: 'TourStep',
  inheritAttrs: false,
  props: (0,vc_tour_interface/* tourStepProps */.N)(),
  setup(props, _ref) {
    let {
      attrs
    } = _ref;
    return () => {
      const {
        current,
        renderPanel
      } = props;
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(runtime_core_esm_bundler/* Fragment */.HY, null, [typeof renderPanel === 'function' ? renderPanel((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, attrs), props), current) : (0,runtime_core_esm_bundler/* createVNode */.Wm)(TourStep_DefaultPanel, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, attrs), props), null)]);
    };
  }
});
/* harmony default export */ const vc_tour_TourStep = (TourStep);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/hooks/useId.js
var useId = __webpack_require__(99954);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/PortalWrapper.js + 1 modules
var PortalWrapper = __webpack_require__(82675);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/type.js
var type = __webpack_require__(29332);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/Mask.js







const COVER_PROPS = {
  fill: 'transparent',
  'pointer-events': 'auto'
};
const Mask = (0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  name: 'TourMask',
  props: {
    prefixCls: {
      type: String
    },
    pos: (0,type/* objectType */.$m)(),
    rootClassName: {
      type: String
    },
    showMask: (0,type/* booleanType */._9)(),
    fill: {
      type: String,
      default: 'rgba(0,0,0,0.5)'
    },
    open: (0,type/* booleanType */._9)(),
    animated: (0,type/* someType */.QE)([Boolean, Object]),
    zIndex: {
      type: Number
    }
  },
  setup(props, _ref) {
    let {
      attrs
    } = _ref;
    const id = (0,useId/* default */.ZP)();
    return () => {
      const {
        prefixCls,
        open,
        rootClassName,
        pos,
        showMask,
        fill,
        animated,
        zIndex
      } = props;
      const maskId = `${prefixCls}-mask-${id}`;
      const mergedAnimated = typeof animated === 'object' ? animated === null || animated === void 0 ? void 0 : animated.placeholder : animated;
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(PortalWrapper/* default */.Z, {
        "visible": open,
        "autoLock": true
      }, {
        default: () => open && (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, attrs), {}, {
          "class": (0,classNames/* default */.Z)(`${prefixCls}-mask`, rootClassName, attrs.class),
          "style": [{
            position: 'fixed',
            left: 0,
            right: 0,
            top: 0,
            bottom: 0,
            zIndex,
            pointerEvents: 'none'
          }, attrs.style]
        }), [showMask ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("svg", {
          "style": {
            width: '100%',
            height: '100%'
          }
        }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("defs", null, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("mask", {
          "id": maskId
        }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", {
          "x": "0",
          "y": "0",
          "width": "100vw",
          "height": "100vh",
          "fill": "white"
        }, null), pos && (0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", {
          "x": pos.left,
          "y": pos.top,
          "rx": pos.radius,
          "width": pos.width,
          "height": pos.height,
          "fill": "black",
          "class": mergedAnimated ? `${prefixCls}-placeholder-animated` : ''
        }, null)])]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", {
          "x": "0",
          "y": "0",
          "width": "100%",
          "height": "100%",
          "fill": fill,
          "mask": `url(#${maskId})`
        }, null), pos && (0,runtime_core_esm_bundler/* createVNode */.Wm)(runtime_core_esm_bundler/* Fragment */.HY, null, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, COVER_PROPS), {}, {
          "x": "0",
          "y": "0",
          "width": "100%",
          "height": pos.top
        }), null), (0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, COVER_PROPS), {}, {
          "x": "0",
          "y": "0",
          "width": pos.left,
          "height": "100%"
        }), null), (0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, COVER_PROPS), {}, {
          "x": "0",
          "y": pos.top + pos.height,
          "width": "100%",
          "height": `calc(100vh - ${pos.top + pos.height}px)`
        }), null), (0,runtime_core_esm_bundler/* createVNode */.Wm)("rect", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, COVER_PROPS), {}, {
          "x": pos.left + pos.width,
          "y": "0",
          "width": `calc(100vw - ${pos.left + pos.width}px)`,
          "height": "100%"
        }), null)])]) : null])
      });
    };
  }
});
/* harmony default export */ const vc_tour_Mask = (Mask);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/placements.js

const targetOffset = [0, 0];
const basePlacements = {
  left: {
    points: ['cr', 'cl'],
    offset: [-8, 0]
  },
  right: {
    points: ['cl', 'cr'],
    offset: [8, 0]
  },
  top: {
    points: ['bc', 'tc'],
    offset: [0, -8]
  },
  bottom: {
    points: ['tc', 'bc'],
    offset: [0, 8]
  },
  topLeft: {
    points: ['bl', 'tl'],
    offset: [0, -8]
  },
  leftTop: {
    points: ['tr', 'tl'],
    offset: [-8, 0]
  },
  topRight: {
    points: ['br', 'tr'],
    offset: [0, -8]
  },
  rightTop: {
    points: ['tl', 'tr'],
    offset: [8, 0]
  },
  bottomRight: {
    points: ['tr', 'br'],
    offset: [0, 8]
  },
  rightBottom: {
    points: ['bl', 'br'],
    offset: [8, 0]
  },
  bottomLeft: {
    points: ['tl', 'bl'],
    offset: [0, 8]
  },
  leftBottom: {
    points: ['br', 'bl'],
    offset: [-8, 0]
  }
};
function getPlacements() {
  let arrowPointAtCenter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
  const placements = {};
  Object.keys(basePlacements).forEach(key => {
    placements[key] = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, basePlacements[key]), {
      autoArrow: arrowPointAtCenter,
      targetOffset
    });
  });
  return placements;
}
const placements = getPlacements();
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/initDefaultProps.js
var initDefaultProps = __webpack_require__(57206);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tour/Tour.js



var __rest = undefined && undefined.__rest || function (s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
};











const CENTER_PLACEHOLDER = {
  left: '50%',
  top: '50%',
  width: '1px',
  height: '1px'
};
const tourProps = () => {
  const {
    builtinPlacements,
    popupAlign
  } = (0,vc_trigger_interface/* triggerProps */.d)();
  return {
    builtinPlacements,
    popupAlign,
    steps: (0,type/* arrayType */.Mx)(),
    open: (0,type/* booleanType */._9)(),
    defaultCurrent: {
      type: Number
    },
    current: {
      type: Number
    },
    onChange: (0,type/* functionType */.Qy)(),
    onClose: (0,type/* functionType */.Qy)(),
    onFinish: (0,type/* functionType */.Qy)(),
    mask: (0,type/* someType */.QE)([Boolean, Object], true),
    arrow: (0,type/* someType */.QE)([Boolean, Object], true),
    rootClassName: {
      type: String
    },
    placement: (0,type/* stringType */.sk)('bottom'),
    prefixCls: {
      type: String,
      default: 'rc-tour'
    },
    renderPanel: (0,type/* functionType */.Qy)(),
    gap: (0,type/* objectType */.$m)(),
    animated: (0,type/* someType */.QE)([Boolean, Object]),
    scrollIntoViewOptions: (0,type/* someType */.QE)([Boolean, Object], true),
    zIndex: {
      type: Number,
      default: 1001
    }
  };
};
const Tour = (0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  name: 'Tour',
  inheritAttrs: false,
  props: (0,initDefaultProps/* default */.Z)(tourProps(), {}),
  setup(props) {
    const {
      defaultCurrent,
      placement,
      mask,
      scrollIntoViewOptions,
      open,
      gap,
      arrow
    } = (0,reactivity_esm_bundler/* toRefs */.BK)(props);
    const triggerRef = (0,reactivity_esm_bundler/* ref */.iH)();
    const [mergedCurrent, setMergedCurrent] = (0,useMergedState/* default */.Z)(0, {
      value: (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.current),
      defaultValue: defaultCurrent.value
    });
    const [mergedOpen, setMergedOpen] = (0,useMergedState/* default */.Z)(undefined, {
      value: (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.open),
      postState: origin => mergedCurrent.value < 0 || mergedCurrent.value >= props.steps.length ? false : origin !== null && origin !== void 0 ? origin : true
    });
    const openRef = (0,reactivity_esm_bundler/* shallowRef */.XI)(mergedOpen.value);
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      if (mergedOpen.value && !openRef.value) {
        setMergedCurrent(0);
      }
      openRef.value = mergedOpen.value;
    });
    const curStep = (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.steps[mergedCurrent.value] || {});
    const mergedPlacement = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      var _a;
      return (_a = curStep.value.placement) !== null && _a !== void 0 ? _a : placement.value;
    });
    const mergedMask = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      var _a;
      return mergedOpen.value && ((_a = curStep.value.mask) !== null && _a !== void 0 ? _a : mask.value);
    });
    const mergedScrollIntoViewOptions = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      var _a;
      return (_a = curStep.value.scrollIntoViewOptions) !== null && _a !== void 0 ? _a : scrollIntoViewOptions.value;
    });
    const [posInfo, targetElement] = useTarget((0,runtime_core_esm_bundler/* computed */.Fl)(() => curStep.value.target), open, gap, mergedScrollIntoViewOptions);
    // ========================= arrow =========================
    const mergedArrow = (0,runtime_core_esm_bundler/* computed */.Fl)(() => targetElement.value ? typeof curStep.value.arrow === 'undefined' ? arrow.value : curStep.value.arrow : false);
    const arrowPointAtCenter = (0,runtime_core_esm_bundler/* computed */.Fl)(() => typeof mergedArrow.value === 'object' ? mergedArrow.value.pointAtCenter : false);
    (0,runtime_core_esm_bundler/* watch */.YP)(arrowPointAtCenter, () => {
      var _a;
      (_a = triggerRef.value) === null || _a === void 0 ? void 0 : _a.forcePopupAlign();
    });
    (0,runtime_core_esm_bundler/* watch */.YP)(mergedCurrent, () => {
      var _a;
      (_a = triggerRef.value) === null || _a === void 0 ? void 0 : _a.forcePopupAlign();
    });
    // ========================= Change =========================
    const onInternalChange = nextCurrent => {
      var _a;
      setMergedCurrent(nextCurrent);
      (_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, nextCurrent);
    };
    return () => {
      var _a;
      const {
          prefixCls,
          steps,
          onClose,
          onFinish,
          rootClassName,
          renderPanel,
          animated,
          zIndex
        } = props,
        restProps = __rest(props, ["prefixCls", "steps", "onClose", "onFinish", "rootClassName", "renderPanel", "animated", "zIndex"]);
      // ========================= Render =========================
      // Skip if not init yet
      if (targetElement.value === undefined) {
        return null;
      }
      const handleClose = () => {
        setMergedOpen(false);
        onClose === null || onClose === void 0 ? void 0 : onClose(mergedCurrent.value);
      };
      const mergedShowMask = typeof mergedMask.value === 'boolean' ? mergedMask.value : !!mergedMask.value;
      const mergedMaskStyle = typeof mergedMask.value === 'boolean' ? undefined : mergedMask.value;
      // when targetElement is not exist, use body as triggerDOMNode
      const getTriggerDOMNode = () => {
        return targetElement.value || document.body;
      };
      const getPopupElement = () => (0,runtime_core_esm_bundler/* createVNode */.Wm)(vc_tour_TourStep, (0,objectSpread2/* default */.Z)({
        "arrow": mergedArrow.value,
        "key": "content",
        "prefixCls": prefixCls,
        "total": steps.length,
        "renderPanel": renderPanel,
        "onPrev": () => {
          onInternalChange(mergedCurrent.value - 1);
        },
        "onNext": () => {
          onInternalChange(mergedCurrent.value + 1);
        },
        "onClose": handleClose,
        "current": mergedCurrent.value,
        "onFinish": () => {
          handleClose();
          onFinish === null || onFinish === void 0 ? void 0 : onFinish();
        }
      }, curStep.value), null);
      const posInfoStyle = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
        const info = posInfo.value || CENTER_PLACEHOLDER;
        // 如果info[key] 是number，添加 px
        const style = {};
        Object.keys(info).forEach(key => {
          if (typeof info[key] === 'number') {
            style[key] = `${info[key]}px`;
          } else {
            style[key] = info[key];
          }
        });
        return style;
      });
      return mergedOpen.value ? (0,runtime_core_esm_bundler/* createVNode */.Wm)(runtime_core_esm_bundler/* Fragment */.HY, null, [(0,runtime_core_esm_bundler/* createVNode */.Wm)(vc_tour_Mask, {
        "zIndex": zIndex,
        "prefixCls": prefixCls,
        "pos": posInfo.value,
        "showMask": mergedShowMask,
        "style": mergedMaskStyle === null || mergedMaskStyle === void 0 ? void 0 : mergedMaskStyle.style,
        "fill": mergedMaskStyle === null || mergedMaskStyle === void 0 ? void 0 : mergedMaskStyle.color,
        "open": mergedOpen.value,
        "animated": animated,
        "rootClassName": rootClassName
      }, null), (0,runtime_core_esm_bundler/* createVNode */.Wm)(vc_trigger/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, restProps), {}, {
        "arrow": !!restProps.arrow,
        "builtinPlacements": !curStep.value.target ? undefined : (_a = restProps.builtinPlacements) !== null && _a !== void 0 ? _a : getPlacements(arrowPointAtCenter.value),
        "ref": triggerRef,
        "popupStyle": !curStep.value.target ? (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, curStep.value.style), {
          position: 'fixed',
          left: CENTER_PLACEHOLDER.left,
          top: CENTER_PLACEHOLDER.top,
          transform: 'translate(-50%, -50%)'
        }) : curStep.value.style,
        "popupPlacement": mergedPlacement.value,
        "popupVisible": mergedOpen.value,
        "popupClassName": (0,classNames/* default */.Z)(rootClassName, curStep.value.className),
        "prefixCls": prefixCls,
        "popup": getPopupElement,
        "forceRender": false,
        "destroyPopupOnHide": true,
        "zIndex": zIndex,
        "mask": false,
        "getTriggerDOMNode": getTriggerDOMNode
      }), {
        default: () => [(0,runtime_core_esm_bundler/* createVNode */.Wm)(PortalWrapper/* default */.Z, {
          "visible": mergedOpen.value,
          "autoLock": true
        }, {
          default: () => [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
            "class": (0,classNames/* default */.Z)(rootClassName, `${prefixCls}-target-placeholder`),
            "style": (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, posInfoStyle.value), {
              position: 'fixed',
              pointerEvents: 'none'
            })
          }, null)]
        })]
      })]) : null;
    };
  }
});
/* harmony default export */ const vc_tour_Tour = (Tour);

/***/ }),

/***/ 50301:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "ZP": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _Tour__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28000);



/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_Tour__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z);

/***/ }),

/***/ 32625:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "N": () => (/* binding */ tourStepProps)
/* harmony export */ });
/* unused harmony export tourStepInfo */
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62081);
/* harmony import */ var _util_type__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29332);


const tourStepInfo = () => ({
  arrow: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([Boolean, Object]),
  target: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([String, Function, Object]),
  title: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([String, Object]),
  description: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([String, Object]),
  placement: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .stringType */ .sk)(),
  mask: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([Object, Boolean], true),
  className: {
    type: String
  },
  style: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .objectType */ .$m)(),
  scrollIntoViewOptions: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .someType */ .QE)([Boolean, Object])
});
const tourStepProps = () => (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)({}, tourStepInfo()), {
  prefixCls: {
    type: String
  },
  total: {
    type: Number
  },
  current: {
    type: Number
  },
  onClose: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .functionType */ .Qy)(),
  onFinish: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .functionType */ .Qy)(),
  renderPanel: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .functionType */ .Qy)(),
  onPrev: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .functionType */ .Qy)(),
  onNext: (0,_util_type__WEBPACK_IMPORTED_MODULE_0__/* .functionType */ .Qy)()
});

/***/ }),

/***/ 7104:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (/* binding */ useInjectLegacySelectContext),
/* harmony export */   "p": () => (/* binding */ useProvideLegacySelectContext)
/* harmony export */ });
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27520);
/**
 * BaseSelect provide some parsed data into context.
 * You can use this hooks to get them.
 */

const TreeSelectLegacyContextPropsKey = Symbol('TreeSelectLegacyContextPropsKey');
// export const LegacySelectContext = defineComponent({
//  compatConfig: { MODE: 3 },
//   name: 'SelectContext',
//   props: {
//     value: { type: Object as PropType<LegacyContextProps> },
//   },
//   setup(props, { slots }) {
//     provide(
//       TreeSelectLegacyContextPropsKey,
//       computed(() => props.value),
//     );
//     return () => slots.default?.();
//   },
// });
function useProvideLegacySelectContext(props) {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .provide */ .JJ)(TreeSelectLegacyContextPropsKey, props);
}
function useInjectLegacySelectContext() {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .inject */ .f3)(TreeSelectLegacyContextPropsKey, {});
}

/***/ }),

/***/ 16424:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* istanbul ignore file */
/** This is a placeholder, not real render in dom */
const TreeNode = () => null;
TreeNode.inheritAttrs = false;
TreeNode.displayName = 'ATreeSelectNode';
TreeNode.isTreeSelectNode = true;
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (TreeNode);

/***/ }),

/***/ 87973:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "Z": () => (/* binding */ TreeSelect),
  "s": () => (/* binding */ treeSelectProps)
});

// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 1 modules
var objectSpread2 = __webpack_require__(38295);
// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(62081);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-core@3.3.1/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var runtime_core_esm_bundler = __webpack_require__(27520);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+reactivity@3.3.1/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
var reactivity_esm_bundler = __webpack_require__(83270);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/hooks/useMemo.js
var useMemo = __webpack_require__(83474);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/KeyCode.js
var KeyCode = __webpack_require__(64776);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/Tree.js + 3 modules
var Tree = __webpack_require__(73266);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/utils/valueUtil.js
var valueUtil = __webpack_require__(63709);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-select/hooks/useBaseProps.js
var useBaseProps = __webpack_require__(94438);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/LegacyContext.js
var LegacyContext = __webpack_require__(7104);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/TreeSelectContext.js

const TreeSelectContextPropsKey = Symbol('TreeSelectContextPropsKey');
function useProvideSelectContext(props) {
  return (0,runtime_core_esm_bundler/* provide */.JJ)(TreeSelectContextPropsKey, props);
}
function useInjectSelectContext() {
  return (0,runtime_core_esm_bundler/* inject */.f3)(TreeSelectContextPropsKey, {});
}
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/OptionList.js











const HIDDEN_STYLE = {
  width: 0,
  height: 0,
  display: 'flex',
  overflow: 'hidden',
  opacity: 0,
  border: 0,
  padding: 0,
  margin: 0
};
/* harmony default export */ const OptionList = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'OptionList',
  inheritAttrs: false,
  setup(_, _ref) {
    let {
      slots,
      expose
    } = _ref;
    const baseProps = (0,useBaseProps/* default */.Z)();
    const legacyContext = (0,LegacyContext/* default */.Z)();
    const context = useInjectSelectContext();
    const treeRef = (0,reactivity_esm_bundler/* ref */.iH)();
    const memoTreeData = (0,useMemo/* default */.Z)(() => context.treeData, [() => baseProps.open, () => context.treeData], next => next[0]);
    const mergedCheckedKeys = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        checkable,
        halfCheckedKeys,
        checkedKeys
      } = legacyContext;
      if (!checkable) {
        return null;
      }
      return {
        checked: checkedKeys,
        halfChecked: halfCheckedKeys
      };
    });
    (0,runtime_core_esm_bundler/* watch */.YP)(() => baseProps.open, () => {
      (0,runtime_core_esm_bundler/* nextTick */.Y3)(() => {
        var _a;
        if (baseProps.open && !baseProps.multiple && legacyContext.checkedKeys.length) {
          (_a = treeRef.value) === null || _a === void 0 ? void 0 : _a.scrollTo({
            key: legacyContext.checkedKeys[0]
          });
        }
      });
    }, {
      immediate: true,
      flush: 'post'
    });
    // ========================== Search ==========================
    const lowerSearchValue = (0,runtime_core_esm_bundler/* computed */.Fl)(() => String(baseProps.searchValue).toLowerCase());
    const filterTreeNode = treeNode => {
      if (!lowerSearchValue.value) {
        return false;
      }
      return String(treeNode[legacyContext.treeNodeFilterProp]).toLowerCase().includes(lowerSearchValue.value);
    };
    // =========================== Keys ===========================
    const expandedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)(legacyContext.treeDefaultExpandedKeys);
    const searchExpandedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)(null);
    (0,runtime_core_esm_bundler/* watch */.YP)(() => baseProps.searchValue, () => {
      if (baseProps.searchValue) {
        searchExpandedKeys.value = (0,valueUtil/* getAllKeys */.NW)((0,reactivity_esm_bundler/* toRaw */.IU)(context.treeData), (0,reactivity_esm_bundler/* toRaw */.IU)(context.fieldNames));
      }
    }, {
      immediate: true
    });
    const mergedExpandedKeys = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      if (legacyContext.treeExpandedKeys) {
        return legacyContext.treeExpandedKeys.slice();
      }
      return baseProps.searchValue ? searchExpandedKeys.value : expandedKeys.value;
    });
    const onInternalExpand = keys => {
      var _a;
      expandedKeys.value = keys;
      searchExpandedKeys.value = keys;
      (_a = legacyContext.onTreeExpand) === null || _a === void 0 ? void 0 : _a.call(legacyContext, keys);
    };
    // ========================== Events ==========================
    const onListMouseDown = event => {
      event.preventDefault();
    };
    const onInternalSelect = (_, _ref2) => {
      let {
        node
      } = _ref2;
      var _a, _b;
      const {
        checkable,
        checkedKeys
      } = legacyContext;
      if (checkable && (0,valueUtil/* isCheckDisabled */.hK)(node)) {
        return;
      }
      (_a = context.onSelect) === null || _a === void 0 ? void 0 : _a.call(context, node.key, {
        selected: !checkedKeys.includes(node.key)
      });
      if (!baseProps.multiple) {
        (_b = baseProps.toggleOpen) === null || _b === void 0 ? void 0 : _b.call(baseProps, false);
      }
    };
    // ========================= Keyboard =========================
    const activeKey = (0,reactivity_esm_bundler/* ref */.iH)(null);
    const activeEntity = (0,runtime_core_esm_bundler/* computed */.Fl)(() => legacyContext.keyEntities[activeKey.value]);
    const setActiveKey = key => {
      activeKey.value = key;
    };
    expose({
      scrollTo: function () {
        var _a, _b;
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        return (_b = (_a = treeRef.value) === null || _a === void 0 ? void 0 : _a.scrollTo) === null || _b === void 0 ? void 0 : _b.call(_a, ...args);
      },
      onKeydown: event => {
        var _a;
        const {
          which
        } = event;
        switch (which) {
          // >>> Arrow keys
          case KeyCode/* default.UP */.Z.UP:
          case KeyCode/* default.DOWN */.Z.DOWN:
          case KeyCode/* default.LEFT */.Z.LEFT:
          case KeyCode/* default.RIGHT */.Z.RIGHT:
            (_a = treeRef.value) === null || _a === void 0 ? void 0 : _a.onKeydown(event);
            break;
          // >>> Select item
          case KeyCode/* default.ENTER */.Z.ENTER:
            {
              if (activeEntity.value) {
                const {
                  selectable,
                  value
                } = activeEntity.value.node || {};
                if (selectable !== false) {
                  onInternalSelect(null, {
                    node: {
                      key: activeKey.value
                    },
                    selected: !legacyContext.checkedKeys.includes(value)
                  });
                }
              }
              break;
            }
          // >>> Close
          case KeyCode/* default.ESC */.Z.ESC:
            {
              baseProps.toggleOpen(false);
            }
        }
      },
      onKeyup: () => {}
    });
    return () => {
      var _a;
      const {
        prefixCls,
        multiple,
        searchValue,
        open,
        notFoundContent = (_a = slots.notFoundContent) === null || _a === void 0 ? void 0 : _a.call(slots)
      } = baseProps;
      const {
        listHeight,
        listItemHeight,
        virtual,
        dropdownMatchSelectWidth,
        treeExpandAction
      } = context;
      const {
        checkable,
        treeDefaultExpandAll,
        treeIcon,
        showTreeIcon,
        switcherIcon,
        treeLine,
        loadData,
        treeLoadedKeys,
        treeMotion,
        onTreeLoad,
        checkedKeys
      } = legacyContext;
      // ========================== Render ==========================
      if (memoTreeData.value.length === 0) {
        return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
          "role": "listbox",
          "class": `${prefixCls}-empty`,
          "onMousedown": onListMouseDown
        }, [notFoundContent]);
      }
      const treeProps = {
        fieldNames: context.fieldNames
      };
      if (treeLoadedKeys) {
        treeProps.loadedKeys = treeLoadedKeys;
      }
      if (mergedExpandedKeys.value) {
        treeProps.expandedKeys = mergedExpandedKeys.value;
      }
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "onMousedown": onListMouseDown
      }, [activeEntity.value && open && (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "style": HIDDEN_STYLE,
        "aria-live": "assertive"
      }, [activeEntity.value.node.value]), (0,runtime_core_esm_bundler/* createVNode */.Wm)(Tree/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
        "ref": treeRef,
        "focusable": false,
        "prefixCls": `${prefixCls}-tree`,
        "treeData": memoTreeData.value,
        "height": listHeight,
        "itemHeight": listItemHeight,
        "virtual": virtual !== false && dropdownMatchSelectWidth !== false,
        "multiple": multiple,
        "icon": treeIcon,
        "showIcon": showTreeIcon,
        "switcherIcon": switcherIcon,
        "showLine": treeLine,
        "loadData": searchValue ? null : loadData,
        "motion": treeMotion,
        "activeKey": activeKey.value,
        "checkable": checkable,
        "checkStrictly": true,
        "checkedKeys": mergedCheckedKeys.value,
        "selectedKeys": !checkable ? checkedKeys : [],
        "defaultExpandAll": treeDefaultExpandAll
      }, treeProps), {}, {
        "onActiveChange": setActiveKey,
        "onSelect": onInternalSelect,
        "onCheck": onInternalSelect,
        "onExpand": onInternalExpand,
        "onLoad": onTreeLoad,
        "filterTreeNode": filterTreeNode,
        "expandAction": treeExpandAction
      }), (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, slots), {
        checkable: legacyContext.customSlots.treeCheckable
      }))]);
    };
  }
}));
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/utils/strategyUtil.js
var strategyUtil = __webpack_require__(91964);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/index.js
var props_util = __webpack_require__(9985);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/util.js
var util = __webpack_require__(18049);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-util/warning.js
var warning = __webpack_require__(83630);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/TreeNode.js
var TreeNode = __webpack_require__(16424);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/utils/legacyUtil.js


var __rest = undefined && undefined.__rest || function (s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
};



function isTreeSelectNode(node) {
  return node && node.type && node.type.isTreeSelectNode;
}
function convertChildrenToData(rootNodes) {
  function dig() {
    let treeNodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    return (0,props_util/* filterEmpty */.OU)(treeNodes).map(treeNode => {
      var _a, _b, _c;
      // Filter invalidate node
      if (!isTreeSelectNode(treeNode)) {
        (0,warning/* warning */.Kp)(!treeNode, 'TreeSelect/TreeSelectNode can only accept TreeSelectNode as children.');
        return null;
      }
      const slots = treeNode.children || {};
      const key = treeNode.key;
      const props = {};
      for (const [k, v] of Object.entries(treeNode.props)) {
        props[(0,util/* camelize */._A)(k)] = v;
      }
      const {
        isLeaf,
        checkable,
        selectable,
        disabled,
        disableCheckbox
      } = props;
      // 默认值为 undefined
      const newProps = {
        isLeaf: isLeaf || isLeaf === '' || undefined,
        checkable: checkable || checkable === '' || undefined,
        selectable: selectable || selectable === '' || undefined,
        disabled: disabled || disabled === '' || undefined,
        disableCheckbox: disableCheckbox || disableCheckbox === '' || undefined
      };
      const slotsProps = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props), newProps);
      const {
          title = (_a = slots.title) === null || _a === void 0 ? void 0 : _a.call(slots, slotsProps),
          switcherIcon = (_b = slots.switcherIcon) === null || _b === void 0 ? void 0 : _b.call(slots, slotsProps)
        } = props,
        rest = __rest(props, ["title", "switcherIcon"]);
      const children = (_c = slots.default) === null || _c === void 0 ? void 0 : _c.call(slots);
      const dataNode = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, rest), {
        title,
        switcherIcon,
        key,
        isLeaf
      }), newProps);
      const parsedChildren = dig(children);
      if (parsedChildren.length) {
        dataNode.children = parsedChildren;
      }
      return dataNode;
    });
  }
  return dig(rootNodes);
}
function fillLegacyProps(dataNode) {
  // Skip if not dataNode exist
  if (!dataNode) {
    return dataNode;
  }
  const cloneNode = (0,esm_extends/* default */.Z)({}, dataNode);
  if (!('props' in cloneNode)) {
    Object.defineProperty(cloneNode, 'props', {
      get() {
        (0,warning/* warning */.Kp)(false, 'New `vc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
        return cloneNode;
      }
    });
  }
  return cloneNode;
}
function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition, fieldNames) {
  let triggerNode = null;
  let nodeList = null;
  function generateMap() {
    function dig(list) {
      let level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
      let parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      return list.map((option, index) => {
        const pos = `${level}-${index}`;
        const value = option[fieldNames.value];
        const included = checkedValues.includes(value);
        const children = dig(option[fieldNames.children] || [], pos, included);
        const node = (0,runtime_core_esm_bundler/* createVNode */.Wm)(TreeNode/* default */.Z, option, {
          default: () => [children.map(child => child.node)]
        });
        // Link with trigger node
        if (triggerValue === value) {
          triggerNode = node;
        }
        if (included) {
          const checkedNode = {
            pos,
            node,
            children
          };
          if (!parentIncluded) {
            nodeList.push(checkedNode);
          }
          return checkedNode;
        }
        return null;
      }).filter(node => node);
    }
    if (!nodeList) {
      nodeList = [];
      dig(treeData);
      // Sort to keep the checked node length
      nodeList.sort((_ref, _ref2) => {
        let {
          node: {
            props: {
              value: val1
            }
          }
        } = _ref;
        let {
          node: {
            props: {
              value: val2
            }
          }
        } = _ref2;
        const index1 = checkedValues.indexOf(val1);
        const index2 = checkedValues.indexOf(val2);
        return index1 - index2;
      });
    }
  }
  Object.defineProperty(extra, 'triggerNode', {
    get() {
      (0,warning/* warning */.Kp)(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
      generateMap();
      return triggerNode;
    }
  });
  Object.defineProperty(extra, 'allCheckedNodes', {
    get() {
      (0,warning/* warning */.Kp)(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
      generateMap();
      if (showPosition) {
        return nodeList;
      }
      return nodeList.map(_ref3 => {
        let {
          node
        } = _ref3;
        return node;
      });
    }
  });
}
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/hooks/useTreeData.js



function parseSimpleTreeData(treeData, _ref) {
  let {
    id,
    pId,
    rootPId
  } = _ref;
  const keyNodes = {};
  const rootNodeList = [];
  // Fill in the map
  const nodeList = treeData.map(node => {
    const clone = (0,esm_extends/* default */.Z)({}, node);
    const key = clone[id];
    keyNodes[key] = clone;
    clone.key = clone.key || key;
    return clone;
  });
  // Connect tree
  nodeList.forEach(node => {
    const parentKey = node[pId];
    const parent = keyNodes[parentKey];
    // Fill parent
    if (parent) {
      parent.children = parent.children || [];
      parent.children.push(node);
    }
    // Fill root tree node
    if (parentKey === rootPId || !parent && rootPId === null) {
      rootNodeList.push(node);
    }
  });
  return rootNodeList;
}
/**
 * Convert `treeData` or `children` into formatted `treeData`.
 * Will not re-calculate if `treeData` or `children` not change.
 */
function useTreeData(treeData, children, simpleMode) {
  const mergedTreeData = (0,reactivity_esm_bundler/* shallowRef */.XI)();
  (0,runtime_core_esm_bundler/* watch */.YP)([simpleMode, treeData, children], () => {
    const simpleModeValue = simpleMode.value;
    if (treeData.value) {
      mergedTreeData.value = simpleMode.value ? parseSimpleTreeData((0,reactivity_esm_bundler/* toRaw */.IU)(treeData.value), (0,esm_extends/* default */.Z)({
        id: 'id',
        pId: 'pId',
        rootPId: null
      }, simpleModeValue !== true ? simpleModeValue : {})) : (0,reactivity_esm_bundler/* toRaw */.IU)(treeData.value).slice();
    } else {
      mergedTreeData.value = convertChildrenToData((0,reactivity_esm_bundler/* toRaw */.IU)(children.value));
    }
  }, {
    immediate: true,
    deep: true
  });
  return mergedTreeData;
}
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/hooks/useCache.js


/**
 * This function will try to call requestIdleCallback if available to save performance.
 * No need `getLabel` here since already fetch on `rawLabeledValue`.
 */
/* harmony default export */ const useCache = (values => {
  const cacheRef = (0,reactivity_esm_bundler/* shallowRef */.XI)({
    valueLabels: new Map()
  });
  const mergedValues = (0,reactivity_esm_bundler/* shallowRef */.XI)();
  (0,runtime_core_esm_bundler/* watch */.YP)(values, () => {
    mergedValues.value = (0,reactivity_esm_bundler/* toRaw */.IU)(values.value);
  }, {
    immediate: true
  });
  const newFilledValues = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
    const {
      valueLabels
    } = cacheRef.value;
    const valueLabelsCache = new Map();
    const filledValues = mergedValues.value.map(item => {
      var _a;
      const {
        value
      } = item;
      const mergedLabel = (_a = item.label) !== null && _a !== void 0 ? _a : valueLabels.get(value);
      // Save in cache
      valueLabelsCache.set(value, mergedLabel);
      return (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, item), {
        label: mergedLabel
      });
    });
    cacheRef.value.valueLabels = valueLabelsCache;
    return filledValues;
  });
  return [newFilledValues];
});
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/treeUtil.js
var treeUtil = __webpack_require__(66443);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/hooks/useDataEntities.js





/* harmony default export */ const useDataEntities = ((treeData, fieldNames) => {
  const valueEntities = (0,reactivity_esm_bundler/* shallowRef */.XI)(new Map());
  const keyEntities = (0,reactivity_esm_bundler/* shallowRef */.XI)({});
  (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
    const fieldNamesValue = fieldNames.value;
    const collection = (0,treeUtil/* convertDataToEntities */.I8)(treeData.value, {
      fieldNames: fieldNamesValue,
      initWrapper: wrapper => (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, wrapper), {
        valueEntities: new Map()
      }),
      processEntity: (entity, wrapper) => {
        const val = entity.node[fieldNamesValue.value];
        // Check if exist same value
        if (false) {}
        wrapper.valueEntities.set(val, entity);
      }
    });
    valueEntities.value = collection.valueEntities;
    keyEntities.value = collection.keyEntities;
  });
  return {
    valueEntities,
    keyEntities
  };
});
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/conductUtil.js
var conductUtil = __webpack_require__(74199);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/hooks/useCheckedKeys.js


/* harmony default export */ const useCheckedKeys = ((rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities, maxLevel, levelEntities) => {
  const newRawCheckedValues = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
  const newRawHalfCheckedValues = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
  (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
    let checkedKeys = rawLabeledValues.value.map(_ref => {
      let {
        value
      } = _ref;
      return value;
    });
    let halfCheckedKeys = rawHalfCheckedValues.value.map(_ref2 => {
      let {
        value
      } = _ref2;
      return value;
    });
    const missingValues = checkedKeys.filter(key => !keyEntities.value[key]);
    if (treeConduction.value) {
      ({
        checkedKeys,
        halfCheckedKeys
      } = (0,conductUtil/* conductCheck */.S)(checkedKeys, true, keyEntities.value, maxLevel.value, levelEntities.value));
    }
    newRawCheckedValues.value = Array.from(new Set([...missingValues, ...checkedKeys]));
    newRawHalfCheckedValues.value = halfCheckedKeys;
  });
  return [newRawCheckedValues, newRawHalfCheckedValues];
});
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/hooks/useFilterTreeData.js



/* harmony default export */ const useFilterTreeData = ((treeData, searchValue, _ref) => {
  let {
    treeNodeFilterProp,
    filterTreeNode,
    fieldNames
  } = _ref;
  return (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
    const {
      children: fieldChildren
    } = fieldNames.value;
    const searchValueVal = searchValue.value;
    const treeNodeFilterPropValue = treeNodeFilterProp === null || treeNodeFilterProp === void 0 ? void 0 : treeNodeFilterProp.value;
    if (!searchValueVal || filterTreeNode.value === false) {
      return treeData.value;
    }
    let filterOptionFunc;
    if (typeof filterTreeNode.value === 'function') {
      filterOptionFunc = filterTreeNode.value;
    } else {
      const upperStr = searchValueVal.toUpperCase();
      filterOptionFunc = (_, dataNode) => {
        const value = dataNode[treeNodeFilterPropValue];
        return String(value).toUpperCase().includes(upperStr);
      };
    }
    function dig(list) {
      let keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      const res = [];
      for (let index = 0, len = list.length; index < len; index++) {
        const dataNode = list[index];
        const children = dataNode[fieldChildren];
        const match = keepAll || filterOptionFunc(searchValueVal, fillLegacyProps(dataNode));
        const childList = dig(children || [], match);
        if (match || childList.length) {
          res.push((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, dataNode), {
            [fieldChildren]: childList
          }));
        }
      }
      return res;
    }
    return dig(treeData.value);
  });
});
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-select/BaseSelect.js + 9 modules
var BaseSelect = __webpack_require__(6833);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/omit.js
var omit = __webpack_require__(20811);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/vue-types/index.js
var vue_types = __webpack_require__(33999);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/initDefaultProps.js
var initDefaultProps = __webpack_require__(57206);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-select/hooks/useId.js
var useId = __webpack_require__(83005);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/hooks/useMergedState.js
var useMergedState = __webpack_require__(7738);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/toReactive.js
var toReactive = __webpack_require__(89397);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/useMaxLevel.js
var useMaxLevel = __webpack_require__(8954);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree-select/TreeSelect.js



























function treeSelectProps() {
  return (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, (0,omit/* default */.Z)((0,BaseSelect/* baseSelectPropsWithoutPrivate */.Wg)(), ['mode'])), {
    prefixCls: String,
    id: String,
    value: {
      type: [String, Number, Object, Array]
    },
    defaultValue: {
      type: [String, Number, Object, Array]
    },
    onChange: {
      type: Function
    },
    searchValue: String,
    /** @deprecated Use `searchValue` instead */
    inputValue: String,
    onSearch: {
      type: Function
    },
    autoClearSearchValue: {
      type: Boolean,
      default: undefined
    },
    filterTreeNode: {
      type: [Boolean, Function],
      default: undefined
    },
    treeNodeFilterProp: String,
    // >>> Select
    onSelect: Function,
    onDeselect: Function,
    showCheckedStrategy: {
      type: String
    },
    treeNodeLabelProp: String,
    fieldNames: {
      type: Object
    },
    // >>> Mode
    multiple: {
      type: Boolean,
      default: undefined
    },
    treeCheckable: {
      type: Boolean,
      default: undefined
    },
    treeCheckStrictly: {
      type: Boolean,
      default: undefined
    },
    labelInValue: {
      type: Boolean,
      default: undefined
    },
    // >>> Data
    treeData: {
      type: Array
    },
    treeDataSimpleMode: {
      type: [Boolean, Object],
      default: undefined
    },
    loadData: {
      type: Function
    },
    treeLoadedKeys: {
      type: Array
    },
    onTreeLoad: {
      type: Function
    },
    // >>> Expanded
    treeDefaultExpandAll: {
      type: Boolean,
      default: undefined
    },
    treeExpandedKeys: {
      type: Array
    },
    treeDefaultExpandedKeys: {
      type: Array
    },
    onTreeExpand: {
      type: Function
    },
    // >>> Options
    virtual: {
      type: Boolean,
      default: undefined
    },
    listHeight: Number,
    listItemHeight: Number,
    onDropdownVisibleChange: {
      type: Function
    },
    // >>> Tree
    treeLine: {
      type: [Boolean, Object],
      default: undefined
    },
    treeIcon: vue_types/* default.any */.Z.any,
    showTreeIcon: {
      type: Boolean,
      default: undefined
    },
    switcherIcon: vue_types/* default.any */.Z.any,
    treeMotion: vue_types/* default.any */.Z.any,
    children: Array,
    treeExpandAction: String,
    showArrow: {
      type: Boolean,
      default: undefined
    },
    showSearch: {
      type: Boolean,
      default: undefined
    },
    open: {
      type: Boolean,
      default: undefined
    },
    defaultOpen: {
      type: Boolean,
      default: undefined
    },
    disabled: {
      type: Boolean,
      default: undefined
    },
    placeholder: vue_types/* default.any */.Z.any,
    maxTagPlaceholder: {
      type: Function
    },
    dropdownPopupAlign: vue_types/* default.any */.Z.any,
    customSlots: Object
  });
}
function isRawValue(value) {
  return !value || typeof value !== 'object';
}
/* harmony default export */ const TreeSelect = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'TreeSelect',
  inheritAttrs: false,
  props: (0,initDefaultProps/* default */.Z)(treeSelectProps(), {
    treeNodeFilterProp: 'value',
    autoClearSearchValue: true,
    showCheckedStrategy: strategyUtil/* SHOW_CHILD */.FJ,
    listHeight: 200,
    listItemHeight: 20,
    prefixCls: 'vc-tree-select'
  }),
  setup(props, _ref) {
    let {
      attrs,
      expose,
      slots
    } = _ref;
    const mergedId = (0,useId/* default */.ZP)((0,reactivity_esm_bundler/* toRef */.Vh)(props, 'id'));
    const treeConduction = (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.treeCheckable && !props.treeCheckStrictly);
    const mergedCheckable = (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.treeCheckable || props.treeCheckStrictly);
    const mergedLabelInValue = (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.treeCheckStrictly || props.labelInValue);
    const mergedMultiple = (0,runtime_core_esm_bundler/* computed */.Fl)(() => mergedCheckable.value || props.multiple);
    // ========================== Warning ===========================
    if (false) {}
    // ========================= FieldNames =========================
    const mergedFieldNames = (0,runtime_core_esm_bundler/* computed */.Fl)(() => (0,valueUtil/* fillFieldNames */.w$)(props.fieldNames));
    // =========================== Search ===========================
    const [mergedSearchValue, setSearchValue] = (0,useMergedState/* default */.Z)('', {
      value: (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.searchValue !== undefined ? props.searchValue : props.inputValue),
      postState: search => search || ''
    });
    const onInternalSearch = searchText => {
      var _a;
      setSearchValue(searchText);
      (_a = props.onSearch) === null || _a === void 0 ? void 0 : _a.call(props, searchText);
    };
    // ============================ Data ============================
    // `useTreeData` only do convert of `children` or `simpleMode`.
    // Else will return origin `treeData` for perf consideration.
    // Do not do anything to loop the data.
    const mergedTreeData = useTreeData((0,reactivity_esm_bundler/* toRef */.Vh)(props, 'treeData'), (0,reactivity_esm_bundler/* toRef */.Vh)(props, 'children'), (0,reactivity_esm_bundler/* toRef */.Vh)(props, 'treeDataSimpleMode'));
    const {
      keyEntities,
      valueEntities
    } = useDataEntities(mergedTreeData, mergedFieldNames);
    /** Get `missingRawValues` which not exist in the tree yet */
    const splitRawValues = newRawValues => {
      const missingRawValues = [];
      const existRawValues = [];
      // Keep missing value in the cache
      newRawValues.forEach(val => {
        if (valueEntities.value.has(val)) {
          existRawValues.push(val);
        } else {
          missingRawValues.push(val);
        }
      });
      return {
        missingRawValues,
        existRawValues
      };
    };
    // Filtered Tree
    const filteredTreeData = useFilterTreeData(mergedTreeData, mergedSearchValue, {
      fieldNames: mergedFieldNames,
      treeNodeFilterProp: (0,reactivity_esm_bundler/* toRef */.Vh)(props, 'treeNodeFilterProp'),
      filterTreeNode: (0,reactivity_esm_bundler/* toRef */.Vh)(props, 'filterTreeNode')
    });
    // =========================== Label ============================
    const getLabel = item => {
      if (item) {
        if (props.treeNodeLabelProp) {
          return item[props.treeNodeLabelProp];
        }
        // Loop from fieldNames
        const {
          _title: titleList
        } = mergedFieldNames.value;
        for (let i = 0; i < titleList.length; i += 1) {
          const title = item[titleList[i]];
          if (title !== undefined) {
            return title;
          }
        }
      }
    };
    // ========================= Wrap Value =========================
    const toLabeledValues = draftValues => {
      const values = (0,valueUtil/* toArray */.qo)(draftValues);
      return values.map(val => {
        if (isRawValue(val)) {
          return {
            value: val
          };
        }
        return val;
      });
    };
    const convert2LabelValues = draftValues => {
      const values = toLabeledValues(draftValues);
      return values.map(item => {
        let {
          label: rawLabel
        } = item;
        const {
          value: rawValue,
          halfChecked: rawHalfChecked
        } = item;
        let rawDisabled;
        const entity = valueEntities.value.get(rawValue);
        // Fill missing label & status
        if (entity) {
          rawLabel = rawLabel !== null && rawLabel !== void 0 ? rawLabel : getLabel(entity.node);
          rawDisabled = entity.node.disabled;
        }
        return {
          label: rawLabel,
          value: rawValue,
          halfChecked: rawHalfChecked,
          disabled: rawDisabled
        };
      });
    };
    // =========================== Values ===========================
    const [internalValue, setInternalValue] = (0,useMergedState/* default */.Z)(props.defaultValue, {
      value: (0,reactivity_esm_bundler/* toRef */.Vh)(props, 'value')
    });
    const rawMixedLabeledValues = (0,runtime_core_esm_bundler/* computed */.Fl)(() => toLabeledValues(internalValue.value));
    // Split value into full check and half check
    const rawLabeledValues = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const rawHalfLabeledValues = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      const fullCheckValues = [];
      const halfCheckValues = [];
      rawMixedLabeledValues.value.forEach(item => {
        if (item.halfChecked) {
          halfCheckValues.push(item);
        } else {
          fullCheckValues.push(item);
        }
      });
      rawLabeledValues.value = fullCheckValues;
      rawHalfLabeledValues.value = halfCheckValues;
    });
    // const [mergedValues] = useCache(rawLabeledValues);
    const rawValues = (0,runtime_core_esm_bundler/* computed */.Fl)(() => rawLabeledValues.value.map(item => item.value));
    const {
      maxLevel,
      levelEntities
    } = (0,useMaxLevel/* default */.Z)(keyEntities);
    // Convert value to key. Will fill missed keys for conduct check.
    const [rawCheckedValues, rawHalfCheckedValues] = useCheckedKeys(rawLabeledValues, rawHalfLabeledValues, treeConduction, keyEntities, maxLevel, levelEntities);
    // Convert rawCheckedKeys to check strategy related values
    const displayValues = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      // Collect keys which need to show
      const displayKeys = (0,strategyUtil/* formatStrategyValues */.uz)(rawCheckedValues.value, props.showCheckedStrategy, keyEntities.value, mergedFieldNames.value);
      // Convert to value and filled with label
      const values = displayKeys.map(key => {
        var _a, _b, _c;
        return (_c = (_b = (_a = keyEntities.value[key]) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b[mergedFieldNames.value.value]) !== null && _c !== void 0 ? _c : key;
      });
      // Back fill with origin label
      const labeledValues = values.map(val => {
        const targetItem = rawLabeledValues.value.find(item => item.value === val);
        return {
          value: val,
          label: targetItem === null || targetItem === void 0 ? void 0 : targetItem.label
        };
      });
      const rawDisplayValues = convert2LabelValues(labeledValues);
      const firstVal = rawDisplayValues[0];
      if (!mergedMultiple.value && firstVal && (0,valueUtil/* isNil */.kK)(firstVal.value) && (0,valueUtil/* isNil */.kK)(firstVal.label)) {
        return [];
      }
      return rawDisplayValues.map(item => {
        var _a;
        return (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, item), {
          label: (_a = item.label) !== null && _a !== void 0 ? _a : item.value
        });
      });
    });
    const [cachedDisplayValues] = useCache(displayValues);
    // =========================== Change ===========================
    const triggerChange = (newRawValues, extra, source) => {
      const labeledValues = convert2LabelValues(newRawValues);
      setInternalValue(labeledValues);
      // Clean up if needed
      if (props.autoClearSearchValue) {
        setSearchValue('');
      }
      // Generate rest parameters is costly, so only do it when necessary
      if (props.onChange) {
        let eventValues = newRawValues;
        if (treeConduction.value) {
          const formattedKeyList = (0,strategyUtil/* formatStrategyValues */.uz)(newRawValues, props.showCheckedStrategy, keyEntities.value, mergedFieldNames.value);
          eventValues = formattedKeyList.map(key => {
            const entity = valueEntities.value.get(key);
            return entity ? entity.node[mergedFieldNames.value.value] : key;
          });
        }
        const {
          triggerValue,
          selected
        } = extra || {
          triggerValue: undefined,
          selected: undefined
        };
        let returnRawValues = eventValues;
        // We need fill half check back
        if (props.treeCheckStrictly) {
          const halfValues = rawHalfLabeledValues.value.filter(item => !eventValues.includes(item.value));
          returnRawValues = [...returnRawValues, ...halfValues];
        }
        const returnLabeledValues = convert2LabelValues(returnRawValues);
        const additionalInfo = {
          // [Legacy] Always return as array contains label & value
          preValue: rawLabeledValues.value,
          triggerValue
        };
        // [Legacy] Fill legacy data if user query.
        // This is expansive that we only fill when user query
        // https://github.com/react-component/tree-select/blob/fe33eb7c27830c9ac70cd1fdb1ebbe7bc679c16a/src/Select.jsx
        let showPosition = true;
        if (props.treeCheckStrictly || source === 'selection' && !selected) {
          showPosition = false;
        }
        fillAdditionalInfo(additionalInfo, triggerValue, newRawValues, mergedTreeData.value, showPosition, mergedFieldNames.value);
        if (mergedCheckable.value) {
          additionalInfo.checked = selected;
        } else {
          additionalInfo.selected = selected;
        }
        const returnValues = mergedLabelInValue.value ? returnLabeledValues : returnLabeledValues.map(item => item.value);
        props.onChange(mergedMultiple.value ? returnValues : returnValues[0], mergedLabelInValue.value ? null : returnLabeledValues.map(item => item.label), additionalInfo);
      }
    };
    // ========================== Options ===========================
    /** Trigger by option list */
    const onOptionSelect = (selectedKey, _ref2) => {
      let {
        selected,
        source
      } = _ref2;
      var _a, _b, _c;
      const keyEntitiesValue = (0,reactivity_esm_bundler/* toRaw */.IU)(keyEntities.value);
      const valueEntitiesValue = (0,reactivity_esm_bundler/* toRaw */.IU)(valueEntities.value);
      const entity = keyEntitiesValue[selectedKey];
      const node = entity === null || entity === void 0 ? void 0 : entity.node;
      const selectedValue = (_a = node === null || node === void 0 ? void 0 : node[mergedFieldNames.value.value]) !== null && _a !== void 0 ? _a : selectedKey;
      // Never be falsy but keep it safe
      if (!mergedMultiple.value) {
        // Single mode always set value
        triggerChange([selectedValue], {
          selected: true,
          triggerValue: selectedValue
        }, 'option');
      } else {
        let newRawValues = selected ? [...rawValues.value, selectedValue] : rawCheckedValues.value.filter(v => v !== selectedValue);
        // Add keys if tree conduction
        if (treeConduction.value) {
          // Should keep missing values
          const {
            missingRawValues,
            existRawValues
          } = splitRawValues(newRawValues);
          const keyList = existRawValues.map(val => valueEntitiesValue.get(val).key);
          // Conduction by selected or not
          let checkedKeys;
          if (selected) {
            ({
              checkedKeys
            } = (0,conductUtil/* conductCheck */.S)(keyList, true, keyEntitiesValue, maxLevel.value, levelEntities.value));
          } else {
            ({
              checkedKeys
            } = (0,conductUtil/* conductCheck */.S)(keyList, {
              checked: false,
              halfCheckedKeys: rawHalfCheckedValues.value
            }, keyEntitiesValue, maxLevel.value, levelEntities.value));
          }
          // Fill back of keys
          newRawValues = [...missingRawValues, ...checkedKeys.map(key => keyEntitiesValue[key].node[mergedFieldNames.value.value])];
        }
        triggerChange(newRawValues, {
          selected,
          triggerValue: selectedValue
        }, source || 'option');
      }
      // Trigger select event
      if (selected || !mergedMultiple.value) {
        (_b = props.onSelect) === null || _b === void 0 ? void 0 : _b.call(props, selectedValue, fillLegacyProps(node));
      } else {
        (_c = props.onDeselect) === null || _c === void 0 ? void 0 : _c.call(props, selectedValue, fillLegacyProps(node));
      }
    };
    // ========================== Dropdown ==========================
    const onInternalDropdownVisibleChange = open => {
      if (props.onDropdownVisibleChange) {
        const legacyParam = {};
        Object.defineProperty(legacyParam, 'documentClickClose', {
          get() {
            (0,warning/* warning */.Kp)(false, 'Second param of `onDropdownVisibleChange` has been removed.');
            return false;
          }
        });
        props.onDropdownVisibleChange(open, legacyParam);
      }
    };
    // ====================== Display Change ========================
    const onDisplayValuesChange = (newValues, info) => {
      const newRawValues = newValues.map(item => item.value);
      if (info.type === 'clear') {
        triggerChange(newRawValues, {}, 'selection');
        return;
      }
      // TreeSelect only have multiple mode which means display change only has remove
      if (info.values.length) {
        onOptionSelect(info.values[0].value, {
          selected: false,
          source: 'selection'
        });
      }
    };
    const {
      treeNodeFilterProp,
      // Data
      loadData,
      treeLoadedKeys,
      onTreeLoad,
      // Expanded
      treeDefaultExpandAll,
      treeExpandedKeys,
      treeDefaultExpandedKeys,
      onTreeExpand,
      // Options
      virtual,
      listHeight,
      listItemHeight,
      // Tree
      treeLine,
      treeIcon,
      showTreeIcon,
      switcherIcon,
      treeMotion,
      customSlots,
      dropdownMatchSelectWidth,
      treeExpandAction
    } = (0,reactivity_esm_bundler/* toRefs */.BK)(props);
    (0,LegacyContext/* useProvideLegacySelectContext */.p)((0,toReactive/* toReactive */.Y)({
      checkable: mergedCheckable,
      loadData,
      treeLoadedKeys,
      onTreeLoad,
      checkedKeys: rawCheckedValues,
      halfCheckedKeys: rawHalfCheckedValues,
      treeDefaultExpandAll,
      treeExpandedKeys,
      treeDefaultExpandedKeys,
      onTreeExpand,
      treeIcon,
      treeMotion,
      showTreeIcon,
      switcherIcon,
      treeLine,
      treeNodeFilterProp,
      keyEntities,
      customSlots
    }));
    useProvideSelectContext((0,toReactive/* toReactive */.Y)({
      virtual,
      listHeight,
      listItemHeight,
      treeData: filteredTreeData,
      fieldNames: mergedFieldNames,
      onSelect: onOptionSelect,
      dropdownMatchSelectWidth,
      treeExpandAction
    }));
    const selectRef = (0,reactivity_esm_bundler/* ref */.iH)();
    expose({
      focus() {
        var _a;
        (_a = selectRef.value) === null || _a === void 0 ? void 0 : _a.focus();
      },
      blur() {
        var _a;
        (_a = selectRef.value) === null || _a === void 0 ? void 0 : _a.blur();
      },
      scrollTo(arg) {
        var _a;
        (_a = selectRef.value) === null || _a === void 0 ? void 0 : _a.scrollTo(arg);
      }
    });
    return () => {
      var _a;
      const restProps = (0,omit/* default */.Z)(props, ['id', 'prefixCls', 'customSlots',
      // Value
      'value', 'defaultValue', 'onChange', 'onSelect', 'onDeselect',
      // Search
      'searchValue', 'inputValue', 'onSearch', 'autoClearSearchValue', 'filterTreeNode', 'treeNodeFilterProp',
      // Selector
      'showCheckedStrategy', 'treeNodeLabelProp',
      //  Mode
      'multiple', 'treeCheckable', 'treeCheckStrictly', 'labelInValue',
      // FieldNames
      'fieldNames',
      // Data
      'treeDataSimpleMode', 'treeData', 'children', 'loadData', 'treeLoadedKeys', 'onTreeLoad',
      // Expanded
      'treeDefaultExpandAll', 'treeExpandedKeys', 'treeDefaultExpandedKeys', 'onTreeExpand',
      // Options
      'virtual', 'listHeight', 'listItemHeight', 'onDropdownVisibleChange',
      // Tree
      'treeLine', 'treeIcon', 'showTreeIcon', 'switcherIcon', 'treeMotion']);
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(BaseSelect/* default */.ZP, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
        "ref": selectRef
      }, attrs), restProps), {}, {
        "id": mergedId,
        "prefixCls": props.prefixCls,
        "mode": mergedMultiple.value ? 'multiple' : undefined,
        "displayValues": cachedDisplayValues.value,
        "onDisplayValuesChange": onDisplayValuesChange,
        "searchValue": mergedSearchValue.value,
        "onSearch": onInternalSearch,
        "OptionList": OptionList,
        "emptyOptions": !mergedTreeData.value.length,
        "onDropdownVisibleChange": onInternalDropdownVisibleChange,
        "tagRender": props.tagRender || slots.tagRender,
        "dropdownMatchSelectWidth": (_a = props.dropdownMatchSelectWidth) !== null && _a !== void 0 ? _a : true
      }), slots);
    };
  }
}));

/***/ }),

/***/ 46539:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "ZP": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _TreeSelect__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(87973);




/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_TreeSelect__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z);

/***/ }),

/***/ 91964:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "FJ": () => (/* binding */ SHOW_CHILD),
/* harmony export */   "Qw": () => (/* binding */ SHOW_ALL),
/* harmony export */   "hT": () => (/* binding */ SHOW_PARENT),
/* harmony export */   "uz": () => (/* binding */ formatStrategyValues)
/* harmony export */ });
/* harmony import */ var _valueUtil__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(63709);

const SHOW_ALL = 'SHOW_ALL';
const SHOW_PARENT = 'SHOW_PARENT';
const SHOW_CHILD = 'SHOW_CHILD';
function formatStrategyValues(values, strategy, keyEntities, fieldNames) {
  const valueSet = new Set(values);
  if (strategy === SHOW_CHILD) {
    return values.filter(key => {
      const entity = keyEntities[key];
      if (entity && entity.children && entity.children.some(_ref => {
        let {
          node
        } = _ref;
        return valueSet.has(node[fieldNames.value]);
      }) && entity.children.every(_ref2 => {
        let {
          node
        } = _ref2;
        return (0,_valueUtil__WEBPACK_IMPORTED_MODULE_0__/* .isCheckDisabled */ .hK)(node) || valueSet.has(node[fieldNames.value]);
      })) {
        return false;
      }
      return true;
    });
  }
  if (strategy === SHOW_PARENT) {
    return values.filter(key => {
      const entity = keyEntities[key];
      const parent = entity ? entity.parent : null;
      if (parent && !(0,_valueUtil__WEBPACK_IMPORTED_MODULE_0__/* .isCheckDisabled */ .hK)(parent.node) && valueSet.has(parent.key)) {
        return false;
      }
      return true;
    });
  }
  return values;
}

/***/ }),

/***/ 63709:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "NW": () => (/* binding */ getAllKeys),
/* harmony export */   "hK": () => (/* binding */ isCheckDisabled),
/* harmony export */   "kK": () => (/* binding */ isNil),
/* harmony export */   "qo": () => (/* binding */ toArray),
/* harmony export */   "w$": () => (/* binding */ fillFieldNames)
/* harmony export */ });
function toArray(value) {
  if (Array.isArray(value)) {
    return value;
  }
  return value !== undefined ? [value] : [];
}
function fillFieldNames(fieldNames) {
  const {
    label,
    value,
    children
  } = fieldNames || {};
  const mergedValue = value || 'value';
  return {
    _title: label ? [label] : ['title', 'label'],
    value: mergedValue,
    key: mergedValue,
    children: children || 'children'
  };
}
function isCheckDisabled(node) {
  return node.disabled || node.disableCheckbox || node.checkable === false;
}
/** Loop fetch all the keys exist in the tree */
function getAllKeys(treeData, fieldNames) {
  const keys = [];
  function dig(list) {
    list.forEach(item => {
      keys.push(item[fieldNames.value]);
      const children = item[fieldNames.children];
      if (children) {
        dig(children);
      }
    });
  }
  dig(treeData);
  return keys;
}
function isNil(val) {
  return val === null || val === undefined;
}

/***/ }),

/***/ 73266:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "Z": () => (/* binding */ Tree)
});

// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 1 modules
var objectSpread2 = __webpack_require__(38295);
// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(62081);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-core@3.3.1/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var runtime_core_esm_bundler = __webpack_require__(27520);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/contextTypes.js
var contextTypes = __webpack_require__(31993);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/util.js
var util = __webpack_require__(58187);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/treeUtil.js
var treeUtil = __webpack_require__(66443);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+reactivity@3.3.1/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
var reactivity_esm_bundler = __webpack_require__(83270);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-virtual-list/index.js + 10 modules
var vc_virtual_list = __webpack_require__(55311);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/omit.js
var omit = __webpack_require__(20811);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-dom@3.3.1/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
var runtime_dom_esm_bundler = __webpack_require__(41922);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/TreeNode.js + 1 modules
var TreeNode = __webpack_require__(31295);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/props.js
var props = __webpack_require__(94125);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/collapseMotion.js
var collapseMotion = __webpack_require__(93955);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/MotionTreeNode.js



var __rest = undefined && undefined.__rest || function (s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
};





/* harmony default export */ const MotionTreeNode = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'MotionTreeNode',
  inheritAttrs: false,
  props: (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props/* treeNodeProps */.Pe), {
    active: Boolean,
    motion: Object,
    motionNodes: {
      type: Array
    },
    onMotionStart: Function,
    onMotionEnd: Function,
    motionType: String
  }),
  setup(props, _ref) {
    let {
      attrs,
      slots
    } = _ref;
    const visible = (0,reactivity_esm_bundler/* shallowRef */.XI)(true);
    const context = (0,contextTypes/* useInjectTreeContext */.Mk)();
    const motionedRef = (0,reactivity_esm_bundler/* shallowRef */.XI)(false);
    const transitionProps = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      if (props.motion) {
        return props.motion;
      } else {
        return (0,collapseMotion/* default */.Z)();
      }
    });
    const onMotionEnd = (node, type) => {
      var _a, _b, _c, _d;
      if (type === 'appear') {
        (_b = (_a = transitionProps.value) === null || _a === void 0 ? void 0 : _a.onAfterEnter) === null || _b === void 0 ? void 0 : _b.call(_a, node);
      } else if (type === 'leave') {
        (_d = (_c = transitionProps.value) === null || _c === void 0 ? void 0 : _c.onAfterLeave) === null || _d === void 0 ? void 0 : _d.call(_c, node);
      }
      if (!motionedRef.value) {
        props.onMotionEnd();
      }
      motionedRef.value = true;
    };
    (0,runtime_core_esm_bundler/* watch */.YP)(() => props.motionNodes, () => {
      if (props.motionNodes && props.motionType === 'hide' && visible.value) {
        (0,runtime_core_esm_bundler/* nextTick */.Y3)(() => {
          visible.value = false;
        });
      }
    }, {
      immediate: true,
      flush: 'post'
    });
    (0,runtime_core_esm_bundler/* onMounted */.bv)(() => {
      props.motionNodes && props.onMotionStart();
    });
    (0,runtime_core_esm_bundler/* onBeforeUnmount */.Jd)(() => {
      props.motionNodes && onMotionEnd();
    });
    return () => {
      const {
          motion,
          motionNodes,
          motionType,
          active,
          eventKey
        } = props,
        otherProps = __rest(props, ["motion", "motionNodes", "motionType", "active", "eventKey"]);
      if (motionNodes) {
        return (0,runtime_core_esm_bundler/* createVNode */.Wm)(runtime_dom_esm_bundler/* Transition */.uT, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, transitionProps.value), {}, {
          "appear": motionType === 'show',
          "onAfterAppear": node => onMotionEnd(node, 'appear'),
          "onAfterLeave": node => onMotionEnd(node, 'leave')
        }), {
          default: () => [(0,runtime_core_esm_bundler/* withDirectives */.wy)((0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
            "class": `${context.value.prefixCls}-treenode-motion`
          }, [motionNodes.map(treeNode => {
            const restProps = __rest(treeNode.data, []),
              {
                title,
                key,
                isStart,
                isEnd
              } = treeNode;
            delete restProps.children;
            return (0,runtime_core_esm_bundler/* createVNode */.Wm)(TreeNode/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, restProps), {}, {
              "title": title,
              "active": active,
              "data": treeNode.data,
              "key": key,
              "eventKey": key,
              "isStart": isStart,
              "isEnd": isEnd
            }), slots);
          })]), [[runtime_dom_esm_bundler/* vShow */.F8, visible.value]])]
        });
      }
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(TreeNode/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
        "class": attrs.class,
        "style": attrs.style
      }, otherProps), {}, {
        "active": active,
        "eventKey": eventKey
      }), slots);
    };
  }
}));
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/diffUtil.js
var diffUtil = __webpack_require__(61081);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/NodeList.js



/**
 * Handle virtual list of the TreeNodes.
 */
var NodeList_rest = undefined && undefined.__rest || function (s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
};








const HIDDEN_STYLE = {
  width: 0,
  height: 0,
  display: 'flex',
  overflow: 'hidden',
  opacity: 0,
  border: 0,
  padding: 0,
  margin: 0
};
const noop = () => {};
const MOTION_KEY = `RC_TREE_MOTION_${Math.random()}`;
const MotionNode = {
  key: MOTION_KEY
};
const MotionEntity = {
  key: MOTION_KEY,
  level: 0,
  index: 0,
  pos: '0',
  node: MotionNode,
  nodes: [MotionNode]
};
const MotionFlattenData = {
  parent: null,
  children: [],
  pos: MotionEntity.pos,
  data: MotionNode,
  title: null,
  key: MOTION_KEY,
  /** Hold empty list here since we do not use it */
  isStart: [],
  isEnd: []
};
/**
 * We only need get visible content items to play the animation.
 */
function getMinimumRangeTransitionRange(list, virtual, height, itemHeight) {
  if (virtual === false || !height) {
    return list;
  }
  return list.slice(0, Math.ceil(height / itemHeight) + 1);
}
function itemKey(item) {
  const {
    key,
    pos
  } = item;
  return (0,treeUtil/* getKey */.km)(key, pos);
}
function getAccessibilityPath(item) {
  let path = String(item.key);
  let current = item;
  while (current.parent) {
    current = current.parent;
    path = `${current.key} > ${path}`;
  }
  return path;
}
/* harmony default export */ const NodeList = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'NodeList',
  inheritAttrs: false,
  props: props/* nodeListProps */.dh,
  setup(props, _ref) {
    let {
      expose,
      attrs
    } = _ref;
    // =============================== Ref ================================
    const listRef = (0,reactivity_esm_bundler/* ref */.iH)();
    const indentMeasurerRef = (0,reactivity_esm_bundler/* ref */.iH)();
    const {
      expandedKeys,
      flattenNodes
    } = (0,contextTypes/* useInjectKeysState */.IB)();
    expose({
      scrollTo: scroll => {
        listRef.value.scrollTo(scroll);
      },
      getIndentWidth: () => indentMeasurerRef.value.offsetWidth
    });
    // ============================== Motion ==============================
    const transitionData = (0,reactivity_esm_bundler/* shallowRef */.XI)(flattenNodes.value);
    const transitionRange = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const motionType = (0,reactivity_esm_bundler/* ref */.iH)(null);
    function onMotionEnd() {
      transitionData.value = flattenNodes.value;
      transitionRange.value = [];
      motionType.value = null;
      props.onListChangeEnd();
    }
    const context = (0,contextTypes/* useInjectTreeContext */.Mk)();
    (0,runtime_core_esm_bundler/* watch */.YP)([() => expandedKeys.value.slice(), flattenNodes], (_ref2, _ref3) => {
      let [expandedKeys, data] = _ref2;
      let [prevExpandedKeys, prevData] = _ref3;
      const diffExpanded = (0,diffUtil/* findExpandedKeys */.U)(prevExpandedKeys, expandedKeys);
      if (diffExpanded.key !== null) {
        const {
          virtual,
          height,
          itemHeight
        } = props;
        if (diffExpanded.add) {
          const keyIndex = prevData.findIndex(_ref4 => {
            let {
              key
            } = _ref4;
            return key === diffExpanded.key;
          });
          const rangeNodes = getMinimumRangeTransitionRange((0,diffUtil/* getExpandRange */.l)(prevData, data, diffExpanded.key), virtual, height, itemHeight);
          const newTransitionData = prevData.slice();
          newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
          transitionData.value = newTransitionData;
          transitionRange.value = rangeNodes;
          motionType.value = 'show';
        } else {
          const keyIndex = data.findIndex(_ref5 => {
            let {
              key
            } = _ref5;
            return key === diffExpanded.key;
          });
          const rangeNodes = getMinimumRangeTransitionRange((0,diffUtil/* getExpandRange */.l)(data, prevData, diffExpanded.key), virtual, height, itemHeight);
          const newTransitionData = data.slice();
          newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
          transitionData.value = newTransitionData;
          transitionRange.value = rangeNodes;
          motionType.value = 'hide';
        }
      } else if (prevData !== data) {
        transitionData.value = data;
      }
    });
    // We should clean up motion if is changed by dragging
    (0,runtime_core_esm_bundler/* watch */.YP)(() => context.value.dragging, dragging => {
      if (!dragging) {
        onMotionEnd();
      }
    });
    const mergedData = (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.motion === undefined ? transitionData.value : flattenNodes.value);
    const onActiveChange = () => {
      props.onActiveChange(null);
    };
    return () => {
      const _a = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props), attrs),
        {
          prefixCls,
          selectable,
          checkable,
          disabled,
          motion,
          height,
          itemHeight,
          virtual,
          focusable,
          activeItem,
          focused,
          tabindex,
          onKeydown,
          onFocus,
          onBlur,
          onListChangeStart,
          onListChangeEnd
        } = _a,
        domProps = NodeList_rest(_a, ["prefixCls", "selectable", "checkable", "disabled", "motion", "height", "itemHeight", "virtual", "focusable", "activeItem", "focused", "tabindex", "onKeydown", "onFocus", "onBlur", "onListChangeStart", "onListChangeEnd"]);
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(runtime_core_esm_bundler/* Fragment */.HY, null, [focused && activeItem && (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "style": HIDDEN_STYLE,
        "aria-live": "assertive"
      }, [getAccessibilityPath(activeItem)]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", null, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("input", {
        "style": HIDDEN_STYLE,
        "disabled": focusable === false || disabled,
        "tabindex": focusable !== false ? tabindex : null,
        "onKeydown": onKeydown,
        "onFocus": onFocus,
        "onBlur": onBlur,
        "value": "",
        "onChange": noop,
        "aria-label": "for screen reader"
      }, null)]), (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-treenode`,
        "aria-hidden": true,
        "style": {
          position: 'absolute',
          pointerEvents: 'none',
          visibility: 'hidden',
          height: 0,
          overflow: 'hidden'
        }
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-indent`
      }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "ref": indentMeasurerRef,
        "class": `${prefixCls}-indent-unit`
      }, null)])]), (0,runtime_core_esm_bundler/* createVNode */.Wm)(vc_virtual_list/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, (0,omit/* default */.Z)(domProps, ['onActiveChange'])), {}, {
        "data": mergedData.value,
        "itemKey": itemKey,
        "height": height,
        "fullHeight": false,
        "virtual": virtual,
        "itemHeight": itemHeight,
        "prefixCls": `${prefixCls}-list`,
        "ref": listRef,
        "onVisibleChange": (originList, fullList) => {
          const originSet = new Set(originList);
          const restList = fullList.filter(item => !originSet.has(item));
          // Motion node is not render. Skip motion
          if (restList.some(item => itemKey(item) === MOTION_KEY)) {
            onMotionEnd();
          }
        }
      }), {
        default: treeNode => {
          const {
              pos
            } = treeNode,
            restProps = NodeList_rest(treeNode.data, []),
            {
              title,
              key,
              isStart,
              isEnd
            } = treeNode;
          const mergedKey = (0,treeUtil/* getKey */.km)(key, pos);
          delete restProps.key;
          delete restProps.children;
          return (0,runtime_core_esm_bundler/* createVNode */.Wm)(MotionTreeNode, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, restProps), {}, {
            "eventKey": mergedKey,
            "title": title,
            "active": !!activeItem && key === activeItem.key,
            "data": treeNode.data,
            "isStart": isStart,
            "isEnd": isEnd,
            "motion": motion,
            "motionNodes": key === MOTION_KEY ? transitionRange.value : null,
            "motionType": motionType.value,
            "onMotionStart": onListChangeStart,
            "onMotionEnd": onMotionEnd,
            "onMousemove": onActiveChange
          }), null);
        }
      })]);
    };
  }
}));
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/conductUtil.js
var conductUtil = __webpack_require__(74199);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/DropIndicator.js

function DropIndicator(_ref) {
  let {
    dropPosition,
    dropLevelOffset,
    indent
  } = _ref;
  const style = {
    pointerEvents: 'none',
    position: 'absolute',
    right: 0,
    backgroundColor: 'red',
    height: `${2}px`
  };
  switch (dropPosition) {
    case -1:
      style.top = 0;
      style.left = `${-dropLevelOffset * indent}px`;
      break;
    case 1:
      style.bottom = 0;
      style.left = `${-dropLevelOffset * indent}px`;
      break;
    case 0:
      style.bottom = 0;
      style.left = `${indent}`;
      break;
  }
  return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
    "style": style
  }, null);
}
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/initDefaultProps.js
var initDefaultProps = __webpack_require__(57206);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-util/warning.js
var warning = __webpack_require__(83630);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/KeyCode.js
var KeyCode = __webpack_require__(64776);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/classNames.js
var classNames = __webpack_require__(64334);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/pickAttrs.js
var pickAttrs = __webpack_require__(1405);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/useMaxLevel.js
var useMaxLevel = __webpack_require__(8954);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/Tree.js

















const MAX_RETRY_TIMES = 10;
/* harmony default export */ const Tree = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'Tree',
  inheritAttrs: false,
  props: (0,initDefaultProps/* default */.Z)((0,props/* treeProps */.Ni)(), {
    prefixCls: 'vc-tree',
    showLine: false,
    showIcon: true,
    selectable: true,
    multiple: false,
    checkable: false,
    disabled: false,
    checkStrictly: false,
    draggable: false,
    expandAction: false,
    defaultExpandParent: true,
    autoExpandParent: false,
    defaultExpandAll: false,
    defaultExpandedKeys: [],
    defaultCheckedKeys: [],
    defaultSelectedKeys: [],
    dropIndicatorRender: DropIndicator,
    allowDrop: () => true
  }),
  setup(props, _ref) {
    let {
      attrs,
      slots,
      expose
    } = _ref;
    const destroyed = (0,reactivity_esm_bundler/* shallowRef */.XI)(false);
    let delayedDragEnterLogic = {};
    const indent = (0,reactivity_esm_bundler/* shallowRef */.XI)();
    const selectedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const checkedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const halfCheckedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const loadedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const loadingKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const expandedKeys = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    const loadingRetryTimes = {};
    const dragState = (0,reactivity_esm_bundler/* reactive */.qj)({
      draggingNodeKey: null,
      dragChildrenKeys: [],
      // dropTargetKey is the key of abstract-drop-node
      // the abstract-drop-node is the real drop node when drag and drop
      // not the DOM drag over node
      dropTargetKey: null,
      dropPosition: null,
      dropContainerKey: null,
      dropLevelOffset: null,
      dropTargetPos: null,
      dropAllowed: true,
      // the abstract-drag-over-node
      // if mouse is on the bottom of top dom node or no the top of the bottom dom node
      // abstract-drag-over-node is the top node
      dragOverNodeKey: null
    });
    const treeData = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    (0,runtime_core_esm_bundler/* watch */.YP)([() => props.treeData, () => props.children], () => {
      treeData.value = props.treeData !== undefined ? props.treeData.slice() : (0,treeUtil/* convertTreeToData */.zn)((0,reactivity_esm_bundler/* toRaw */.IU)(props.children));
    }, {
      immediate: true,
      deep: true
    });
    const keyEntities = (0,reactivity_esm_bundler/* shallowRef */.XI)({});
    const focused = (0,reactivity_esm_bundler/* shallowRef */.XI)(false);
    const activeKey = (0,reactivity_esm_bundler/* shallowRef */.XI)(null);
    const listChanging = (0,reactivity_esm_bundler/* shallowRef */.XI)(false);
    const fieldNames = (0,runtime_core_esm_bundler/* computed */.Fl)(() => (0,treeUtil/* fillFieldNames */.w$)(props.fieldNames));
    const listRef = (0,reactivity_esm_bundler/* shallowRef */.XI)();
    let dragStartMousePosition = null;
    let dragNode = null;
    let currentMouseOverDroppableNodeKey = null;
    const treeNodeRequiredProps = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return {
        expandedKeysSet: expandedKeysSet.value,
        selectedKeysSet: selectedKeysSet.value,
        loadedKeysSet: loadedKeysSet.value,
        loadingKeysSet: loadingKeysSet.value,
        checkedKeysSet: checkedKeysSet.value,
        halfCheckedKeysSet: halfCheckedKeysSet.value,
        dragOverNodeKey: dragState.dragOverNodeKey,
        dropPosition: dragState.dropPosition,
        keyEntities: keyEntities.value
      };
    });
    const expandedKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(expandedKeys.value);
    });
    const selectedKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(selectedKeys.value);
    });
    const loadedKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(loadedKeys.value);
    });
    const loadingKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(loadingKeys.value);
    });
    const checkedKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(checkedKeys.value);
    });
    const halfCheckedKeysSet = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return new Set(halfCheckedKeys.value);
    });
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      if (treeData.value) {
        const entitiesMap = (0,treeUtil/* convertDataToEntities */.I8)(treeData.value, {
          fieldNames: fieldNames.value
        });
        keyEntities.value = (0,esm_extends/* default */.Z)({
          [MOTION_KEY]: MotionEntity
        }, entitiesMap.keyEntities);
      }
    });
    let init = false; // 处理 defaultXxxx api, 仅仅首次有效
    (0,runtime_core_esm_bundler/* watch */.YP)([() => props.expandedKeys, () => props.autoExpandParent, keyEntities],
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    (_ref2, _ref3) => {
      let [_newKeys, newAutoExpandParent] = _ref2;
      let [_oldKeys, oldAutoExpandParent] = _ref3;
      let keys = expandedKeys.value;
      // ================ expandedKeys =================
      if (props.expandedKeys !== undefined || init && newAutoExpandParent !== oldAutoExpandParent) {
        keys = props.autoExpandParent || !init && props.defaultExpandParent ? (0,util/* conductExpandParent */.r7)(props.expandedKeys, keyEntities.value) : props.expandedKeys;
      } else if (!init && props.defaultExpandAll) {
        const cloneKeyEntities = (0,esm_extends/* default */.Z)({}, keyEntities.value);
        delete cloneKeyEntities[MOTION_KEY];
        keys = Object.keys(cloneKeyEntities).map(key => cloneKeyEntities[key].key);
      } else if (!init && props.defaultExpandedKeys) {
        keys = props.autoExpandParent || props.defaultExpandParent ? (0,util/* conductExpandParent */.r7)(props.defaultExpandedKeys, keyEntities.value) : props.defaultExpandedKeys;
      }
      if (keys) {
        expandedKeys.value = keys;
      }
      init = true;
    }, {
      immediate: true
    });
    // ================ flattenNodes =================
    const flattenNodes = (0,reactivity_esm_bundler/* shallowRef */.XI)([]);
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      flattenNodes.value = (0,treeUtil/* flattenTreeData */.oH)(treeData.value, expandedKeys.value, fieldNames.value);
    });
    // ================ selectedKeys =================
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      if (props.selectable) {
        if (props.selectedKeys !== undefined) {
          selectedKeys.value = (0,util/* calcSelectedKeys */.BT)(props.selectedKeys, props);
        } else if (!init && props.defaultSelectedKeys) {
          selectedKeys.value = (0,util/* calcSelectedKeys */.BT)(props.defaultSelectedKeys, props);
        }
      }
    });
    const {
      maxLevel,
      levelEntities
    } = (0,useMaxLevel/* default */.Z)(keyEntities);
    // ================= checkedKeys =================
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      if (props.checkable) {
        let checkedKeyEntity;
        if (props.checkedKeys !== undefined) {
          checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.checkedKeys) || {};
        } else if (!init && props.defaultCheckedKeys) {
          checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.defaultCheckedKeys) || {};
        } else if (treeData.value) {
          // If `treeData` changed, we also need check it
          checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.checkedKeys) || {
            checkedKeys: checkedKeys.value,
            halfCheckedKeys: halfCheckedKeys.value
          };
        }
        if (checkedKeyEntity) {
          let {
            checkedKeys: newCheckedKeys = [],
            halfCheckedKeys: newHalfCheckedKeys = []
          } = checkedKeyEntity;
          if (!props.checkStrictly) {
            const conductKeys = (0,conductUtil/* conductCheck */.S)(newCheckedKeys, true, keyEntities.value, maxLevel.value, levelEntities.value);
            ({
              checkedKeys: newCheckedKeys,
              halfCheckedKeys: newHalfCheckedKeys
            } = conductKeys);
          }
          checkedKeys.value = newCheckedKeys;
          halfCheckedKeys.value = newHalfCheckedKeys;
        }
      }
    });
    // ================= loadedKeys ==================
    (0,runtime_core_esm_bundler/* watchEffect */.m0)(() => {
      if (props.loadedKeys) {
        loadedKeys.value = props.loadedKeys;
      }
    });
    const resetDragState = () => {
      (0,esm_extends/* default */.Z)(dragState, {
        dragOverNodeKey: null,
        dropPosition: null,
        dropLevelOffset: null,
        dropTargetKey: null,
        dropContainerKey: null,
        dropTargetPos: null,
        dropAllowed: false
      });
    };
    const scrollTo = scroll => {
      listRef.value.scrollTo(scroll);
    };
    (0,runtime_core_esm_bundler/* watch */.YP)(() => props.activeKey, () => {
      if (props.activeKey !== undefined) {
        activeKey.value = props.activeKey;
      }
    }, {
      immediate: true
    });
    (0,runtime_core_esm_bundler/* watch */.YP)(activeKey, val => {
      (0,runtime_core_esm_bundler/* nextTick */.Y3)(() => {
        if (val !== null) {
          scrollTo({
            key: val
          });
        }
      });
    }, {
      immediate: true,
      flush: 'post'
    });
    // =========================== Expanded ===========================
    /** Set uncontrolled `expandedKeys`. This will also auto update `flattenNodes`. */
    const setExpandedKeys = keys => {
      if (props.expandedKeys === undefined) {
        expandedKeys.value = keys;
      }
    };
    const cleanDragState = () => {
      if (dragState.draggingNodeKey !== null) {
        (0,esm_extends/* default */.Z)(dragState, {
          draggingNodeKey: null,
          dropPosition: null,
          dropContainerKey: null,
          dropTargetKey: null,
          dropLevelOffset: null,
          dropAllowed: true,
          dragOverNodeKey: null
        });
      }
      dragStartMousePosition = null;
      currentMouseOverDroppableNodeKey = null;
    };
    // if onNodeDragEnd is called, onWindowDragEnd won't be called since stopPropagation() is called
    const onNodeDragEnd = (event, node) => {
      const {
        onDragend
      } = props;
      dragState.dragOverNodeKey = null;
      cleanDragState();
      onDragend === null || onDragend === void 0 ? void 0 : onDragend({
        event,
        node: node.eventData
      });
      dragNode = null;
    };
    // since stopPropagation() is called in treeNode
    // if onWindowDrag is called, whice means state is keeped, drag state should be cleared
    const onWindowDragEnd = event => {
      onNodeDragEnd(event, null, true);
      window.removeEventListener('dragend', onWindowDragEnd);
    };
    const onNodeDragStart = (event, node) => {
      const {
        onDragstart
      } = props;
      const {
        eventKey,
        eventData
      } = node;
      dragNode = node;
      dragStartMousePosition = {
        x: event.clientX,
        y: event.clientY
      };
      const newExpandedKeys = (0,util/* arrDel */._5)(expandedKeys.value, eventKey);
      dragState.draggingNodeKey = eventKey;
      dragState.dragChildrenKeys = (0,util/* getDragChildrenKeys */.wA)(eventKey, keyEntities.value);
      indent.value = listRef.value.getIndentWidth();
      setExpandedKeys(newExpandedKeys);
      window.addEventListener('dragend', onWindowDragEnd);
      if (onDragstart) {
        onDragstart({
          event,
          node: eventData
        });
      }
    };
    /**
     * [Legacy] Select handler is smaller than node,
     * so that this will trigger when drag enter node or select handler.
     * This is a little tricky if customize css without padding.
     * Better for use mouse move event to refresh drag state.
     * But let's just keep it to avoid event trigger logic change.
     */
    const onNodeDragEnter = (event, node) => {
      const {
        onDragenter,
        onExpand,
        allowDrop,
        direction
      } = props;
      const {
        pos,
        eventKey
      } = node;
      // record the key of node which is latest entered, used in dragleave event.
      if (currentMouseOverDroppableNodeKey !== eventKey) {
        currentMouseOverDroppableNodeKey = eventKey;
      }
      if (!dragNode) {
        resetDragState();
        return;
      }
      const {
        dropPosition,
        dropLevelOffset,
        dropTargetKey,
        dropContainerKey,
        dropTargetPos,
        dropAllowed,
        dragOverNodeKey
      } = (0,util/* calcDropPosition */.OM)(event, dragNode, node, indent.value, dragStartMousePosition, allowDrop, flattenNodes.value, keyEntities.value, expandedKeysSet.value, direction);
      if (
      // don't allow drop inside its children
      dragState.dragChildrenKeys.indexOf(dropTargetKey) !== -1 ||
      // don't allow drop when drop is not allowed caculated by calcDropPosition
      !dropAllowed) {
        resetDragState();
        return;
      }
      // Side effect for delay drag
      if (!delayedDragEnterLogic) {
        delayedDragEnterLogic = {};
      }
      Object.keys(delayedDragEnterLogic).forEach(key => {
        clearTimeout(delayedDragEnterLogic[key]);
      });
      if (dragNode.eventKey !== node.eventKey) {
        // hoist expand logic here
        // since if logic is on the bottom
        // it will be blocked by abstract dragover node check
        //   => if you dragenter from top, you mouse will still be consider as in the top node
        delayedDragEnterLogic[pos] = window.setTimeout(() => {
          if (dragState.draggingNodeKey === null) return;
          let newExpandedKeys = expandedKeys.value.slice();
          const entity = keyEntities.value[node.eventKey];
          if (entity && (entity.children || []).length) {
            newExpandedKeys = (0,util/* arrAdd */.L0)(expandedKeys.value, node.eventKey);
          }
          setExpandedKeys(newExpandedKeys);
          if (onExpand) {
            onExpand(newExpandedKeys, {
              node: node.eventData,
              expanded: true,
              nativeEvent: event
            });
          }
        }, 800);
      }
      // Skip if drag node is self
      if (dragNode.eventKey === dropTargetKey && dropLevelOffset === 0) {
        resetDragState();
        return;
      }
      // Update drag over node and drag state
      (0,esm_extends/* default */.Z)(dragState, {
        dragOverNodeKey,
        dropPosition,
        dropLevelOffset,
        dropTargetKey,
        dropContainerKey,
        dropTargetPos,
        dropAllowed
      });
      if (onDragenter) {
        onDragenter({
          event,
          node: node.eventData,
          expandedKeys: expandedKeys.value
        });
      }
    };
    const onNodeDragOver = (event, node) => {
      const {
        onDragover,
        allowDrop,
        direction
      } = props;
      if (!dragNode) {
        return;
      }
      const {
        dropPosition,
        dropLevelOffset,
        dropTargetKey,
        dropContainerKey,
        dropAllowed,
        dropTargetPos,
        dragOverNodeKey
      } = (0,util/* calcDropPosition */.OM)(event, dragNode, node, indent.value, dragStartMousePosition, allowDrop, flattenNodes.value, keyEntities.value, expandedKeysSet.value, direction);
      if (dragState.dragChildrenKeys.indexOf(dropTargetKey) !== -1 || !dropAllowed) {
        // don't allow drop inside its children
        // don't allow drop when drop is not allowed caculated by calcDropPosition
        return;
      }
      // Update drag position
      if (dragNode.eventKey === dropTargetKey && dropLevelOffset === 0) {
        if (!(dragState.dropPosition === null && dragState.dropLevelOffset === null && dragState.dropTargetKey === null && dragState.dropContainerKey === null && dragState.dropTargetPos === null && dragState.dropAllowed === false && dragState.dragOverNodeKey === null)) {
          resetDragState();
        }
      } else if (!(dropPosition === dragState.dropPosition && dropLevelOffset === dragState.dropLevelOffset && dropTargetKey === dragState.dropTargetKey && dropContainerKey === dragState.dropContainerKey && dropTargetPos === dragState.dropTargetPos && dropAllowed === dragState.dropAllowed && dragOverNodeKey === dragState.dragOverNodeKey)) {
        (0,esm_extends/* default */.Z)(dragState, {
          dropPosition,
          dropLevelOffset,
          dropTargetKey,
          dropContainerKey,
          dropTargetPos,
          dropAllowed,
          dragOverNodeKey
        });
      }
      if (onDragover) {
        onDragover({
          event,
          node: node.eventData
        });
      }
    };
    const onNodeDragLeave = (event, node) => {
      // if it is outside the droppable area
      // currentMouseOverDroppableNodeKey will be updated in dragenter event when into another droppable receiver.
      if (currentMouseOverDroppableNodeKey === node.eventKey && !event.currentTarget.contains(event.relatedTarget)) {
        resetDragState();
        currentMouseOverDroppableNodeKey = null;
      }
      const {
        onDragleave
      } = props;
      if (onDragleave) {
        onDragleave({
          event,
          node: node.eventData
        });
      }
    };
    const onNodeDrop = function (event, _node) {
      let outsideTree = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      var _a;
      const {
        dragChildrenKeys,
        dropPosition,
        dropTargetKey,
        dropTargetPos,
        dropAllowed
      } = dragState;
      if (!dropAllowed) return;
      const {
        onDrop
      } = props;
      dragState.dragOverNodeKey = null;
      cleanDragState();
      if (dropTargetKey === null) return;
      const abstractDropNodeProps = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(dropTargetKey, (0,reactivity_esm_bundler/* toRaw */.IU)(treeNodeRequiredProps.value))), {
        active: ((_a = activeItem.value) === null || _a === void 0 ? void 0 : _a.key) === dropTargetKey,
        data: keyEntities.value[dropTargetKey].node
      });
      const dropToChild = dragChildrenKeys.indexOf(dropTargetKey) !== -1;
      (0,warning/* warning */.Kp)(!dropToChild, "Can not drop to dragNode's children node. Maybe this is a bug of ant-design-vue. Please report an issue.");
      const posArr = (0,util/* posToArr */.yx)(dropTargetPos);
      const dropResult = {
        event,
        node: (0,treeUtil/* convertNodePropsToEventData */.F)(abstractDropNodeProps),
        dragNode: dragNode ? dragNode.eventData : null,
        dragNodesKeys: [dragNode.eventKey].concat(dragChildrenKeys),
        dropToGap: dropPosition !== 0,
        dropPosition: dropPosition + Number(posArr[posArr.length - 1])
      };
      if (!outsideTree) {
        onDrop === null || onDrop === void 0 ? void 0 : onDrop(dropResult);
      }
      dragNode = null;
    };
    const triggerExpandActionExpand = (e, treeNode) => {
      const {
        expanded,
        key
      } = treeNode;
      const node = flattenNodes.value.filter(nodeItem => nodeItem.key === key)[0];
      const eventNode = (0,treeUtil/* convertNodePropsToEventData */.F)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(key, treeNodeRequiredProps.value)), {
        data: node.data
      }));
      setExpandedKeys(expanded ? (0,util/* arrDel */._5)(expandedKeys.value, key) : (0,util/* arrAdd */.L0)(expandedKeys.value, key));
      onNodeExpand(e, eventNode);
    };
    const onNodeClick = (e, treeNode) => {
      const {
        onClick,
        expandAction
      } = props;
      if (expandAction === 'click') {
        triggerExpandActionExpand(e, treeNode);
      }
      if (onClick) {
        onClick(e, treeNode);
      }
    };
    const onNodeDoubleClick = (e, treeNode) => {
      const {
        onDblclick,
        expandAction
      } = props;
      if (expandAction === 'doubleclick' || expandAction === 'dblclick') {
        triggerExpandActionExpand(e, treeNode);
      }
      if (onDblclick) {
        onDblclick(e, treeNode);
      }
    };
    const onNodeSelect = (e, treeNode) => {
      let newSelectedKeys = selectedKeys.value;
      const {
        onSelect,
        multiple
      } = props;
      const {
        selected
      } = treeNode;
      const key = treeNode[fieldNames.value.key];
      const targetSelected = !selected;
      // Update selected keys
      if (!targetSelected) {
        newSelectedKeys = (0,util/* arrDel */._5)(newSelectedKeys, key);
      } else if (!multiple) {
        newSelectedKeys = [key];
      } else {
        newSelectedKeys = (0,util/* arrAdd */.L0)(newSelectedKeys, key);
      }
      // [Legacy] Not found related usage in doc or upper libs
      const keyEntitiesValue = keyEntities.value;
      const selectedNodes = newSelectedKeys.map(selectedKey => {
        const entity = keyEntitiesValue[selectedKey];
        if (!entity) return null;
        return entity.node;
      }).filter(node => node);
      if (props.selectedKeys === undefined) {
        selectedKeys.value = newSelectedKeys;
      }
      if (onSelect) {
        onSelect(newSelectedKeys, {
          event: 'select',
          selected: targetSelected,
          node: treeNode,
          selectedNodes,
          nativeEvent: e
        });
      }
    };
    const onNodeCheck = (e, treeNode, checked) => {
      const {
        checkStrictly,
        onCheck
      } = props;
      const key = treeNode[fieldNames.value.key];
      // Prepare trigger arguments
      let checkedObj;
      const eventObj = {
        event: 'check',
        node: treeNode,
        checked,
        nativeEvent: e
      };
      const keyEntitiesValue = keyEntities.value;
      if (checkStrictly) {
        const newCheckedKeys = checked ? (0,util/* arrAdd */.L0)(checkedKeys.value, key) : (0,util/* arrDel */._5)(checkedKeys.value, key);
        const newHalfCheckedKeys = (0,util/* arrDel */._5)(halfCheckedKeys.value, key);
        checkedObj = {
          checked: newCheckedKeys,
          halfChecked: newHalfCheckedKeys
        };
        eventObj.checkedNodes = newCheckedKeys.map(checkedKey => keyEntitiesValue[checkedKey]).filter(entity => entity).map(entity => entity.node);
        if (props.checkedKeys === undefined) {
          checkedKeys.value = newCheckedKeys;
        }
      } else {
        // Always fill first
        let {
          checkedKeys: newCheckedKeys,
          halfCheckedKeys: newHalfCheckedKeys
        } = (0,conductUtil/* conductCheck */.S)([...checkedKeys.value, key], true, keyEntitiesValue, maxLevel.value, levelEntities.value);
        // If remove, we do it again to correction
        if (!checked) {
          const keySet = new Set(newCheckedKeys);
          keySet.delete(key);
          ({
            checkedKeys: newCheckedKeys,
            halfCheckedKeys: newHalfCheckedKeys
          } = (0,conductUtil/* conductCheck */.S)(Array.from(keySet), {
            checked: false,
            halfCheckedKeys: newHalfCheckedKeys
          }, keyEntitiesValue, maxLevel.value, levelEntities.value));
        }
        checkedObj = newCheckedKeys;
        // [Legacy] This is used for vc-tree-select`
        eventObj.checkedNodes = [];
        eventObj.checkedNodesPositions = [];
        eventObj.halfCheckedKeys = newHalfCheckedKeys;
        newCheckedKeys.forEach(checkedKey => {
          const entity = keyEntitiesValue[checkedKey];
          if (!entity) return;
          const {
            node,
            pos
          } = entity;
          eventObj.checkedNodes.push(node);
          eventObj.checkedNodesPositions.push({
            node,
            pos
          });
        });
        if (props.checkedKeys === undefined) {
          checkedKeys.value = newCheckedKeys;
          halfCheckedKeys.value = newHalfCheckedKeys;
        }
      }
      if (onCheck) {
        onCheck(checkedObj, eventObj);
      }
    };
    const onNodeLoad = treeNode => {
      const key = treeNode[fieldNames.value.key];
      const loadPromise = new Promise((resolve, reject) => {
        // We need to get the latest state of loading/loaded keys
        const {
          loadData,
          onLoad
        } = props;
        if (!loadData || loadedKeysSet.value.has(key) || loadingKeysSet.value.has(key)) {
          return null;
        }
        // Process load data
        const promise = loadData(treeNode);
        promise.then(() => {
          const newLoadedKeys = (0,util/* arrAdd */.L0)(loadedKeys.value, key);
          const newLoadingKeys = (0,util/* arrDel */._5)(loadingKeys.value, key);
          // onLoad should trigger before internal setState to avoid `loadData` trigger twice.
          // https://github.com/ant-design/ant-design/issues/12464
          if (onLoad) {
            onLoad(newLoadedKeys, {
              event: 'load',
              node: treeNode
            });
          }
          if (props.loadedKeys === undefined) {
            loadedKeys.value = newLoadedKeys;
          }
          loadingKeys.value = newLoadingKeys;
          resolve();
        }).catch(e => {
          const newLoadingKeys = (0,util/* arrDel */._5)(loadingKeys.value, key);
          loadingKeys.value = newLoadingKeys;
          // If exceed max retry times, we give up retry
          loadingRetryTimes[key] = (loadingRetryTimes[key] || 0) + 1;
          if (loadingRetryTimes[key] >= MAX_RETRY_TIMES) {
            (0,warning/* warning */.Kp)(false, 'Retry for `loadData` many times but still failed. No more retry.');
            const newLoadedKeys = (0,util/* arrAdd */.L0)(loadedKeys.value, key);
            if (props.loadedKeys === undefined) {
              loadedKeys.value = newLoadedKeys;
            }
            resolve();
          }
          reject(e);
        });
        loadingKeys.value = (0,util/* arrAdd */.L0)(loadingKeys.value, key);
      });
      // Not care warning if we ignore this
      loadPromise.catch(() => {});
      return loadPromise;
    };
    const onNodeMouseEnter = (event, node) => {
      const {
        onMouseenter
      } = props;
      if (onMouseenter) {
        onMouseenter({
          event,
          node
        });
      }
    };
    const onNodeMouseLeave = (event, node) => {
      const {
        onMouseleave
      } = props;
      if (onMouseleave) {
        onMouseleave({
          event,
          node
        });
      }
    };
    const onNodeContextMenu = (event, node) => {
      const {
        onRightClick
      } = props;
      if (onRightClick) {
        event.preventDefault();
        onRightClick({
          event,
          node
        });
      }
    };
    const onFocus = e => {
      const {
        onFocus
      } = props;
      focused.value = true;
      if (onFocus) {
        onFocus(e);
      }
    };
    const onBlur = e => {
      const {
        onBlur
      } = props;
      focused.value = false;
      onActiveChange(null);
      if (onBlur) {
        onBlur(e);
      }
    };
    const onNodeExpand = (e, treeNode) => {
      let newExpandedKeys = expandedKeys.value;
      const {
        onExpand,
        loadData
      } = props;
      const {
        expanded
      } = treeNode;
      const key = treeNode[fieldNames.value.key];
      // Do nothing when motion is in progress
      if (listChanging.value) {
        return;
      }
      // Update selected keys
      const index = newExpandedKeys.indexOf(key);
      const targetExpanded = !expanded;
      (0,warning/* warning */.Kp)(expanded && index !== -1 || !expanded && index === -1, 'Expand state not sync with index check');
      if (targetExpanded) {
        newExpandedKeys = (0,util/* arrAdd */.L0)(newExpandedKeys, key);
      } else {
        newExpandedKeys = (0,util/* arrDel */._5)(newExpandedKeys, key);
      }
      setExpandedKeys(newExpandedKeys);
      if (onExpand) {
        onExpand(newExpandedKeys, {
          node: treeNode,
          expanded: targetExpanded,
          nativeEvent: e
        });
      }
      // Async Load data
      if (targetExpanded && loadData) {
        const loadPromise = onNodeLoad(treeNode);
        if (loadPromise) {
          loadPromise.then(() => {
            // [Legacy] Refresh logic
            // const newFlattenTreeData = flattenTreeData(
            //   treeData.value,
            //   newExpandedKeys,
            //   fieldNames.value,
            // );
            // flattenNodes.value = newFlattenTreeData;
          }).catch(e => {
            const expandedKeysToRestore = (0,util/* arrDel */._5)(expandedKeys.value, key);
            setExpandedKeys(expandedKeysToRestore);
            Promise.reject(e);
          });
        }
      }
    };
    const onListChangeStart = () => {
      listChanging.value = true;
    };
    const onListChangeEnd = () => {
      setTimeout(() => {
        listChanging.value = false;
      });
    };
    // =========================== Keyboard ===========================
    const onActiveChange = newActiveKey => {
      const {
        onActiveChange
      } = props;
      if (activeKey.value === newActiveKey) {
        return;
      }
      if (props.activeKey !== undefined) {
        activeKey.value = newActiveKey;
      }
      if (newActiveKey !== null) {
        scrollTo({
          key: newActiveKey
        });
      }
      if (onActiveChange) {
        onActiveChange(newActiveKey);
      }
    };
    const activeItem = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      if (activeKey.value === null) {
        return null;
      }
      return flattenNodes.value.find(_ref4 => {
        let {
          key
        } = _ref4;
        return key === activeKey.value;
      }) || null;
    });
    const offsetActiveKey = offset => {
      let index = flattenNodes.value.findIndex(_ref5 => {
        let {
          key
        } = _ref5;
        return key === activeKey.value;
      });
      // Align with index
      if (index === -1 && offset < 0) {
        index = flattenNodes.value.length;
      }
      index = (index + offset + flattenNodes.value.length) % flattenNodes.value.length;
      const item = flattenNodes.value[index];
      if (item) {
        const {
          key
        } = item;
        onActiveChange(key);
      } else {
        onActiveChange(null);
      }
    };
    const activeItemEventNode = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return (0,treeUtil/* convertNodePropsToEventData */.F)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(activeKey.value, treeNodeRequiredProps.value)), {
        data: activeItem.value.data,
        active: true
      }));
    });
    const onKeydown = event => {
      const {
        onKeydown,
        checkable,
        selectable
      } = props;
      // >>>>>>>>>> Direction
      switch (event.which) {
        case KeyCode/* default.UP */.Z.UP:
          {
            offsetActiveKey(-1);
            event.preventDefault();
            break;
          }
        case KeyCode/* default.DOWN */.Z.DOWN:
          {
            offsetActiveKey(1);
            event.preventDefault();
            break;
          }
      }
      // >>>>>>>>>> Expand & Selection
      const item = activeItem.value;
      if (item && item.data) {
        const expandable = item.data.isLeaf === false || !!(item.data.children || []).length;
        const eventNode = activeItemEventNode.value;
        switch (event.which) {
          // >>> Expand
          case KeyCode/* default.LEFT */.Z.LEFT:
            {
              // Collapse if possible
              if (expandable && expandedKeysSet.value.has(activeKey.value)) {
                onNodeExpand({}, eventNode);
              } else if (item.parent) {
                onActiveChange(item.parent.key);
              }
              event.preventDefault();
              break;
            }
          case KeyCode/* default.RIGHT */.Z.RIGHT:
            {
              // Expand if possible
              if (expandable && !expandedKeysSet.value.has(activeKey.value)) {
                onNodeExpand({}, eventNode);
              } else if (item.children && item.children.length) {
                onActiveChange(item.children[0].key);
              }
              event.preventDefault();
              break;
            }
          // Selection
          case KeyCode/* default.ENTER */.Z.ENTER:
          case KeyCode/* default.SPACE */.Z.SPACE:
            {
              if (checkable && !eventNode.disabled && eventNode.checkable !== false && !eventNode.disableCheckbox) {
                onNodeCheck({}, eventNode, !checkedKeysSet.value.has(activeKey.value));
              } else if (!checkable && selectable && !eventNode.disabled && eventNode.selectable !== false) {
                onNodeSelect({}, eventNode);
              }
              break;
            }
        }
      }
      if (onKeydown) {
        onKeydown(event);
      }
    };
    expose({
      onNodeExpand,
      scrollTo,
      onKeydown,
      selectedKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => selectedKeys.value),
      checkedKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => checkedKeys.value),
      halfCheckedKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => halfCheckedKeys.value),
      loadedKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => loadedKeys.value),
      loadingKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => loadingKeys.value),
      expandedKeys: (0,runtime_core_esm_bundler/* computed */.Fl)(() => expandedKeys.value)
    });
    (0,runtime_core_esm_bundler/* onUnmounted */.Ah)(() => {
      window.removeEventListener('dragend', onWindowDragEnd);
      destroyed.value = true;
    });
    (0,contextTypes/* useProvideKeysState */.vF)({
      expandedKeys,
      selectedKeys,
      loadedKeys,
      loadingKeys,
      checkedKeys,
      halfCheckedKeys,
      expandedKeysSet,
      selectedKeysSet,
      loadedKeysSet,
      loadingKeysSet,
      checkedKeysSet,
      halfCheckedKeysSet,
      flattenNodes
    });
    return () => {
      const {
        // focused,
        // flattenNodes,
        // keyEntities,
        draggingNodeKey,
        // activeKey,
        dropLevelOffset,
        dropContainerKey,
        dropTargetKey,
        dropPosition,
        dragOverNodeKey
        // indent,
      } = dragState;
      const {
        prefixCls,
        showLine,
        focusable,
        tabindex = 0,
        selectable,
        showIcon,
        icon = slots.icon,
        switcherIcon,
        draggable,
        checkable,
        checkStrictly,
        disabled,
        motion,
        loadData,
        filterTreeNode,
        height,
        itemHeight,
        virtual,
        dropIndicatorRender,
        onContextmenu,
        onScroll,
        direction,
        rootClassName,
        rootStyle
      } = props;
      const {
        class: className,
        style
      } = attrs;
      const domProps = (0,pickAttrs/* default */.Z)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props), attrs), {
        aria: true,
        data: true
      });
      // It's better move to hooks but we just simply keep here
      let draggableConfig;
      if (draggable) {
        if (typeof draggable === 'object') {
          draggableConfig = draggable;
        } else if (typeof draggable === 'function') {
          draggableConfig = {
            nodeDraggable: draggable
          };
        } else {
          draggableConfig = {};
        }
      } else {
        draggableConfig = false;
      }
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)(contextTypes/* TreeContext */.kw, {
        "value": {
          prefixCls,
          selectable,
          showIcon,
          icon,
          switcherIcon,
          draggable: draggableConfig,
          draggingNodeKey,
          checkable,
          customCheckable: slots.checkable,
          checkStrictly,
          disabled,
          keyEntities: keyEntities.value,
          dropLevelOffset,
          dropContainerKey,
          dropTargetKey,
          dropPosition,
          dragOverNodeKey,
          dragging: draggingNodeKey !== null,
          indent: indent.value,
          direction,
          dropIndicatorRender,
          loadData,
          filterTreeNode,
          onNodeClick,
          onNodeDoubleClick,
          onNodeExpand,
          onNodeSelect,
          onNodeCheck,
          onNodeLoad,
          onNodeMouseEnter,
          onNodeMouseLeave,
          onNodeContextMenu,
          onNodeDragStart,
          onNodeDragEnter,
          onNodeDragOver,
          onNodeDragLeave,
          onNodeDragEnd,
          onNodeDrop,
          slots
        }
      }, {
        default: () => [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
          "role": "tree",
          "class": (0,classNames/* default */.Z)(prefixCls, className, rootClassName, {
            [`${prefixCls}-show-line`]: showLine,
            [`${prefixCls}-focused`]: focused.value,
            [`${prefixCls}-active-focused`]: activeKey.value !== null
          }),
          "style": rootStyle
        }, [(0,runtime_core_esm_bundler/* createVNode */.Wm)(NodeList, (0,objectSpread2/* default */.Z)({
          "ref": listRef,
          "prefixCls": prefixCls,
          "style": style,
          "disabled": disabled,
          "selectable": selectable,
          "checkable": !!checkable,
          "motion": motion,
          "height": height,
          "itemHeight": itemHeight,
          "virtual": virtual,
          "focusable": focusable,
          "focused": focused.value,
          "tabindex": tabindex,
          "activeItem": activeItem.value,
          "onFocus": onFocus,
          "onBlur": onBlur,
          "onKeydown": onKeydown,
          "onActiveChange": onActiveChange,
          "onListChangeStart": onListChangeStart,
          "onListChangeEnd": onListChangeEnd,
          "onContextmenu": onContextmenu,
          "onScroll": onScroll
        }, domProps), null)])]
      });
    };
  }
}));

/***/ }),

/***/ 31295:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "Z": () => (/* binding */ TreeNode)
});

// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 1 modules
var objectSpread2 = __webpack_require__(38295);
// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(62081);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-core@3.3.1/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var runtime_core_esm_bundler = __webpack_require__(27520);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/contextTypes.js
var contextTypes = __webpack_require__(31993);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/Indent.js

const Indent = _ref => {
  let {
    prefixCls,
    level,
    isStart,
    isEnd
  } = _ref;
  const baseClassName = `${prefixCls}-indent-unit`;
  const list = [];
  for (let i = 0; i < level; i += 1) {
    list.push((0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
      "key": i,
      "class": {
        [baseClassName]: true,
        [`${baseClassName}-start`]: isStart[i],
        [`${baseClassName}-end`]: isEnd[i]
      }
    }, null));
  }
  return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
    "aria-hidden": "true",
    "class": `${prefixCls}-indent`
  }, [list]);
};
/* harmony default export */ const vc_tree_Indent = (Indent);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/utils/treeUtil.js
var treeUtil = __webpack_require__(66443);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+reactivity@3.3.1/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
var reactivity_esm_bundler = __webpack_require__(83270);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/props.js
var props = __webpack_require__(94125);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/classNames.js
var classNames = __webpack_require__(64334);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-util/warning.js
var warning = __webpack_require__(83630);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/pickAttrs.js
var pickAttrs = __webpack_require__(1405);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/eagerComputed.js
var eagerComputed = __webpack_require__(66674);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-tree/TreeNode.js



var __rest = undefined && undefined.__rest || function (s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
};









const ICON_OPEN = 'open';
const ICON_CLOSE = 'close';
const defaultTitle = '---';
/* harmony default export */ const TreeNode = ((0,runtime_core_esm_bundler/* defineComponent */.aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'ATreeNode',
  inheritAttrs: false,
  props: props/* treeNodeProps */.Pe,
  isTreeNode: 1,
  setup(props, _ref) {
    let {
      attrs,
      slots,
      expose
    } = _ref;
    (0,warning/* warning */.Kp)(!('slots' in props.data), `treeData slots is deprecated, please use ${Object.keys(props.data.slots || {}).map(key => '`v-slot:' + key + '` ')}instead`);
    const dragNodeHighlight = (0,reactivity_esm_bundler/* shallowRef */.XI)(false);
    const context = (0,contextTypes/* useInjectTreeContext */.Mk)();
    const {
      expandedKeysSet,
      selectedKeysSet,
      loadedKeysSet,
      loadingKeysSet,
      checkedKeysSet,
      halfCheckedKeysSet
    } = (0,contextTypes/* useInjectKeysState */.IB)();
    const {
      dragOverNodeKey,
      dropPosition,
      keyEntities
    } = context.value;
    const mergedTreeNodeProps = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      return (0,treeUtil/* getTreeNodeProps */.H8)(props.eventKey, {
        expandedKeysSet: expandedKeysSet.value,
        selectedKeysSet: selectedKeysSet.value,
        loadedKeysSet: loadedKeysSet.value,
        loadingKeysSet: loadingKeysSet.value,
        checkedKeysSet: checkedKeysSet.value,
        halfCheckedKeysSet: halfCheckedKeysSet.value,
        dragOverNodeKey,
        dropPosition,
        keyEntities
      });
    });
    const expanded = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.expanded);
    const selected = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.selected);
    const checked = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.checked);
    const loaded = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.loaded);
    const loading = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.loading);
    const halfChecked = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.halfChecked);
    const dragOver = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.dragOver);
    const dragOverGapTop = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.dragOverGapTop);
    const dragOverGapBottom = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.dragOverGapBottom);
    const pos = (0,eagerComputed/* default */.Z)(() => mergedTreeNodeProps.value.pos);
    const selectHandle = (0,reactivity_esm_bundler/* shallowRef */.XI)();
    const hasChildren = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        eventKey
      } = props;
      const {
        keyEntities
      } = context.value;
      const {
        children
      } = keyEntities[eventKey] || {};
      return !!(children || []).length;
    });
    const isLeaf = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        isLeaf
      } = props;
      const {
        loadData
      } = context.value;
      const has = hasChildren.value;
      if (isLeaf === false) {
        return false;
      }
      return isLeaf || !loadData && !has || loadData && loaded.value && !has;
    });
    const nodeState = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      if (isLeaf.value) {
        return null;
      }
      return expanded.value ? ICON_OPEN : ICON_CLOSE;
    });
    const isDisabled = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        disabled
      } = props;
      const {
        disabled: treeDisabled
      } = context.value;
      return !!(treeDisabled || disabled);
    });
    const isCheckable = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        checkable
      } = props;
      const {
        checkable: treeCheckable
      } = context.value;
      // Return false if tree or treeNode is not checkable
      if (!treeCheckable || checkable === false) return false;
      return treeCheckable;
    });
    const isSelectable = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        selectable
      } = props;
      const {
        selectable: treeSelectable
      } = context.value;
      // Ignore when selectable is undefined or null
      if (typeof selectable === 'boolean') {
        return selectable;
      }
      return treeSelectable;
    });
    const renderArgsData = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        data,
        active,
        checkable,
        disableCheckbox,
        disabled,
        selectable
      } = props;
      return (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({
        active,
        checkable,
        disableCheckbox,
        disabled,
        selectable
      }, data), {
        dataRef: data,
        data,
        isLeaf: isLeaf.value,
        checked: checked.value,
        expanded: expanded.value,
        loading: loading.value,
        selected: selected.value,
        halfChecked: halfChecked.value
      });
    });
    const instance = (0,runtime_core_esm_bundler/* getCurrentInstance */.FN)();
    const eventData = (0,runtime_core_esm_bundler/* computed */.Fl)(() => {
      const {
        eventKey
      } = props;
      const {
        keyEntities
      } = context.value;
      const {
        parent
      } = keyEntities[eventKey] || {};
      return (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, (0,treeUtil/* convertNodePropsToEventData */.F)((0,esm_extends/* default */.Z)({}, props, mergedTreeNodeProps.value))), {
        parent
      });
    });
    const dragNodeEvent = (0,reactivity_esm_bundler/* reactive */.qj)({
      eventData,
      eventKey: (0,runtime_core_esm_bundler/* computed */.Fl)(() => props.eventKey),
      selectHandle,
      pos,
      key: instance.vnode.key
    });
    expose(dragNodeEvent);
    const onSelectorDoubleClick = e => {
      const {
        onNodeDoubleClick
      } = context.value;
      onNodeDoubleClick(e, eventData.value);
    };
    const onSelect = e => {
      if (isDisabled.value) return;
      const {
        onNodeSelect
      } = context.value;
      e.preventDefault();
      onNodeSelect(e, eventData.value);
    };
    const onCheck = e => {
      if (isDisabled.value) return;
      const {
        disableCheckbox
      } = props;
      const {
        onNodeCheck
      } = context.value;
      if (!isCheckable.value || disableCheckbox) return;
      e.preventDefault();
      const targetChecked = !checked.value;
      onNodeCheck(e, eventData.value, targetChecked);
    };
    const onSelectorClick = e => {
      // Click trigger before select/check operation
      const {
        onNodeClick
      } = context.value;
      onNodeClick(e, eventData.value);
      if (isSelectable.value) {
        onSelect(e);
      } else {
        onCheck(e);
      }
    };
    const onMouseEnter = e => {
      const {
        onNodeMouseEnter
      } = context.value;
      onNodeMouseEnter(e, eventData.value);
    };
    const onMouseLeave = e => {
      const {
        onNodeMouseLeave
      } = context.value;
      onNodeMouseLeave(e, eventData.value);
    };
    const onContextmenu = e => {
      const {
        onNodeContextMenu
      } = context.value;
      onNodeContextMenu(e, eventData.value);
    };
    const onDragStart = e => {
      const {
        onNodeDragStart
      } = context.value;
      e.stopPropagation();
      dragNodeHighlight.value = true;
      onNodeDragStart(e, dragNodeEvent);
      try {
        // ie throw error
        // firefox-need-it
        e.dataTransfer.setData('text/plain', '');
      } catch (error) {
        // empty
      }
    };
    const onDragEnter = e => {
      const {
        onNodeDragEnter
      } = context.value;
      e.preventDefault();
      e.stopPropagation();
      onNodeDragEnter(e, dragNodeEvent);
    };
    const onDragOver = e => {
      const {
        onNodeDragOver
      } = context.value;
      e.preventDefault();
      e.stopPropagation();
      onNodeDragOver(e, dragNodeEvent);
    };
    const onDragLeave = e => {
      const {
        onNodeDragLeave
      } = context.value;
      e.stopPropagation();
      onNodeDragLeave(e, dragNodeEvent);
    };
    const onDragEnd = e => {
      const {
        onNodeDragEnd
      } = context.value;
      e.stopPropagation();
      dragNodeHighlight.value = false;
      onNodeDragEnd(e, dragNodeEvent);
    };
    const onDrop = e => {
      const {
        onNodeDrop
      } = context.value;
      e.preventDefault();
      e.stopPropagation();
      dragNodeHighlight.value = false;
      onNodeDrop(e, dragNodeEvent);
    };
    // Disabled item still can be switch
    const onExpand = e => {
      const {
        onNodeExpand
      } = context.value;
      if (loading.value) return;
      onNodeExpand(e, eventData.value);
    };
    const isDraggable = () => {
      const {
        data
      } = props;
      const {
        draggable
      } = context.value;
      return !!(draggable && (!draggable.nodeDraggable || draggable.nodeDraggable(data)));
    };
    // ==================== Render: Drag Handler ====================
    const renderDragHandler = () => {
      const {
        draggable,
        prefixCls
      } = context.value;
      return draggable && (draggable === null || draggable === void 0 ? void 0 : draggable.icon) ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "class": `${prefixCls}-draggable-icon`
      }, [draggable.icon]) : null;
    };
    const renderSwitcherIconDom = () => {
      var _a, _b, _c;
      const {
        switcherIcon: switcherIconFromProps = slots.switcherIcon || ((_a = context.value.slots) === null || _a === void 0 ? void 0 : _a[(_c = (_b = props.data) === null || _b === void 0 ? void 0 : _b.slots) === null || _c === void 0 ? void 0 : _c.switcherIcon])
      } = props;
      const {
        switcherIcon: switcherIconFromCtx
      } = context.value;
      const switcherIcon = switcherIconFromProps || switcherIconFromCtx;
      // if switcherIconDom is null, no render switcher span
      if (typeof switcherIcon === 'function') {
        return switcherIcon(renderArgsData.value);
      }
      return switcherIcon;
    };
    // Load data to avoid default expanded tree without data
    const syncLoadData = () => {
      //const { expanded, loading, loaded } = props;
      const {
        loadData,
        onNodeLoad
      } = context.value;
      if (loading.value) {
        return;
      }
      // read from state to avoid loadData at same time
      if (loadData && expanded.value && !isLeaf.value) {
        // We needn't reload data when has children in sync logic
        // It's only needed in node expanded
        if (!hasChildren.value && !loaded.value) {
          onNodeLoad(eventData.value);
        }
      }
    };
    (0,runtime_core_esm_bundler/* onMounted */.bv)(() => {
      syncLoadData();
    });
    (0,runtime_core_esm_bundler/* onUpdated */.ic)(() => {
      // https://github.com/vueComponent/ant-design-vue/issues/4835
      syncLoadData();
    });
    // Switcher
    const renderSwitcher = () => {
      const {
        prefixCls
      } = context.value;
      // if switcherIconDom is null, no render switcher span
      const switcherIconDom = renderSwitcherIconDom();
      if (isLeaf.value) {
        return switcherIconDom !== false ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
          "class": (0,classNames/* default */.Z)(`${prefixCls}-switcher`, `${prefixCls}-switcher-noop`)
        }, [switcherIconDom]) : null;
      }
      const switcherCls = (0,classNames/* default */.Z)(`${prefixCls}-switcher`, `${prefixCls}-switcher_${expanded.value ? ICON_OPEN : ICON_CLOSE}`);
      return switcherIconDom !== false ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "onClick": onExpand,
        "class": switcherCls
      }, [switcherIconDom]) : null;
    };
    // Checkbox
    const renderCheckbox = () => {
      var _a, _b;
      const {
        disableCheckbox
      } = props;
      const {
        prefixCls
      } = context.value;
      const disabled = isDisabled.value;
      const checkable = isCheckable.value;
      if (!checkable) return null;
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "class": (0,classNames/* default */.Z)(`${prefixCls}-checkbox`, checked.value && `${prefixCls}-checkbox-checked`, !checked.value && halfChecked.value && `${prefixCls}-checkbox-indeterminate`, (disabled || disableCheckbox) && `${prefixCls}-checkbox-disabled`),
        "onClick": onCheck
      }, [(_b = (_a = context.value).customCheckable) === null || _b === void 0 ? void 0 : _b.call(_a)]);
    };
    const renderIcon = () => {
      const {
        prefixCls
      } = context.value;
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "class": (0,classNames/* default */.Z)(`${prefixCls}-iconEle`, `${prefixCls}-icon__${nodeState.value || 'docu'}`, loading.value && `${prefixCls}-icon_loading`)
      }, null);
    };
    const renderDropIndicator = () => {
      const {
        disabled,
        eventKey
      } = props;
      const {
        draggable,
        dropLevelOffset,
        dropPosition,
        prefixCls,
        indent,
        dropIndicatorRender,
        dragOverNodeKey,
        direction
      } = context.value;
      const rootDraggable = draggable !== false;
      // allowDrop is calculated in Tree.tsx, there is no need for calc it here
      const showIndicator = !disabled && rootDraggable && dragOverNodeKey === eventKey;
      return showIndicator ? dropIndicatorRender({
        dropPosition,
        dropLevelOffset,
        indent,
        prefixCls,
        direction
      }) : null;
    };
    // Icon + Title
    const renderSelector = () => {
      var _a, _b, _c, _d, _e, _f;
      const {
        // title = slots.title ||
        //   context.value.slots?.[props.data?.slots?.title] ||
        //   context.value.slots?.title,
        // selected,
        icon = slots.icon,
        // loading,
        data
      } = props;
      const title = slots.title || ((_a = context.value.slots) === null || _a === void 0 ? void 0 : _a[(_c = (_b = props.data) === null || _b === void 0 ? void 0 : _b.slots) === null || _c === void 0 ? void 0 : _c.title]) || ((_d = context.value.slots) === null || _d === void 0 ? void 0 : _d.title) || props.title;
      const {
        prefixCls,
        showIcon,
        icon: treeIcon,
        loadData
        // slots: contextSlots,
      } = context.value;
      const disabled = isDisabled.value;
      const wrapClass = `${prefixCls}-node-content-wrapper`;
      // Icon - Still show loading icon when loading without showIcon
      let $icon;
      if (showIcon) {
        const currentIcon = icon || ((_e = context.value.slots) === null || _e === void 0 ? void 0 : _e[(_f = data === null || data === void 0 ? void 0 : data.slots) === null || _f === void 0 ? void 0 : _f.icon]) || treeIcon;
        $icon = currentIcon ? (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
          "class": (0,classNames/* default */.Z)(`${prefixCls}-iconEle`, `${prefixCls}-icon__customize`)
        }, [typeof currentIcon === 'function' ? currentIcon(renderArgsData.value) : currentIcon]) : renderIcon();
      } else if (loadData && loading.value) {
        $icon = renderIcon();
      }
      // Title
      let titleNode;
      if (typeof title === 'function') {
        titleNode = title(renderArgsData.value);
        // } else if (contextSlots.titleRender) {
        //   titleNode = contextSlots.titleRender(renderArgsData.value);
      } else {
        titleNode = title;
      }
      titleNode = titleNode === undefined ? defaultTitle : titleNode;
      const $title = (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "class": `${prefixCls}-title`
      }, [titleNode]);
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
        "ref": selectHandle,
        "title": typeof title === 'string' ? title : '',
        "class": (0,classNames/* default */.Z)(`${wrapClass}`, `${wrapClass}-${nodeState.value || 'normal'}`, !disabled && (selected.value || dragNodeHighlight.value) && `${prefixCls}-node-selected`),
        "onMouseenter": onMouseEnter,
        "onMouseleave": onMouseLeave,
        "onContextmenu": onContextmenu,
        "onClick": onSelectorClick,
        "onDblclick": onSelectorDoubleClick
      }, [$icon, $title, renderDropIndicator()]);
    };
    return () => {
      const _a = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props), attrs),
        {
          eventKey,
          isLeaf,
          isStart,
          isEnd,
          domRef,
          active,
          data,
          onMousemove,
          selectable
        } = _a,
        otherProps = __rest(_a, ["eventKey", "isLeaf", "isStart", "isEnd", "domRef", "active", "data", "onMousemove", "selectable"]);
      const {
        prefixCls,
        filterTreeNode,
        keyEntities,
        dropContainerKey,
        dropTargetKey,
        draggingNodeKey
      } = context.value;
      const disabled = isDisabled.value;
      const dataOrAriaAttributeProps = (0,pickAttrs/* default */.Z)(otherProps, {
        aria: true,
        data: true
      });
      const {
        level
      } = keyEntities[eventKey] || {};
      const isEndNode = isEnd[isEnd.length - 1];
      const mergedDraggable = isDraggable();
      const draggableWithoutDisabled = !disabled && mergedDraggable;
      const dragging = draggingNodeKey === eventKey;
      const ariaSelected = selectable !== undefined ? {
        'aria-selected': !!selectable
      } : undefined;
      // console.log(1);
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
        "ref": domRef,
        "class": (0,classNames/* default */.Z)(attrs.class, `${prefixCls}-treenode`, {
          [`${prefixCls}-treenode-disabled`]: disabled,
          [`${prefixCls}-treenode-switcher-${expanded.value ? 'open' : 'close'}`]: !isLeaf,
          [`${prefixCls}-treenode-checkbox-checked`]: checked.value,
          [`${prefixCls}-treenode-checkbox-indeterminate`]: halfChecked.value,
          [`${prefixCls}-treenode-selected`]: selected.value,
          [`${prefixCls}-treenode-loading`]: loading.value,
          [`${prefixCls}-treenode-active`]: active,
          [`${prefixCls}-treenode-leaf-last`]: isEndNode,
          [`${prefixCls}-treenode-draggable`]: draggableWithoutDisabled,
          dragging,
          'drop-target': dropTargetKey === eventKey,
          'drop-container': dropContainerKey === eventKey,
          'drag-over': !disabled && dragOver.value,
          'drag-over-gap-top': !disabled && dragOverGapTop.value,
          'drag-over-gap-bottom': !disabled && dragOverGapBottom.value,
          'filter-node': filterTreeNode && filterTreeNode(eventData.value)
        }),
        "style": attrs.style,
        "draggable": draggableWithoutDisabled,
        "aria-grabbed": dragging,
        "onDragstart": draggableWithoutDisabled ? onDragStart : undefined,
        "onDragenter": mergedDraggable ? onDragEnter : undefined,
        "onDragover": mergedDraggable ? onDragOver : undefined,
        "onDragleave": mergedDraggable ? onDragLeave : undefined,
        "onDrop": mergedDraggable ? onDrop : undefined,
        "onDragend": mergedDraggable ? onDragEnd : undefined,
        "onMousemove": onMousemove
      }, ariaSelected), dataOrAriaAttributeProps), [(0,runtime_core_esm_bundler/* createVNode */.Wm)(vc_tree_Indent, {
        "prefixCls": prefixCls,
        "level": level,
        "isStart": isStart,
        "isEnd": isEnd
      }, null), renderDragHandler(), renderSwitcher(), renderCheckbox(), renderSelector()]);
    };
  }
}));

/***/ }),

/***/ 31993:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "IB": () => (/* binding */ useInjectKeysState),
/* harmony export */   "Mk": () => (/* binding */ useInjectTreeContext),
/* harmony export */   "kw": () => (/* binding */ TreeContext),
/* harmony export */   "vF": () => (/* binding */ useProvideKeysState)
/* harmony export */ });
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27520);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(83270);
/**
 * Webpack has bug for import loop, which is not the same behavior as ES module.
 * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
 */

const TreeContextKey = Symbol('TreeContextKey');
const TreeContext = (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .defineComponent */ .aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'TreeContext',
  props: {
    value: {
      type: Object
    }
  },
  setup(props, _ref) {
    let {
      slots
    } = _ref;
    (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .provide */ .JJ)(TreeContextKey, (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => props.value));
    return () => {
      var _a;
      return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
    };
  }
});
const useInjectTreeContext = () => {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .inject */ .f3)(TreeContextKey, (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => ({})));
};
const KeysStateKey = Symbol('KeysStateKey');
const useProvideKeysState = state => {
  (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .provide */ .JJ)(KeysStateKey, state);
};
const useInjectKeysState = () => {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .inject */ .f3)(KeysStateKey, {
    expandedKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    selectedKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    loadedKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    loadingKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    checkedKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    halfCheckedKeys: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([]),
    expandedKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    selectedKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    loadedKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    loadingKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    checkedKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    halfCheckedKeysSet: (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => new Set()),
    flattenNodes: (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .shallowRef */ .XI)([])
  });
};

/***/ }),

/***/ 89291:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _Tree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73266);



/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_Tree__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z);

/***/ }),

/***/ 94125:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Ni": () => (/* binding */ treeProps),
/* harmony export */   "Pe": () => (/* binding */ treeNodeProps),
/* harmony export */   "dh": () => (/* binding */ nodeListProps)
/* harmony export */ });
/* harmony import */ var _util_vue_types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33999);

const treeNodeProps = {
  eventKey: [String, Number],
  prefixCls: String,
  // By parent
  // expanded: { type: Boolean, default: undefined },
  // selected: { type: Boolean, default: undefined },
  // checked: { type: Boolean, default: undefined },
  // loaded: { type: Boolean, default: undefined },
  // loading: { type: Boolean, default: undefined },
  // halfChecked: { type: Boolean, default: undefined },
  // dragOver: { type: Boolean, default: undefined },
  // dragOverGapTop: { type: Boolean, default: undefined },
  // dragOverGapBottom: { type: Boolean, default: undefined },
  // pos: String,
  title: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  /** New added in Tree for easy data access */
  data: {
    type: Object,
    default: undefined
  },
  parent: {
    type: Object,
    default: undefined
  },
  isStart: {
    type: Array
  },
  isEnd: {
    type: Array
  },
  active: {
    type: Boolean,
    default: undefined
  },
  onMousemove: {
    type: Function
  },
  // By user
  isLeaf: {
    type: Boolean,
    default: undefined
  },
  checkable: {
    type: Boolean,
    default: undefined
  },
  selectable: {
    type: Boolean,
    default: undefined
  },
  disabled: {
    type: Boolean,
    default: undefined
  },
  disableCheckbox: {
    type: Boolean,
    default: undefined
  },
  icon: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  switcherIcon: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  domRef: {
    type: Function
  }
};
const nodeListProps = {
  prefixCls: {
    type: String
  },
  // data: { type: Array as PropType<FlattenNode[]> },
  motion: {
    type: Object
  },
  focusable: {
    type: Boolean
  },
  activeItem: {
    type: Object
  },
  focused: {
    type: Boolean
  },
  tabindex: {
    type: Number
  },
  checkable: {
    type: Boolean
  },
  selectable: {
    type: Boolean
  },
  disabled: {
    type: Boolean
  },
  // expandedKeys: { type: Array as PropType<Key[]> },
  // selectedKeys: { type: Array as PropType<Key[]> },
  // checkedKeys: { type: Array as PropType<Key[]> },
  // loadedKeys: { type: Array as PropType<Key[]> },
  // loadingKeys: { type: Array as PropType<Key[]> },
  // halfCheckedKeys: { type: Array as PropType<Key[]> },
  // keyEntities: { type: Object as PropType<Record<Key, DataEntity<DataNode>>> },
  // dragging: { type: Boolean as PropType<boolean> },
  // dragOverNodeKey: { type: [String, Number] as PropType<Key> },
  // dropPosition: { type: Number as PropType<number> },
  // Virtual list
  height: {
    type: Number
  },
  itemHeight: {
    type: Number
  },
  virtual: {
    type: Boolean
  },
  onScroll: {
    type: Function
  },
  onKeydown: {
    type: Function
  },
  onFocus: {
    type: Function
  },
  onBlur: {
    type: Function
  },
  onActiveChange: {
    type: Function
  },
  onContextmenu: {
    type: Function
  },
  onListChangeStart: {
    type: Function
  },
  onListChangeEnd: {
    type: Function
  }
};
const treeProps = () => ({
  prefixCls: String,
  focusable: {
    type: Boolean,
    default: undefined
  },
  activeKey: [Number, String],
  tabindex: Number,
  children: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  treeData: {
    type: Array
  },
  fieldNames: {
    type: Object
  },
  showLine: {
    type: [Boolean, Object],
    default: undefined
  },
  showIcon: {
    type: Boolean,
    default: undefined
  },
  icon: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  selectable: {
    type: Boolean,
    default: undefined
  },
  expandAction: [String, Boolean],
  disabled: {
    type: Boolean,
    default: undefined
  },
  multiple: {
    type: Boolean,
    default: undefined
  },
  checkable: {
    type: Boolean,
    default: undefined
  },
  checkStrictly: {
    type: Boolean,
    default: undefined
  },
  draggable: {
    type: [Function, Boolean]
  },
  defaultExpandParent: {
    type: Boolean,
    default: undefined
  },
  autoExpandParent: {
    type: Boolean,
    default: undefined
  },
  defaultExpandAll: {
    type: Boolean,
    default: undefined
  },
  defaultExpandedKeys: {
    type: Array
  },
  expandedKeys: {
    type: Array
  },
  defaultCheckedKeys: {
    type: Array
  },
  checkedKeys: {
    type: [Object, Array]
  },
  defaultSelectedKeys: {
    type: Array
  },
  selectedKeys: {
    type: Array
  },
  allowDrop: {
    type: Function
  },
  dropIndicatorRender: {
    type: Function
  },
  onFocus: {
    type: Function
  },
  onBlur: {
    type: Function
  },
  onKeydown: {
    type: Function
  },
  onContextmenu: {
    type: Function
  },
  onClick: {
    type: Function
  },
  onDblclick: {
    type: Function
  },
  onScroll: {
    type: Function
  },
  onExpand: {
    type: Function
  },
  onCheck: {
    type: Function
  },
  onSelect: {
    type: Function
  },
  onLoad: {
    type: Function
  },
  loadData: {
    type: Function
  },
  loadedKeys: {
    type: Array
  },
  onMouseenter: {
    type: Function
  },
  onMouseleave: {
    type: Function
  },
  onRightClick: {
    type: Function
  },
  onDragstart: {
    type: Function
  },
  onDragenter: {
    type: Function
  },
  onDragover: {
    type: Function
  },
  onDragleave: {
    type: Function
  },
  onDragend: {
    type: Function
  },
  onDrop: {
    type: Function
  },
  /**
   * Used for `rc-tree-select` only.
   * Do not use in your production code directly since this will be refactor.
   */
  onActiveChange: {
    type: Function
  },
  filterTreeNode: {
    type: Function
  },
  motion: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  switcherIcon: _util_vue_types__WEBPACK_IMPORTED_MODULE_0__/* ["default"].any */ .Z.any,
  // Virtual List
  height: Number,
  itemHeight: Number,
  virtual: {
    type: Boolean,
    default: undefined
  },
  // direction for drag logic
  direction: {
    type: String
  },
  rootClassName: String,
  rootStyle: Object
});

/***/ })

}]);