aibox-custom-component-packages 0.0.12 → 0.0.13

package/es/chunks/DocSyncSelect.DlJXL1lq.js

@@ -0,0 +1,2290 @@
+import { r as e, t } from "./chunk.EU29TkMc.js";
+import { t as n } from "./withinstall.dLh4K-0g.js";
+import { m as r } from "./i18n.CIhVBbR3.js";
+import { t as i } from "./_plugin-vue_export-helper.Ct3qlEzt.js";
+import { Fragment as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, guardReactiveProps as f, h as p, markRaw as m, mergeProps as h, nextTick as g, normalizeClass as _, normalizeProps as v, normalizeStyle as y, onMounted as b, onUnmounted as x, openBlock as S, popScopeId as C, pushScopeId as w, ref as T, renderList as E, renderSlot as D, resolveComponent as O, resolveDirective as k, resolveDynamicComponent as A, shallowReactive as j, toDisplayString as M, toHandlers as N, unref as P, useAttrs as ee, watch as F, withCtx as I, withDirectives as L, withModifiers as R, withScopeId as z } from "vue";
+import { ElAutoResizer as te, ElCheckbox as ne, ElIcon as B, ElInput as re, ElSegmented as V, ElTreeV2 as ie } from "element-plus";
+import { CaretRight as ae, Empty as oe, FeishuLocalUploadDoc as H, FeishuLocalUploadImg as se, FeishuLocalUploadPdf as ce, FeishuLocalUploadPpt as U, FeishuLocalUploadTxt as W, FeishuLocalUploadXlsx as G, IconDelete as K, IconFeishuDoc as le, IconFeishuExcel as ue, IconFeishuKnowledge as de, IconFeishuMulitTable as fe, Seach as pe } from "color-message-aibox-vue";
+import { IconEmpty as q } from "color-star-custom-components";
+import me from "mitt";
+import '../assets/DocSyncSelect.css';//#region components/DocSyncSelect/config.js
+var J = {
+	label: "name",
+	children: "children",
+	value: "id"
+}, Y = {
+	FRONTEND: "frontend",
+	BACKEND: "backend"
+}, he = [
+	"sheet",
+	"bitable",
+	"doc",
+	"docx",
+	"wiki",
+	"pdf",
+	"pptx",
+	"ppt",
+	"xlsx",
+	"xls",
+	"txt",
+	"png",
+	"jpg",
+	"jpeg"
+], X = {
+	MY_FILES: "myFiles",
+	FEISHU_KNOWLEDGE: "feishuKnowledge"
+}, Z = /* @__PURE__ */ Object.assign({ name: "FileTypeIcon" }, {
+	__name: "FileTypeIcon",
+	props: {
+		fileType: {
+			type: String,
+			required: !1,
+			default: ""
+		},
+		isLocalFileType: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		size: {
+			type: Number,
+			default: 32
+		}
+	},
+	setup(e) {
+		return (t, n) => e.fileType && P(he).includes(e.fileType) ? (S(), s(P(B), {
+			key: 0,
+			size: e.size
+		}, {
+			default: I(() => [e.isLocalFileType ? (S(), l(a, { key: 0 }, [["xlsx", "xls"].includes(e.fileType) ? (S(), s(P(G), { key: 0 })) : ["doc", "docx"].includes(e.fileType) ? (S(), s(P(H), { key: 1 })) : ["pdf"].includes(e.fileType) ? (S(), s(P(ce), { key: 2 })) : ["pptx", "ppt"].includes(e.fileType) ? (S(), s(P(U), { key: 3 })) : ["txt"].includes(e.fileType) ? (S(), s(P(W), { key: 4 })) : [
+				"png",
+				"jpg",
+				"jpeg"
+			].includes(e.fileType) ? (S(), s(P(se), { key: 5 })) : c("", !0)], 64)) : (S(), l(a, { key: 1 }, [["sheet"].includes(e.fileType) ? (S(), s(P(ue), { key: 0 })) : ["bitable"].includes(e.fileType) ? (S(), s(P(fe), { key: 1 })) : ["doc", "docx"].includes(e.fileType) ? (S(), s(P(le), { key: 2 })) : ["wiki"].includes(e.fileType) ? (S(), s(P(de), { key: 3 })) : c("", !0)], 64))]),
+			_: 1
+		}, 8, ["size"])) : c("", !0);
+	}
+}), ge = { class: "right-wrap" }, _e = { class: "content" }, ve = {
+	key: 0,
+	class: "empty-state"
+}, ye = {
+	key: 1,
+	class: "selected-list"
+}, be = ["onClick"], xe = { class: "item-content" }, Se = { class: "item-main" }, Ce = { class: "doc-icon" }, we = { class: "doc-info" }, Te = { class: "doc-name" }, Ee = {
+	key: 0,
+	class: "doc-suffix"
+}, De = ["onClick"], Oe = /* @__PURE__ */ i(/* @__PURE__ */ Object.assign({ name: "RightLayout" }, {
+	__name: "RightLayout",
+	props: {
+		selectedDocuments: {
+			type: Array,
+			default: () => []
+		},
+		treeProps: {
+			type: Object,
+			default: () => J
+		}
+	},
+	emits: ["delete-node"],
+	setup(e, { emit: t }) {
+		let n = e, r = t, i = T(-1), s = o(() => n.selectedDocuments.filter((e) => he.includes(e.type))), f = (e) => {
+			i.value = i.value === e ? -1 : e;
+		}, p = (e) => {
+			r("delete-node", e), i.value = -1;
+		};
+		return (t, n) => (S(), l("div", ge, [u("div", _e, [s.value.length === 0 ? (S(), l("div", ve, [d(P(q))])) : (S(), l("div", ye, [(S(!0), l(a, null, E(s.value, (t, n) => (S(), l("div", {
+			key: t[e.treeProps.value],
+			class: _(["selected-item", { "is-selected": i.value === n }]),
+			onClick: (e) => f(n)
+		}, [u("div", xe, [u("div", Se, [u("div", Ce, [d(Z, {
+			"file-type": t.type,
+			size: 26,
+			isLocalFileType: t?.isLocalFileType
+		}, null, 8, ["file-type", "isLocalFileType"])]), u("div", we, [u("div", Te, M(t[e.treeProps.label]), 1), t.suffix ? (S(), l("div", Ee, M(t.suffix), 1)) : c("", !0)])]), u("div", {
+			class: "flex items-center",
+			onClick: R((e) => p(t), ["stop"])
+		}, [d(P(B), {
+			size: 14,
+			color: "var(--neutral-color-5)"
+		}, {
+			default: I(() => [d(P(K))]),
+			_: 1
+		})], 8, De)])], 10, be))), 128))]))])]));
+	}
+}), [["__scopeId", "data-v-6736cdb6"]]);
+//#endregion
+//#region ../../../node_modules/.pnpm/element-tree-line@0.2.1_vue@3.5.27_typescript@5.9.3_/node_modules/element-tree-line/dist/index.es.js
+function ke(e) {
+	return {
+		name: "element-tree-line",
+		props: {
+			node: {
+				type: Object,
+				required: !0
+			},
+			data: { type: Object },
+			treeData: { type: Array },
+			indent: {
+				type: Number,
+				default() {
+					return 16;
+				}
+			},
+			showLabelLine: {
+				type: Boolean,
+				default: !0
+			}
+		},
+		render(t) {
+			let n = e || t, r = this.getScopedSlot("default"), i = this.getScopedSlot("node-label"), a = this.getScopedSlot("after-node-label"), o = r ? this.getScopedSlotValue(r, {
+				node: this.node,
+				data: this.data
+			}) : [
+				i ? this.getScopedSlotValue(i, {
+					node: this.node,
+					data: this.data
+				}) : n("span", { class: "element-tree-node-label" }, this.node.label),
+				this.showLabelLine ? n("span", { class: "element-tree-node-label-line" }) : null,
+				this.getScopedSlotValue(a, {
+					node: this.node,
+					data: this.data
+				})
+			], s = [], c = this.node;
+			for (; c;) {
+				let e = c.parent;
+				if (c.level === 1 && !c.parent) {
+					if (!this.treeData || !Array.isArray(this.treeData)) throw Error("if you using el-tree-v2 (Virtualized Tree) of element-plus,element-tree-line required data.");
+					e = {
+						children: Array.isArray(this.treeData) ? this.treeData.map((e) => ({
+							...e,
+							key: e.id
+						})) : [],
+						level: 0,
+						key: "node-0",
+						parent: null
+					};
+				}
+				if (e) {
+					let t = (e.children || e.childNodes).findIndex((e) => (e.key || e.id) === (c.key || c.id));
+					s.unshift(t === (e.children || e.childNodes).length - 1);
+				}
+				c = e;
+			}
+			let l = [];
+			for (let e = 0; e < this.node.level; e++) s[e] && this.node.level - 1 !== e || l.push(n("span", {
+				class: {
+					"element-tree-node-line-ver": !0,
+					"last-node-isLeaf-line": s[e] && this.node.level - 1 === e
+				},
+				style: { left: this.indent * e + "px" }
+			}));
+			return n("span", { class: "element-tree-node-label-wrapper" }, [o].concat(l, [n("span", {
+				class: "element-tree-node-line-hor",
+				style: {
+					width: (this.node.isLeaf ? 24 : 8) + "px",
+					left: (this.node.level - 1) * this.indent + "px"
+				}
+			})]));
+		},
+		methods: {
+			getScopedSlot(e) {
+				if (!e) return null;
+				let t = e.split("||"), n = null;
+				for (let e = 0; e < t.length; e++) {
+					let r = t[e], i = (this.$slots || {})[r];
+					if (i) {
+						n = i;
+						break;
+					}
+					if (n = (this.$scopedSlots || {})[r], n) break;
+				}
+				return n;
+			},
+			getScopedSlotValue(e, t, n = null) {
+				return typeof e == "function" ? e(t) || n : e || n;
+			}
+		}
+	};
+}
+function Ae(e) {
+	let t = ke(e);
+	return e && (t.methods.getScopedSlot = function(e) {
+		if (!e) return null;
+		let t = e.split("||"), n = null;
+		for (let e = 0; e < t.length; e++) {
+			let r = t[e], i = (this.$slots || {})[r];
+			if (i) {
+				n = i;
+				break;
+			}
+		}
+		return n;
+	}), t;
+}
+Ae();
+//#endregion
+//#region components/DocSyncSelect/utils.js
+var je = /* @__PURE__ */ e((/* @__PURE__ */ t(((e, t) => {
+	var n = "Expected a function", r = NaN, i = "[object Symbol]", a = /^\s+|\s+$/g, o = /^[-+]0x[0-9a-f]+$/i, s = /^0b[01]+$/i, c = /^0o[0-7]+$/i, l = parseInt, u = typeof global == "object" && global && global.Object === Object && global, d = typeof self == "object" && self && self.Object === Object && self, f = u || d || Function("return this")(), p = Object.prototype.toString, m = Math.max, h = Math.min, g = function() {
+		return f.Date.now();
+	};
+	function _(e, t, r) {
+		var i, a, o, s, c, l, u = 0, d = !1, f = !1, p = !0;
+		if (typeof e != "function") throw TypeError(n);
+		t = x(t) || 0, v(r) && (d = !!r.leading, f = "maxWait" in r, o = f ? m(x(r.maxWait) || 0, t) : o, p = "trailing" in r ? !!r.trailing : p);
+		function _(t) {
+			var n = i, r = a;
+			return i = a = void 0, u = t, s = e.apply(r, n), s;
+		}
+		function y(e) {
+			return u = e, c = setTimeout(C, t), d ? _(e) : s;
+		}
+		function b(e) {
+			var n = e - l, r = e - u, i = t - n;
+			return f ? h(i, o - r) : i;
+		}
+		function S(e) {
+			var n = e - l, r = e - u;
+			return l === void 0 || n >= t || n < 0 || f && r >= o;
+		}
+		function C() {
+			var e = g();
+			if (S(e)) return w(e);
+			c = setTimeout(C, b(e));
+		}
+		function w(e) {
+			return c = void 0, p && i ? _(e) : (i = a = void 0, s);
+		}
+		function T() {
+			c !== void 0 && clearTimeout(c), u = 0, i = l = a = c = void 0;
+		}
+		function E() {
+			return c === void 0 ? s : w(g());
+		}
+		function D() {
+			var e = g(), n = S(e);
+			if (i = arguments, a = this, l = e, n) {
+				if (c === void 0) return y(l);
+				if (f) return c = setTimeout(C, t), _(l);
+			}
+			return c === void 0 && (c = setTimeout(C, t)), s;
+		}
+		return D.cancel = T, D.flush = E, D;
+	}
+	function v(e) {
+		var t = typeof e;
+		return !!e && (t == "object" || t == "function");
+	}
+	function y(e) {
+		return !!e && typeof e == "object";
+	}
+	function b(e) {
+		return typeof e == "symbol" || y(e) && p.call(e) == i;
+	}
+	function x(e) {
+		if (typeof e == "number") return e;
+		if (b(e)) return r;
+		if (v(e)) {
+			var t = typeof e.valueOf == "function" ? e.valueOf() : e;
+			e = v(t) ? t + "" : t;
+		}
+		if (typeof e != "string") return e === 0 ? e : +e;
+		e = e.replace(a, "");
+		var n = s.test(e);
+		return n || c.test(e) ? l(e.slice(2), n ? 2 : 8) : o.test(e) ? r : +e;
+	}
+	t.exports = _;
+})))()), Me = (e) => e && Array.isArray(e) && e.length === 1 && e[0] && typeof e[0] == "object" && e[0].falseChild === !0, Ne = (e) => !e || !e.children ? !0 : !Me(e.children), Pe = (e, t = 800) => (0, je.default)((t) => {
+	e("search", { keyword: t });
+}, t), Fe = (e, t, n) => !e || !Array.isArray(e) ? [] : e.reduce((e, r) => {
+	let i = r[n.label]?.toLowerCase().includes(t.toLowerCase()), a = r.suffix?.toLowerCase().includes(t.toLowerCase());
+	if (i || a) e.push({ ...r });
+	else if (r[n.children]) {
+		let i = Fe(r[n.children], t, n);
+		i.length > 0 && e.push({
+			...r,
+			[n.children]: i
+		});
+	}
+	return e;
+}, []), Ie = (e, t) => {
+	let n = [];
+	if (!e) return n;
+	let r = e[t.children];
+	if (r && Array.isArray(r)) for (let e of r) n.push(e), n = n.concat(Ie(e, t));
+	return n;
+}, Le = (e, t, n = !1) => {
+	let r = 0;
+	function i(e) {
+		for (let a of e) {
+			let e = a[t.children] && a[t.children].length > 0;
+			n ? r++ : e || r++, e && i(a[t.children]);
+		}
+	}
+	return i(e), r;
+}, Re = (e, t, n) => {
+	let r = /* @__PURE__ */ new Map();
+	function i(e, a = []) {
+		for (let o of e) {
+			let e = [...a, o];
+			o.children && o.children.length > 0 ? i(o.children, e) : t.includes(o[n]) && a.forEach((e) => {
+				r.has(e[n]) || r.set(e[n], { ...e });
+			});
+		}
+	}
+	return i(e), Array.from(r.values());
+}, ze = (e, t) => {
+	let n = t?.value || "id", r = t?.children || "children", i = /* @__PURE__ */ new Set(), a = (e) => {
+		if (Array.isArray(e)) for (let t of e) {
+			t && t[n] != null && i.add(t[n]);
+			let e = t?.[r];
+			e && Array.isArray(e) && e.length > 0 && a(e);
+		}
+	};
+	return a(e), i;
+}, Be = ({ tabKey: e, currentSelectedDocs: t, hasSelectToRightDocList: n, treeData: r, treeProps: i }) => {
+	let a = Array.isArray(n) ? n : [], o = i?.value, s = ze((r && Array.isArray(r[e]) ? r[e] : []) || [], i), c = a.filter((e) => !s.has(e?.[o]));
+	return [...t, ...c];
+}, Ve = (e, t, n) => {
+	if (!Array.isArray(e) || t == null) return null;
+	let r = n?.value || "id", i = n?.children || "children", a = (e) => {
+		for (let n of e) {
+			if (n && n[r] === t) return n;
+			let e = n?.[i];
+			if (Array.isArray(e) && e.length > 0) {
+				let t = a(e);
+				if (t) return t;
+			}
+		}
+		return null;
+	};
+	return a(e);
+}, He = (e, t) => {
+	if (!e) return !1;
+	let n = t?.children || "children";
+	if (Me(e[n])) return !0;
+	let r = e[n];
+	if (r && Array.isArray(r)) {
+		for (let e of r) if (He(e, t)) return !0;
+	}
+	return !1;
+}, Ue = (e, t) => e === X.MY_FILES ? t?.myFilesHasMore || !1 : e === X.FEISHU_KNOWLEDGE && t?.feishuKnowledgeHasMore || !1, We = { class: "w-full h-full flex flex-col overflow-hidden" }, Ge = /* @__PURE__ */ i(/* @__PURE__ */ Object.assign({ name: "TreeSelectLayout" }, {
+	__name: "TreeSelectLayout",
+	props: {
+		modelValue: {
+			type: Object,
+			default: () => []
+		},
+		treeProps: {
+			type: Object,
+			default: () => J
+		},
+		apiConfig: { type: Function },
+		loadNode: { type: Function },
+		reqParams: {
+			type: Object,
+			default: () => ({})
+		},
+		autoLoad: {
+			type: Boolean,
+			default: !0
+		},
+		isMultiple: {
+			type: Boolean,
+			default: !0
+		},
+		hasFilter: {
+			type: Boolean,
+			default: !1
+		},
+		treeList: {
+			type: Array,
+			default: () => []
+		},
+		hasTreeLine: {
+			type: Boolean,
+			default: !0
+		},
+		includeParentSelected: {
+			type: Boolean,
+			default: !1
+		},
+		textConfig: {
+			type: Object,
+			default: () => ({ searchPlaceholder: "" })
+		},
+		getTabSelectedDocuments: {
+			type: Function,
+			default: () => () => []
+		}
+	},
+	emits: [
+		"handleCheck",
+		"initFinish",
+		"node-expand"
+	],
+	setup(e, { expose: t, emit: n }) {
+		let r = Ae(p), i = e, a = n, f = ee(), m = () => p(ae, { style: {
+			color: "var(--text-color-2)",
+			fontSize: "16px"
+		} }), v = i.isMultiple ? 20 : 10, y = i.isMultiple ? 15 : 11, x = T([]), C = T(null), w = T(null), E = o(() => i.treeProps.value), O = o(() => i.treeProps.label), k = o(() => i.treeProps.children), A = T(!1), j = o(() => !i.isMultiple && A.value), N = o(() => typeof i.apiConfig == "function"), L = () => {
+			let e = C.value?.getCheckedNodes(), t = e.map((e) => e[E.value]), n = [];
+			return i.includeParentSelected && (n = Re(x.value, t, E.value)), {
+				selectedNodeValues: t,
+				selectedNodes: e,
+				selectedParentNodes: n
+			};
+		}, R = (e, t) => {
+			V(e, t);
+		}, z = (e) => {
+			a("node-expand", e);
+		}, ne = (e, t) => {
+			i.isMultiple || (A.value = !0, w.value = t.key, a("handleCheck", {
+				selectedValue: [w.value],
+				selectedNode: [t.data]
+			}));
+		};
+		T("");
+		let B = (e, t) => t[O.value].includes(e), re = o(() => Le(x.value, i.treeProps, i.includeParentSelected));
+		function V(e = null, t = null) {
+			let { selectedNodeValues: n, selectedNodes: r, selectedParentNodes: i } = L(), o = null;
+			if (e && t) {
+				let n = e[E.value];
+				o = t.checkedKeys.includes(n);
+			}
+			a("handleCheck", {
+				selectedValue: n,
+				selectedNode: r,
+				selectedParentNodes: i,
+				checkedNode: e,
+				isChecked: o
+			});
+		}
+		let oe = (e, t) => {
+			C.value?.setChecked(e, t), V();
+		}, H = () => {
+			f["default-checked-keys"] && g(() => {
+				V();
+			});
+		}, se = (e) => {
+			C.value && (!e || e.length === 0 ? C.value?.setCheckedKeys([]) : C.value?.setCheckedKeys(e));
+		}, ce = (e, t) => {
+			let n = (r) => {
+				for (let i = 0; i < r.length; i++) {
+					let a = r[i];
+					if (a[E.value] === e) {
+						let n = U(t);
+						return a[k.value] = n, a.isLeaf = !t || t.length === 0, console.log("节点更新后:", {
+							nodeKey: e,
+							childrenLength: n.length,
+							isLeaf: a.isLeaf
+						}), x.value = [...x.value], !0;
+					}
+					if (a[k.value] && a[k.value].length > 0 && n(a[k.value])) return !0;
+				}
+				return !1;
+			};
+			n(x.value);
+		}, U = (e) => e?.map((e) => ({
+			...e,
+			[k.value]: e[k.value]?.length ? U(e[k.value]) : void 0
+		})), W = async () => {
+			N.value ? i.apiConfig(i.reqParams)?.then((e) => {
+				x.value = U(e?.data?.orgOptionSoList || e?.data || []), H(), K(i.modelValue), a("initFinish", x.value);
+			}) : G();
+		}, G = () => {
+			x.value = U(i.treeList || []), x.value.length && (H(), K(i.modelValue));
+		}, K = (e) => {
+			let t = e && e.length && e.map((e) => e[i.treeProps.value]);
+			g(() => {
+				C.value?.setCheckedKeys(t);
+			});
+		};
+		return F(() => i.treeList, () => {
+			G();
+		}, { deep: !0 }), F(() => i.modelValue, (e) => {
+			g(() => {
+				K(e);
+			});
+		}, { deep: !0 }), b(() => {
+			W();
+		}), t({
+			allNodeNumbers: re,
+			loadData: W,
+			setNodeCheckStatus: oe,
+			updateNodeChildren: ce,
+			syncSelectedNodes: se
+		}), (t, n) => (S(), l("div", We, [u("div", { class: _([e.hasFilter ? "pd-l-8 pd-r-8" : "", "flex-1 overflow-hidden"]) }, [d(P(te), null, {
+			default: I(({ width: n, height: i }) => [d(P(ie), h({
+				ref_key: "treeRef",
+				ref: C,
+				height: i,
+				width: n,
+				"check-strictly": !0,
+				data: x.value,
+				props: e.treeProps,
+				"node-key": E.value,
+				"show-checkbox": !0,
+				"item-size": P(34),
+				indent: P(v),
+				"highlight-current": j.value,
+				icon: m,
+				"filter-method": B,
+				lazy: "",
+				load: e.loadNode
+			}, P(f), {
+				onNodeClick: ne,
+				onCheck: R,
+				onNodeExpand: z,
+				class: ["hide-false-child-checkbox"]
+			}), {
+				default: I(({ node: n }) => [u("div", { class: _(["tree-node-content", { "false-child-node": n.data?.falseChild }]) }, [D(t.$slots, "node", {
+					node: n,
+					data: n.data
+				}, () => [e.hasTreeLine ? (S(), s(P(r), {
+					key: 0,
+					node: n,
+					treeData: x.value,
+					showLabelLine: !1,
+					indent: P(y)
+				}, null, 8, [
+					"node",
+					"treeData",
+					"indent"
+				])) : c("", !0), u("span", null, M(n.data[O.value]), 1)], !0)], 2)]),
+				empty: I(() => [d(P(q))]),
+				_: 3
+			}, 16, [
+				"height",
+				"width",
+				"data",
+				"props",
+				"node-key",
+				"item-size",
+				"indent",
+				"highlight-current",
+				"load"
+			])]),
+			_: 3
+		})], 2)]));
+	}
+}), [["__scopeId", "data-v-258f00ca"]]);
+//#endregion
+//#region ../../../node_modules/.pnpm/vue-resize@2.0.0-alpha.1_vue@3.5.27_typescript@5.9.3_/node_modules/vue-resize/dist/vue-resize.esm.js
+function Ke() {
+	var e = window.navigator.userAgent, t = e.indexOf("MSIE ");
+	if (t > 0) return parseInt(e.substring(t + 5, e.indexOf(".", t)), 10);
+	if (e.indexOf("Trident/") > 0) {
+		var n = e.indexOf("rv:");
+		return parseInt(e.substring(n + 3, e.indexOf(".", n)), 10);
+	}
+	var r = e.indexOf("Edge/");
+	return r > 0 ? parseInt(e.substring(r + 5, e.indexOf(".", r)), 10) : -1;
+}
+var Q;
+function qe() {
+	qe.init || (qe.init = !0, Q = Ke() !== -1);
+}
+var $ = {
+	name: "ResizeObserver",
+	props: {
+		emitOnMount: {
+			type: Boolean,
+			default: !1
+		},
+		ignoreWidth: {
+			type: Boolean,
+			default: !1
+		},
+		ignoreHeight: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["notify"],
+	mounted() {
+		qe(), g(() => {
+			this._w = this.$el.offsetWidth, this._h = this.$el.offsetHeight, this.emitOnMount && this.emitSize();
+		});
+		let e = document.createElement("object");
+		this._resizeObject = e, e.setAttribute("aria-hidden", "true"), e.setAttribute("tabindex", -1), e.onload = this.addResizeHandlers, e.type = "text/html", Q && this.$el.appendChild(e), e.data = "about:blank", Q || this.$el.appendChild(e);
+	},
+	beforeUnmount() {
+		this.removeResizeHandlers();
+	},
+	methods: {
+		compareAndNotify() {
+			(!this.ignoreWidth && this._w !== this.$el.offsetWidth || !this.ignoreHeight && this._h !== this.$el.offsetHeight) && (this._w = this.$el.offsetWidth, this._h = this.$el.offsetHeight, this.emitSize());
+		},
+		emitSize() {
+			this.$emit("notify", {
+				width: this._w,
+				height: this._h
+			});
+		},
+		addResizeHandlers() {
+			this._resizeObject.contentDocument.defaultView.addEventListener("resize", this.compareAndNotify), this.compareAndNotify();
+		},
+		removeResizeHandlers() {
+			this._resizeObject && this._resizeObject.onload && (!Q && this._resizeObject.contentDocument && this._resizeObject.contentDocument.defaultView.removeEventListener("resize", this.compareAndNotify), this.$el.removeChild(this._resizeObject), this._resizeObject.onload = null, this._resizeObject = null);
+		}
+	}
+}, Je = /* @__PURE__ */ z("data-v-b329ee4c");
+w("data-v-b329ee4c");
+var Ye = {
+	class: "resize-observer",
+	tabindex: "-1"
+};
+C(), $.render = /* @__PURE__ */ Je((e, t, n, r, i, a) => (S(), s("div", Ye))), $.__scopeId = "data-v-b329ee4c", $.__file = "src/components/ResizeObserver.vue";
+//#endregion
+//#region ../../../node_modules/.pnpm/vue-observe-visibility@2.0.0-alpha.1_vue@3.5.27_typescript@5.9.3_/node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js
+function Xe(e) {
+	"@babel/helpers - typeof";
+	return Xe = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+		return typeof e;
+	} : function(e) {
+		return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+	}, Xe(e);
+}
+function Ze(e, t) {
+	if (!(e instanceof t)) throw TypeError("Cannot call a class as a function");
+}
+function Qe(e, t) {
+	for (var n = 0; n < t.length; n++) {
+		var r = t[n];
+		r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+	}
+}
+function $e(e, t, n) {
+	return t && Qe(e.prototype, t), n && Qe(e, n), e;
+}
+function et(e) {
+	return tt(e) || nt(e) || rt(e) || at();
+}
+function tt(e) {
+	if (Array.isArray(e)) return it(e);
+}
+function nt(e) {
+	if (typeof Symbol < "u" && Symbol.iterator in Object(e)) return Array.from(e);
+}
+function rt(e, t) {
+	if (e) {
+		if (typeof e == "string") return it(e, t);
+		var n = Object.prototype.toString.call(e).slice(8, -1);
+		if (n === "Object" && e.constructor && (n = e.constructor.name), n === "Map" || n === "Set") return Array.from(e);
+		if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return it(e, t);
+	}
+}
+function it(e, t) {
+	(t == null || t > e.length) && (t = e.length);
+	for (var n = 0, r = Array(t); n < t; n++) r[n] = e[n];
+	return r;
+}
+function at() {
+	throw TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ot(e) {
+	return typeof e == "function" ? { callback: e } : e;
+}
+function st(e, t) {
+	var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, r, i, a, o = function(o) {
+		if (a = [...arguments].slice(1), !(r && o === i)) {
+			var s = n.leading;
+			typeof s == "function" && (s = s(o, i)), (!r || o !== i) && s && e.apply(void 0, [o].concat(et(a))), i = o, clearTimeout(r), r = setTimeout(function() {
+				e.apply(void 0, [o].concat(et(a))), r = 0;
+			}, t);
+		}
+	};
+	return o._clear = function() {
+		clearTimeout(r), r = null;
+	}, o;
+}
+function ct(e, t) {
+	if (e === t) return !0;
+	if (Xe(e) === "object") {
+		for (var n in e) if (!ct(e[n], t[n])) return !1;
+		return !0;
+	}
+	return !1;
+}
+var lt = /* @__PURE__ */ function() {
+	function e(t, n, r) {
+		Ze(this, e), this.el = t, this.observer = null, this.frozen = !1, this.createObserver(n, r);
+	}
+	return $e(e, [
+		{
+			key: "createObserver",
+			value: function(e, t) {
+				var n = this;
+				if (this.observer && this.destroyObserver(), !this.frozen) {
+					if (this.options = ot(e), this.callback = function(e, t) {
+						n.options.callback(e, t), e && n.options.once && (n.frozen = !0, n.destroyObserver());
+					}, this.callback && this.options.throttle) {
+						var r = (this.options.throttleOptions || {}).leading;
+						this.callback = st(this.callback, this.options.throttle, { leading: function(e) {
+							return r === "both" || r === "visible" && e || r === "hidden" && !e;
+						} });
+					}
+					this.oldResult = void 0, this.observer = new IntersectionObserver(function(e) {
+						var t = e[0];
+						if (e.length > 1) {
+							var r = e.find(function(e) {
+								return e.isIntersecting;
+							});
+							r && (t = r);
+						}
+						if (n.callback) {
+							var i = t.isIntersecting && t.intersectionRatio >= n.threshold;
+							if (i === n.oldResult) return;
+							n.oldResult = i, n.callback(i, t);
+						}
+					}, this.options.intersection), g(function() {
+						n.observer && n.observer.observe(n.el);
+					});
+				}
+			}
+		},
+		{
+			key: "destroyObserver",
+			value: function() {
+				this.observer &&= (this.observer.disconnect(), null), this.callback && this.callback._clear && (this.callback._clear(), this.callback = null);
+			}
+		},
+		{
+			key: "threshold",
+			get: function() {
+				return this.options.intersection && typeof this.options.intersection.threshold == "number" ? this.options.intersection.threshold : 0;
+			}
+		}
+	]), e;
+}();
+function ut(e, t, n) {
+	var r = t.value;
+	r && (typeof IntersectionObserver > "u" ? console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill") : e._vue_visibilityState = new lt(e, r, n));
+}
+function dt(e, t, n) {
+	var r = t.value, i = t.oldValue;
+	if (!ct(r, i)) {
+		var a = e._vue_visibilityState;
+		if (!r) {
+			ft(e);
+			return;
+		}
+		a ? a.createObserver(r, n) : ut(e, { value: r }, n);
+	}
+}
+function ft(e) {
+	var t = e._vue_visibilityState;
+	t && (t.destroyObserver(), delete e._vue_visibilityState);
+}
+var pt = {
+	beforeMount: ut,
+	updated: dt,
+	unmounted: ft
+}, mt = { itemsLimit: 1e3 }, ht = /(auto|scroll)/;
+function gt(e, t) {
+	return e.parentNode === null ? t : gt(e.parentNode, t.concat([e]));
+}
+var _t = function(e, t) {
+	return getComputedStyle(e, null).getPropertyValue(t);
+}, vt = function(e) {
+	return _t(e, "overflow") + _t(e, "overflow-y") + _t(e, "overflow-x");
+}, yt = function(e) {
+	return ht.test(vt(e));
+};
+function bt(e) {
+	if (e instanceof HTMLElement || e instanceof SVGElement) {
+		for (var t = gt(e.parentNode, []), n = 0; n < t.length; n += 1) if (yt(t[n])) return t[n];
+		return document.scrollingElement || document.documentElement;
+	}
+}
+function xt(e) {
+	"@babel/helpers - typeof";
+	return xt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+		return typeof e;
+	} : function(e) {
+		return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+	}, xt(e);
+}
+var St = {
+	items: {
+		type: Array,
+		required: !0
+	},
+	keyField: {
+		type: String,
+		default: "id"
+	},
+	direction: {
+		type: String,
+		default: "vertical",
+		validator: function(e) {
+			return ["vertical", "horizontal"].includes(e);
+		}
+	},
+	listTag: {
+		type: String,
+		default: "div"
+	},
+	itemTag: {
+		type: String,
+		default: "div"
+	}
+};
+function Ct() {
+	return this.items.length && xt(this.items[0]) !== "object";
+}
+var wt = !1;
+if (typeof window < "u") {
+	wt = !1;
+	try {
+		var Tt = Object.defineProperty({}, "passive", { get: function() {
+			wt = !0;
+		} });
+		window.addEventListener("test", null, Tt);
+	} catch {}
+}
+var Et = 0, Dt = {
+	name: "RecycleScroller",
+	components: { ResizeObserver: $ },
+	directives: { ObserveVisibility: pt },
+	props: {
+		...St,
+		itemSize: {
+			type: Number,
+			default: null
+		},
+		gridItems: {
+			type: Number,
+			default: void 0
+		},
+		itemSecondarySize: {
+			type: Number,
+			default: void 0
+		},
+		minItemSize: {
+			type: [Number, String],
+			default: null
+		},
+		sizeField: {
+			type: String,
+			default: "size"
+		},
+		typeField: {
+			type: String,
+			default: "type"
+		},
+		buffer: {
+			type: Number,
+			default: 200
+		},
+		pageMode: {
+			type: Boolean,
+			default: !1
+		},
+		prerender: {
+			type: Number,
+			default: 0
+		},
+		emitUpdate: {
+			type: Boolean,
+			default: !1
+		},
+		updateInterval: {
+			type: Number,
+			default: 0
+		},
+		skipHover: {
+			type: Boolean,
+			default: !1
+		},
+		listTag: {
+			type: String,
+			default: "div"
+		},
+		itemTag: {
+			type: String,
+			default: "div"
+		},
+		listClass: {
+			type: [
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		itemClass: {
+			type: [
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		}
+	},
+	emits: [
+		"resize",
+		"visible",
+		"hidden",
+		"update",
+		"scroll-start",
+		"scroll-end"
+	],
+	data() {
+		return {
+			pool: [],
+			totalSize: 0,
+			ready: !1,
+			hoverKey: null
+		};
+	},
+	computed: {
+		sizes() {
+			if (this.itemSize === null) {
+				let e = { "-1": { accumulator: 0 } }, t = this.items, n = this.sizeField, r = this.minItemSize, i = 1e4, a = 0, o;
+				for (let s = 0, c = t.length; s < c; s++) o = t[s][n] || r, o < i && (i = o), a += o, e[s] = {
+					accumulator: a,
+					size: o
+				};
+				return this.$_computedMinItemSize = i, e;
+			}
+			return [];
+		},
+		simpleArray: Ct,
+		itemIndexByKey() {
+			let { keyField: e, items: t } = this, n = {};
+			for (let r = 0, i = t.length; r < i; r++) n[t[r][e]] = r;
+			return n;
+		}
+	},
+	watch: {
+		items() {
+			this.updateVisibleItems(!0);
+		},
+		pageMode() {
+			this.applyPageMode(), this.updateVisibleItems(!1);
+		},
+		sizes: {
+			handler() {
+				this.updateVisibleItems(!1);
+			},
+			deep: !0
+		},
+		gridItems() {
+			this.updateVisibleItems(!0);
+		},
+		itemSecondarySize() {
+			this.updateVisibleItems(!0);
+		}
+	},
+	created() {
+		this.$_startIndex = 0, this.$_endIndex = 0, this.$_views = /* @__PURE__ */ new Map(), this.$_unusedViews = /* @__PURE__ */ new Map(), this.$_scrollDirty = !1, this.$_lastUpdateScrollPosition = 0, this.prerender && (this.$_prerender = !0, this.updateVisibleItems(!1)), this.gridItems && !this.itemSize && console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems");
+	},
+	mounted() {
+		this.applyPageMode(), this.$nextTick(() => {
+			this.$_prerender = !1, this.updateVisibleItems(!0), this.ready = !0;
+		});
+	},
+	activated() {
+		let e = this.$_lastUpdateScrollPosition;
+		typeof e == "number" && this.$nextTick(() => {
+			this.scrollToPosition(e);
+		});
+	},
+	beforeUnmount() {
+		this.removeListeners();
+	},
+	methods: {
+		addView(e, t, n, r, i) {
+			let a = j({
+				item: n,
+				position: 0,
+				nr: m({
+					id: Et++,
+					index: t,
+					used: !0,
+					key: r,
+					type: i
+				})
+			});
+			return e.push(a), a;
+		},
+		unuseView(e, t = !1) {
+			let n = this.$_unusedViews, r = e.nr.type, i = n.get(r);
+			i || (i = [], n.set(r, i)), i.push(e), t || (e.nr.used = !1, e.position = -9999);
+		},
+		handleResize() {
+			this.$emit("resize"), this.ready && this.updateVisibleItems(!1);
+		},
+		handleScroll(e) {
+			if (!this.$_scrollDirty) {
+				if (this.$_scrollDirty = !0, this.$_updateTimeout) return;
+				let e = () => requestAnimationFrame(() => {
+					this.$_scrollDirty = !1;
+					let { continuous: e } = this.updateVisibleItems(!1, !0);
+					e || (clearTimeout(this.$_refreshTimout), this.$_refreshTimout = setTimeout(this.handleScroll, this.updateInterval + 100));
+				});
+				e(), this.updateInterval && (this.$_updateTimeout = setTimeout(() => {
+					this.$_updateTimeout = 0, this.$_scrollDirty && e();
+				}, this.updateInterval));
+			}
+		},
+		handleVisibilityChange(e, t) {
+			this.ready && (e || t.boundingClientRect.width !== 0 || t.boundingClientRect.height !== 0 ? (this.$emit("visible"), requestAnimationFrame(() => {
+				this.updateVisibleItems(!1);
+			})) : this.$emit("hidden"));
+		},
+		updateVisibleItems(e, t = !1) {
+			let n = this.itemSize, r = this.gridItems || 1, i = this.itemSecondarySize || n, a = this.$_computedMinItemSize, o = this.typeField, s = this.simpleArray ? null : this.keyField, c = this.items, l = c.length, u = this.sizes, d = this.$_views, f = this.$_unusedViews, p = this.pool, m = this.itemIndexByKey, h, g, _, v, y;
+			if (!l) h = g = v = y = _ = 0;
+			else if (this.$_prerender) h = v = 0, g = y = Math.min(this.prerender, c.length), _ = null;
+			else {
+				let e = this.getScroll();
+				if (t) {
+					let t = e.start - this.$_lastUpdateScrollPosition;
+					if (t < 0 && (t = -t), n === null && t < a || t < n) return { continuous: !0 };
+				}
+				this.$_lastUpdateScrollPosition = e.start;
+				let i = this.buffer;
+				e.start -= i, e.end += i;
+				let o = 0;
+				if (this.$refs.before && (o = this.$refs.before.scrollHeight, e.start -= o), this.$refs.after) {
+					let t = this.$refs.after.scrollHeight;
+					e.end += t;
+				}
+				if (n === null) {
+					let t, n = 0, r = l - 1, i = ~~(l / 2), a;
+					do
+						a = i, t = u[i].accumulator, t < e.start ? n = i : i < l - 1 && u[i + 1].accumulator > e.start && (r = i), i = ~~((n + r) / 2);
+					while (i !== a);
+					for (i < 0 && (i = 0), h = i, _ = u[l - 1].accumulator, g = i; g < l && u[g].accumulator < e.end; g++);
+					for (g === -1 ? g = c.length - 1 : (g++, g > l && (g = l)), v = h; v < l && o + u[v].accumulator < e.start; v++);
+					for (y = v; y < l && o + u[y].accumulator < e.end; y++);
+				} else {
+					h = ~~(e.start / n * r);
+					let t = h % r;
+					h -= t, g = Math.ceil(e.end / n * r), v = Math.max(0, Math.floor((e.start - o) / n * r)), y = Math.floor((e.end - o) / n * r), h < 0 && (h = 0), g > l && (g = l), v < 0 && (v = 0), y > l && (y = l), _ = Math.ceil(l / r) * n;
+				}
+			}
+			g - h > mt.itemsLimit && this.itemsLimitError(), this.totalSize = _;
+			let b, x = h <= this.$_endIndex && g >= this.$_startIndex;
+			if (x) for (let t = 0, n = p.length; t < n; t++) b = p[t], b.nr.used && (e && (b.nr.index = m[b.item[s]]), (b.nr.index == null || b.nr.index < h || b.nr.index >= g) && this.unuseView(b));
+			let S = x ? null : /* @__PURE__ */ new Map(), C, w, T;
+			for (let e = h; e < g; e++) {
+				C = c[e];
+				let t = s ? C[s] : C;
+				if (t == null) throw Error(`Key is ${t} on item (keyField is '${s}')`);
+				if (b = d.get(t), !n && !u[e].size) {
+					b && this.unuseView(b);
+					continue;
+				}
+				w = C[o];
+				let a = f.get(w), l = !1;
+				if (!b) x ? b = a && a.length ? a.pop() : this.addView(p, e, C, t, w) : (T = S.get(w) || 0, (!a || T >= a.length) && (b = this.addView(p, e, C, t, w), this.unuseView(b, !0), a = f.get(w)), b = a[T], S.set(w, T + 1)), d.delete(b.nr.key), b.nr.used = !0, b.nr.index = e, b.nr.key = t, b.nr.type = w, d.set(t, b), l = !0;
+				else if (!b.nr.used && (b.nr.used = !0, l = !0, a)) {
+					let e = a.indexOf(b);
+					e !== -1 && a.splice(e, 1);
+				}
+				b.item = C, l && (e === c.length - 1 && this.$emit("scroll-end"), e === 0 && this.$emit("scroll-start")), n === null ? (b.position = u[e - 1].accumulator, b.offset = 0) : (b.position = Math.floor(e / r) * n, b.offset = e % r * i);
+			}
+			return this.$_startIndex = h, this.$_endIndex = g, this.emitUpdate && this.$emit("update", h, g, v, y), clearTimeout(this.$_sortTimer), this.$_sortTimer = setTimeout(this.sortViews, this.updateInterval + 300), { continuous: x };
+		},
+		getListenerTarget() {
+			let e = bt(this.$el);
+			return window.document && (e === window.document.documentElement || e === window.document.body) && (e = window), e;
+		},
+		getScroll() {
+			let { $el: e, direction: t } = this, n = t === "vertical", r;
+			if (this.pageMode) {
+				let t = e.getBoundingClientRect(), i = n ? t.height : t.width, a = -(n ? t.top : t.left), o = n ? window.innerHeight : window.innerWidth;
+				a < 0 && (o += a, a = 0), a + o > i && (o = i - a), r = {
+					start: a,
+					end: a + o
+				};
+			} else r = n ? {
+				start: e.scrollTop,
+				end: e.scrollTop + e.clientHeight
+			} : {
+				start: e.scrollLeft,
+				end: e.scrollLeft + e.clientWidth
+			};
+			return r;
+		},
+		applyPageMode() {
+			this.pageMode ? this.addListeners() : this.removeListeners();
+		},
+		addListeners() {
+			this.listenerTarget = this.getListenerTarget(), this.listenerTarget.addEventListener("scroll", this.handleScroll, wt ? { passive: !0 } : !1), this.listenerTarget.addEventListener("resize", this.handleResize);
+		},
+		removeListeners() {
+			this.listenerTarget &&= (this.listenerTarget.removeEventListener("scroll", this.handleScroll), this.listenerTarget.removeEventListener("resize", this.handleResize), null);
+		},
+		scrollToItem(e) {
+			let t, n = this.gridItems || 1;
+			t = this.itemSize === null ? e > 0 ? this.sizes[e - 1].accumulator : 0 : Math.floor(e / n) * this.itemSize, this.scrollToPosition(t);
+		},
+		scrollToPosition(e) {
+			let t = this.direction === "vertical" ? {
+				scroll: "scrollTop",
+				start: "top"
+			} : {
+				scroll: "scrollLeft",
+				start: "left"
+			}, n, r, i;
+			if (this.pageMode) {
+				let a = bt(this.$el), o = a.tagName === "HTML" ? 0 : a[t.scroll], s = a.getBoundingClientRect(), c = this.$el.getBoundingClientRect()[t.start] - s[t.start];
+				n = a, r = t.scroll, i = e + o + c;
+			} else n = this.$el, r = t.scroll, i = e;
+			n[r] = i;
+		},
+		itemsLimitError() {
+			throw setTimeout(() => {
+				console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", this.$el), console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.");
+			}), Error("Rendered items limit reached");
+		},
+		sortViews() {
+			this.pool.sort((e, t) => e.nr.index - t.nr.index);
+		}
+	}
+}, Ot = {
+	key: 0,
+	ref: "before",
+	class: "vue-recycle-scroller__slot"
+}, kt = {
+	key: 1,
+	ref: "after",
+	class: "vue-recycle-scroller__slot"
+};
+function At(e, t, n, r, i, o) {
+	let u = O("ResizeObserver"), f = k("observe-visibility");
+	return L((S(), l("div", {
+		class: _(["vue-recycle-scroller", {
+			ready: i.ready,
+			"page-mode": n.pageMode,
+			[`direction-${e.direction}`]: !0
+		}]),
+		onScrollPassive: t[0] ||= (...e) => o.handleScroll && o.handleScroll(...e)
+	}, [
+		e.$slots.before ? (S(), l("div", Ot, [D(e.$slots, "before")], 512)) : c("v-if", !0),
+		(S(), s(A(n.listTag), {
+			ref: "wrapper",
+			style: y({ [e.direction === "vertical" ? "minHeight" : "minWidth"]: i.totalSize + "px" }),
+			class: _(["vue-recycle-scroller__item-wrapper", n.listClass])
+		}, {
+			default: I(() => [(S(!0), l(a, null, E(i.pool, (t) => (S(), s(A(n.itemTag), h({
+				key: t.nr.id,
+				style: i.ready ? {
+					transform: `translate${e.direction === "vertical" ? "Y" : "X"}(${t.position}px) translate${e.direction === "vertical" ? "X" : "Y"}(${t.offset}px)`,
+					width: n.gridItems ? `${e.direction === "vertical" && n.itemSecondarySize || n.itemSize}px` : void 0,
+					height: n.gridItems ? `${e.direction === "horizontal" && n.itemSecondarySize || n.itemSize}px` : void 0
+				} : null,
+				class: ["vue-recycle-scroller__item-view", [n.itemClass, { hover: !n.skipHover && i.hoverKey === t.nr.key }]]
+			}, N(n.skipHover ? {} : {
+				mouseenter: () => {
+					i.hoverKey = t.nr.key;
+				},
+				mouseleave: () => {
+					i.hoverKey = null;
+				}
+			})), {
+				default: I(() => [D(e.$slots, "default", {
+					item: t.item,
+					index: t.nr.index,
+					active: t.nr.used
+				})]),
+				_: 2
+			}, 1040, ["style", "class"]))), 128)), D(e.$slots, "empty")]),
+			_: 3
+		}, 8, ["style", "class"])),
+		e.$slots.after ? (S(), l("div", kt, [D(e.$slots, "after")], 512)) : c("v-if", !0),
+		d(u, { onNotify: o.handleResize }, null, 8, ["onNotify"])
+	], 34)), [[f, o.handleVisibilityChange]]);
+}
+Dt.render = At, Dt.__file = "src/components/RecycleScroller.vue";
+var jt = {
+	name: "DynamicScroller",
+	components: { RecycleScroller: Dt },
+	provide() {
+		return typeof ResizeObserver < "u" && (this.$_resizeObserver = new ResizeObserver((e) => {
+			requestAnimationFrame(() => {
+				if (Array.isArray(e)) {
+					for (let t of e) if (t.target && t.target.$_vs_onResize) {
+						let e, n;
+						if (t.borderBoxSize) {
+							let r = t.borderBoxSize[0];
+							e = r.inlineSize, n = r.blockSize;
+						} else e = t.contentRect.width, n = t.contentRect.height;
+						t.target.$_vs_onResize(t.target.$_vs_id, e, n);
+					}
+				}
+			});
+		})), {
+			vscrollData: this.vscrollData,
+			vscrollParent: this,
+			vscrollResizeObserver: this.$_resizeObserver
+		};
+	},
+	inheritAttrs: !1,
+	props: {
+		...St,
+		minItemSize: {
+			type: [Number, String],
+			required: !0
+		}
+	},
+	emits: ["resize", "visible"],
+	data() {
+		return { vscrollData: {
+			active: !0,
+			sizes: {},
+			keyField: this.keyField,
+			simpleArray: !1
+		} };
+	},
+	computed: {
+		simpleArray: Ct,
+		itemsWithSize() {
+			let e = [], { items: t, keyField: n, simpleArray: r } = this, i = this.vscrollData.sizes, a = t.length;
+			for (let o = 0; o < a; o++) {
+				let a = t[o], s = r ? o : a[n], c = i[s];
+				c === void 0 && !this.$_undefinedMap[s] && (c = 0), e.push({
+					item: a,
+					id: s,
+					size: c
+				});
+			}
+			return e;
+		}
+	},
+	watch: {
+		items() {
+			this.forceUpdate();
+		},
+		simpleArray: {
+			handler(e) {
+				this.vscrollData.simpleArray = e;
+			},
+			immediate: !0
+		},
+		direction(e) {
+			this.forceUpdate(!0);
+		},
+		itemsWithSize(e, t) {
+			let n = this.$el.scrollTop, r = 0, i = 0, a = Math.min(e.length, t.length);
+			for (let o = 0; o < a && !(r >= n); o++) r += t[o].size || this.minItemSize, i += e[o].size || this.minItemSize;
+			let o = i - r;
+			o !== 0 && (this.$el.scrollTop += o);
+		}
+	},
+	beforeCreate() {
+		this.$_updates = [], this.$_undefinedSizes = 0, this.$_undefinedMap = {}, this.$_events = me();
+	},
+	activated() {
+		this.vscrollData.active = !0;
+	},
+	deactivated() {
+		this.vscrollData.active = !1;
+	},
+	unmounted() {
+		this.$_events.all.clear();
+	},
+	methods: {
+		onScrollerResize() {
+			this.$refs.scroller && this.forceUpdate(), this.$emit("resize");
+		},
+		onScrollerVisible() {
+			this.$_events.emit("vscroll:update", { force: !1 }), this.$emit("visible");
+		},
+		forceUpdate(e = !1) {
+			(e || this.simpleArray) && (this.vscrollData.sizes = {}), this.$_events.emit("vscroll:update", { force: !0 });
+		},
+		scrollToItem(e) {
+			let t = this.$refs.scroller;
+			t && t.scrollToItem(e);
+		},
+		getItemSize(e, t = void 0) {
+			let n = this.simpleArray ? t ?? this.items.indexOf(e) : e[this.keyField];
+			return this.vscrollData.sizes[n] || 0;
+		},
+		scrollToBottom() {
+			if (this.$_scrollingToBottom) return;
+			this.$_scrollingToBottom = !0;
+			let e = this.$el;
+			this.$nextTick(() => {
+				e.scrollTop = e.scrollHeight + 5e3;
+				let t = () => {
+					e.scrollTop = e.scrollHeight + 5e3, requestAnimationFrame(() => {
+						e.scrollTop = e.scrollHeight + 5e3, this.$_undefinedSizes === 0 ? this.$_scrollingToBottom = !1 : requestAnimationFrame(t);
+					});
+				};
+				requestAnimationFrame(t);
+			});
+		}
+	}
+};
+function Mt(e, t, n, r, i, a) {
+	let o = O("RecycleScroller");
+	return S(), s(o, h({
+		ref: "scroller",
+		items: a.itemsWithSize,
+		"min-item-size": n.minItemSize,
+		direction: e.direction,
+		"key-field": "id",
+		"list-tag": e.listTag,
+		"item-tag": e.itemTag
+	}, e.$attrs, {
+		onResize: a.onScrollerResize,
+		onVisible: a.onScrollerVisible
+	}), {
+		default: I(({ item: t, index: n, active: r }) => [D(e.$slots, "default", v(f({
+			item: t.item,
+			index: n,
+			active: r,
+			itemWithSize: t
+		})))]),
+		before: I(() => [D(e.$slots, "before")]),
+		after: I(() => [D(e.$slots, "after")]),
+		empty: I(() => [D(e.$slots, "empty")]),
+		_: 3
+	}, 16, [
+		"items",
+		"min-item-size",
+		"direction",
+		"list-tag",
+		"item-tag",
+		"onResize",
+		"onVisible"
+	]);
+}
+jt.render = Mt, jt.__file = "src/components/DynamicScroller.vue";
+var Nt = {
+	name: "DynamicScrollerItem",
+	inject: [
+		"vscrollData",
+		"vscrollParent",
+		"vscrollResizeObserver"
+	],
+	props: {
+		item: { required: !0 },
+		watchData: {
+			type: Boolean,
+			default: !1
+		},
+		active: {
+			type: Boolean,
+			required: !0
+		},
+		index: {
+			type: Number,
+			default: void 0
+		},
+		sizeDependencies: {
+			type: [Array, Object],
+			default: null
+		},
+		emitResize: {
+			type: Boolean,
+			default: !1
+		},
+		tag: {
+			type: String,
+			default: "div"
+		}
+	},
+	emits: ["resize"],
+	computed: {
+		id() {
+			if (this.vscrollData.simpleArray) return this.index;
+			if (this.vscrollData.keyField in this.item) return this.item[this.vscrollData.keyField];
+			throw Error(`keyField '${this.vscrollData.keyField}' not found in your item. You should set a valid keyField prop on your Scroller`);
+		},
+		size() {
+			return this.vscrollData.sizes[this.id] || 0;
+		},
+		finalActive() {
+			return this.active && this.vscrollData.active;
+		}
+	},
+	watch: {
+		watchData: "updateWatchData",
+		id(e, t) {
+			if (this.$el.$_vs_id = this.id, this.size || this.onDataUpdate(), this.$_sizeObserved) {
+				let n = this.vscrollData.sizes[t], r = this.vscrollData.sizes[e];
+				n != null && n !== r && this.applySize(n);
+			}
+		},
+		finalActive(e) {
+			this.size || (e ? this.vscrollParent.$_undefinedMap[this.id] || (this.vscrollParent.$_undefinedSizes++, this.vscrollParent.$_undefinedMap[this.id] = !0) : this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = !1)), this.vscrollResizeObserver ? e ? this.observeSize() : this.unobserveSize() : e && this.$_pendingVScrollUpdate === this.id && this.updateSize();
+		}
+	},
+	created() {
+		if (!this.$isServer && (this.$_forceNextVScrollUpdate = null, this.updateWatchData(), !this.vscrollResizeObserver)) {
+			for (let e in this.sizeDependencies) this.$watch(() => this.sizeDependencies[e], this.onDataUpdate);
+			this.vscrollParent.$_events.on("vscroll:update", this.onVscrollUpdate);
+		}
+	},
+	mounted() {
+		this.finalActive && (this.updateSize(), this.observeSize());
+	},
+	beforeUnmount() {
+		this.vscrollParent.$_events.off("vscroll:update", this.onVscrollUpdate), this.unobserveSize();
+	},
+	methods: {
+		updateSize() {
+			this.finalActive ? this.$_pendingSizeUpdate !== this.id && (this.$_pendingSizeUpdate = this.id, this.$_forceNextVScrollUpdate = null, this.$_pendingVScrollUpdate = null, this.computeSize(this.id)) : this.$_forceNextVScrollUpdate = this.id;
+		},
+		updateWatchData() {
+			this.watchData && !this.vscrollResizeObserver ? this.$_watchData = this.$watch("item", () => {
+				this.onDataUpdate();
+			}, { deep: !0 }) : this.$_watchData &&= (this.$_watchData(), null);
+		},
+		onVscrollUpdate({ force: e }) {
+			!this.finalActive && e && (this.$_pendingVScrollUpdate = this.id), (this.$_forceNextVScrollUpdate === this.id || e || !this.size) && this.updateSize();
+		},
+		onDataUpdate() {
+			this.updateSize();
+		},
+		computeSize(e) {
+			this.$nextTick(() => {
+				if (this.id === e) {
+					let e = this.$el.offsetWidth, t = this.$el.offsetHeight;
+					this.applyWidthHeight(e, t);
+				}
+				this.$_pendingSizeUpdate = null;
+			});
+		},
+		applyWidthHeight(e, t) {
+			let n = ~~(this.vscrollParent.direction === "vertical" ? t : e);
+			n && this.size !== n && this.applySize(n);
+		},
+		applySize(e) {
+			this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = void 0), this.vscrollData.sizes[this.id] = e, this.emitResize && this.$emit("resize", this.id);
+		},
+		observeSize() {
+			this.vscrollResizeObserver && (this.$_sizeObserved ||= (this.vscrollResizeObserver.observe(this.$el), this.$el.$_vs_id = this.id, this.$el.$_vs_onResize = this.onResize, !0));
+		},
+		unobserveSize() {
+			this.vscrollResizeObserver && (this.$_sizeObserved &&= (this.vscrollResizeObserver.unobserve(this.$el), this.$el.$_vs_onResize = void 0, !1));
+		},
+		onResize(e, t, n) {
+			this.id === e && this.applyWidthHeight(t, n);
+		}
+	},
+	render() {
+		return p(this.tag, this.$slots.default());
+	}
+};
+Nt.__file = "src/components/DynamicScrollerItem.vue";
+//#endregion
+//#region components/DocSyncSelect/SearchWrap/ScrollList.vue
+var Pt = {
+	key: 0,
+	class: "loading-indicator"
+}, Ft = { class: "loading-text" }, It = {
+	key: 1,
+	class: "no-more-tip"
+}, Lt = {
+	key: 1,
+	class: "empty-state"
+}, Rt = { class: "empty-text" }, zt = /* @__PURE__ */ i({
+	__name: "ScrollList",
+	props: {
+		items: {
+			type: Array,
+			default: () => []
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		hasMore: {
+			type: Boolean,
+			default: !0
+		},
+		loadingText: {
+			type: String,
+			default: "加载中..."
+		},
+		noMoreText: {
+			type: String,
+			default: "没有更多了"
+		},
+		emptyText: {
+			type: String,
+			default: "暂无数据"
+		},
+		height: {
+			type: String,
+			default: "auto"
+		},
+		minItemSize: {
+			type: Number,
+			default: 60
+		},
+		buffer: {
+			type: Number,
+			default: 200
+		},
+		threshold: {
+			type: Number,
+			default: 100
+		},
+		keyField: {
+			type: String,
+			default: "id"
+		}
+	},
+	emits: ["load-more", "scroll"],
+	setup(e, { expose: t, emit: n }) {
+		let r = e, i = n, a = T(null), f = T(null), p = T(!1), m = null, h = o(() => ({ height: r.height })), _ = () => {
+			console.log("loadMore triggered----", p.value || !r.hasMore || r.loading), !(p.value || !r.hasMore || r.loading) && (p.value = !0, i("load-more"));
+		}, v = () => {
+			p.value = !1, C();
+		}, C = () => {
+			a.value && a.value.scrollToPosition(0);
+		}, w = () => {
+			if (a.value) {
+				let e = a.value.$el;
+				e && (e.scrollTop = e.scrollHeight);
+			}
+		}, E = (e) => {
+			a.value && a.value.scrollToItem(e);
+		}, k = () => {
+			if (!f.value || !a.value) return;
+			let e = a.value.$el;
+			if (!e) return;
+			let t = {
+				root: e,
+				rootMargin: `${r.threshold}px`,
+				threshold: .1
+			};
+			m = new IntersectionObserver((e) => {
+				e.forEach((e) => {
+					console.log("Setting up Intersection Observer-----", e.isIntersecting, r.hasMore, !p.value, !r.loading), e.isIntersecting && r.hasMore && !p.value && !r.loading && _();
+				});
+			}, t), m.observe(f.value);
+		}, A = () => {
+			m &&= (m.disconnect(), null);
+		}, j = (e) => {
+			let t = e.target;
+			i("scroll", {
+				scrollTop: t.scrollTop,
+				scrollHeight: t.scrollHeight,
+				clientHeight: t.clientHeight
+			});
+		};
+		return F(() => r.loading, (e) => {
+			e || (p.value = !1);
+		}), F(() => r.items.length, async () => {
+			await g(), A(), r.hasMore && k();
+		}), b(async () => {
+			await g(), r.hasMore && k();
+		}), x(() => {
+			A();
+		}), t({
+			reset: v,
+			scrollToTop: C,
+			scrollToBottom: w,
+			scrollToItem: E,
+			loadMore: _
+		}), (t, n) => {
+			let r = O("Loading");
+			return S(), l("div", {
+				class: "scroll-list",
+				style: y(h.value)
+			}, [e.items.length > 0 ? (S(), s(P(jt), {
+				key: 0,
+				ref_key: "scrollerRef",
+				ref: a,
+				items: e.items,
+				"min-item-size": e.minItemSize,
+				buffer: e.buffer,
+				"key-field": e.keyField,
+				class: "scroller",
+				onScroll: j
+			}, {
+				default: I(({ item: e, index: n, active: r }) => [d(P(Nt), {
+					item: e,
+					active: r,
+					"data-index": n,
+					"size-dependencies": [e]
+				}, {
+					default: I(() => [D(t.$slots, "default", {
+						item: e,
+						index: n,
+						active: r
+					}, void 0, !0)]),
+					_: 2
+				}, 1032, [
+					"item",
+					"active",
+					"data-index",
+					"size-dependencies"
+				])]),
+				after: I(() => [e.hasMore ? (S(), l("div", {
+					key: 0,
+					ref_key: "loadMoreTriggerRef",
+					ref: f,
+					class: "load-more-trigger"
+				}, [p.value ? (S(), l("div", Pt, [d(P(B), { class: "is-loading" }, {
+					default: I(() => [d(r)]),
+					_: 1
+				}), u("span", Ft, M(e.loadingText), 1)])) : c("", !0)], 512)) : c("", !0), !e.hasMore && e.items.length > 0 ? (S(), l("div", It, M(e.noMoreText), 1)) : c("", !0)]),
+				_: 3
+			}, 8, [
+				"items",
+				"min-item-size",
+				"buffer",
+				"key-field"
+			])) : c("", !0), e.items.length === 0 && !p.value ? (S(), l("div", Lt, [D(t.$slots, "empty", {}, () => [d(P(B), {
+				class: "empty-icon",
+				size: 80
+			}, {
+				default: I(() => [d(P(oe))]),
+				_: 1
+			}), u("div", Rt, M(e.emptyText), 1)], !0)])) : c("", !0)], 4);
+		};
+	}
+}, [["__scopeId", "data-v-37e01654"]]), Bt = { class: "search-wrap" }, Vt = { class: "list-item" }, Ht = ["onClick"], Ut = { class: "node-info" }, Wt = { class: "node-label" }, Gt = {
+	key: 0,
+	class: "node-suffix"
+}, Kt = /* @__PURE__ */ i({
+	__name: "index",
+	props: {
+		items: {
+			type: Array,
+			default: () => []
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		hasMore: {
+			type: Boolean,
+			default: !1
+		},
+		height: {
+			type: String,
+			default: "100%"
+		},
+		minItemSize: {
+			type: Number,
+			default: 50
+		},
+		buffer: {
+			type: Number,
+			default: 100
+		},
+		treeProps: {
+			type: Object,
+			default: () => ({
+				label: "label",
+				value: "value"
+			})
+		},
+		selectedDocuments: {
+			type: Array,
+			default: () => []
+		}
+	},
+	emits: ["load-more", "item-check"],
+	setup(e, { emit: t }) {
+		let { t: n } = r(), i = e, a = o(() => i.items.map((e) => {
+			let t = (i.selectedDocuments || []).some((t) => t.id === e.id);
+			return {
+				...e,
+				isSelected: t
+			};
+		})), s = t, f = (e, t) => {
+			s("item-check", e, t);
+		}, p = () => {
+			s("load-more");
+		};
+		return (t, r) => (S(), l("div", Bt, [d(zt, {
+			items: a.value,
+			loading: e.loading,
+			"key-field": "id",
+			"has-more": e.hasMore,
+			"loading-text": P(n)("FEISHU_SEARCH_TEXT.LOADING_TEXT"),
+			"no-more-text": P(n)("FEISHU_SEARCH_TEXT.NO_MORE_TEXT"),
+			"empty-text": P(n)("FEISHU_SEARCH_TEXT.EMPTY_TEXT"),
+			height: e.height,
+			"min-item-size": e.minItemSize,
+			buffer: e.buffer,
+			onLoadMore: p
+		}, {
+			default: I(({ item: n }) => [u("div", Vt, [D(t.$slots, "default", { item: n }, () => [u("div", {
+				class: "search-item",
+				onClick: () => f(n, !n.isSelected)
+			}, [
+				d(P(ne), { "model-value": n.isSelected }, null, 8, ["model-value"]),
+				d(Z, {
+					"file-type": n.type,
+					size: 26,
+					isLocalFileType: t.data?.isLocalFileType
+				}, null, 8, ["file-type", "isLocalFileType"]),
+				u("div", Ut, [u("span", Wt, M(n[e.treeProps.label]), 1), n.suffix ? (S(), l("span", Gt, M(n.suffix), 1)) : c("", !0)])
+			], 8, Ht)], !0)])]),
+			_: 3
+		}, 8, [
+			"items",
+			"loading",
+			"has-more",
+			"loading-text",
+			"no-more-text",
+			"empty-text",
+			"height",
+			"min-item-size",
+			"buffer"
+		])]));
+	}
+}, [["__scopeId", "data-v-9b7f5847"]]), qt = { class: "left-wrap" }, Jt = { class: "content" }, Yt = { class: "input-wrap" }, Xt = { class: "tree-container" }, Zt = { class: "tree-node-content" }, Qt = { class: "node-info" }, $t = { class: "node-label" }, en = {
+	key: 0,
+	class: "node-suffix"
+}, tn = 15, nn = /* @__PURE__ */ i(/* @__PURE__ */ Object.assign({ name: "LeftLayout" }, {
+	__name: "LeftLayout",
+	props: {
+		tabs: {
+			type: Array,
+			default: () => []
+		},
+		treeData: {
+			type: Object,
+			default: () => ({})
+		},
+		treeProps: {
+			type: Object,
+			default: () => J
+		},
+		selectedDocuments: {
+			type: Array,
+			default: () => []
+		},
+		currentTab: {
+			type: String,
+			default: ""
+		},
+		searchType: {
+			type: String,
+			default: Y.FRONTEND,
+			validator: (e) => Object.values(Y).includes(e)
+		},
+		textConfig: {
+			type: Object,
+			default: () => ({ searchPlaceholder: "" })
+		},
+		getTabSelectedDocuments: {
+			type: Function,
+			default: () => () => []
+		},
+		responseSearchHook: {
+			type: Object,
+			default: () => {}
+		}
+	},
+	emits: [
+		"node-check",
+		"tab-change",
+		"search",
+		"node-expand",
+		"load-more",
+		"node-check-search"
+	],
+	setup(e, { expose: t, emit: n }) {
+		let r = e, i = n, f = Ae(p), m = T(), h = T(""), _ = T(r.currentTab || r.tabs[0]?.value || X.MY_FILES), v = T([]), y = T(!1), b = T(!1), x = o(() => r.tabs.map((e) => ({
+			label: e.label,
+			value: e.value
+		}))), C = o(() => r.treeData[_.value] || []);
+		F(() => r.responseSearchHook, (e, t) => {
+			b.value = Ue(r.currentTab, e), y.value = !1;
+		}, {
+			deep: !0,
+			immediate: !0
+		});
+		let w = Pe(i, 800), E = o(() => {
+			if (r.searchType === Y.BACKEND) return C.value;
+			let e = h.value?.trim();
+			return e ? Fe(C.value, e, r.treeProps) : C.value;
+		}), O = (e) => r.getTabSelectedDocuments(_.value).some((t) => t[r.treeProps.value] === e), k = o(() => {
+			if (!h.value?.trim()) return [];
+			let e = (t, n = 0) => {
+				let i = [];
+				return t.forEach((t) => {
+					i.push({
+						...t,
+						level: n,
+						isSelected: O(t[r.treeProps.value])
+					}), t[r.treeProps.children] && t[r.treeProps.children].length > 0 && (i = i.concat(e(t[r.treeProps.children], n + 1)));
+				}), i;
+			};
+			return e(E.value);
+		}), A = (e) => {
+			i("node-check", e);
+		}, j = (e, t) => {
+			i("node-check-search", {
+				selectedNode: r.getTabSelectedDocuments(_.value),
+				checkedNode: e,
+				isChecked: t
+			});
+		};
+		F(_, (e) => {
+			b.value = Ue(e, r.responseSearchHook), i("tab-change", e);
+		}), F(() => r.treeData, () => {
+			y.value = !1, m.value && m.value.syncSelectedNodes && g(() => {
+				let e = (r.selectedDocuments || []).map((e) => e[r.treeProps.value]);
+				m.value.syncSelectedNodes(e);
+			});
+		}, { deep: !0 });
+		let N = (e) => {
+			Ne(e) || i("node-expand", {
+				node: e,
+				tabKey: _.value
+			});
+		}, ee = () => {
+			y.value = !0, i("load-more");
+		};
+		return F(h, (e) => {
+			r.searchType === Y.BACKEND ? (e && e.trim() && (y.value = !0), w(e || "")) : y.value = !1;
+		}), F(() => r.currentTab, (e) => {
+			e && e !== _.value && (_.value = e);
+		}, { immediate: !0 }), F(() => r.selectedDocuments, (e) => {
+			v.value = e || [];
+		}, {
+			immediate: !0,
+			deep: !0
+		}), t({
+			setNodeCheckStatus: (e, t) => {
+				m.value?.setNodeCheckStatus(e, t);
+			},
+			updateNodeChildren: (e, t) => {
+				m.value && m.value?.updateNodeChildren && m.value.updateNodeChildren(e, t);
+			},
+			syncSelectedNodes: (e) => {
+				m.value?.syncSelectedNodes(e);
+			}
+		}), (t, n) => (S(), l("div", qt, [u("div", Jt, [
+			u("div", Yt, [d(P(re), {
+				modelValue: h.value,
+				"onUpdate:modelValue": n[0] ||= (e) => h.value = e,
+				placeholder: r.textConfig.searchPlaceholder,
+				"prefix-icon": P(pe),
+				clearable: ""
+			}, null, 8, [
+				"modelValue",
+				"placeholder",
+				"prefix-icon"
+			])]),
+			d(P(V), {
+				modelValue: _.value,
+				"onUpdate:modelValue": n[1] ||= (e) => _.value = e,
+				options: x.value
+			}, null, 8, ["modelValue", "options"]),
+			u("div", Xt, [!E.value || E.value.length === 0 ? (S(), s(P(q), { key: 0 })) : (S(), l(a, { key: 1 }, [h.value.trim() === "" ? (S(), s(Ge, {
+				key: 1,
+				modelValue: v.value,
+				"onUpdate:modelValue": n[2] ||= (e) => v.value = e,
+				ref_key: "treeSelectRef",
+				ref: m,
+				"tree-list": E.value,
+				"tree-props": e.treeProps,
+				"filter-keyword": h.value,
+				itemSize: 50,
+				hasTreeLine: !0,
+				"text-config": e.textConfig,
+				includeParentSelected: !0,
+				onHandleCheck: A,
+				onNodeExpand: N,
+				getTabSelectedDocuments: e.getTabSelectedDocuments
+			}, {
+				node: I(({ node: n, data: r }) => [D(t.$slots, "node", {
+					node: n,
+					data: r
+				}, () => [d(P(f), {
+					node: n,
+					treeData: E.value,
+					showLabelLine: !0,
+					indent: tn
+				}, {
+					default: I(() => [u("div", Zt, [d(Z, {
+						"file-type": r.type,
+						size: 26,
+						isLocalFileType: r?.isLocalFileType
+					}, null, 8, ["file-type", "isLocalFileType"]), u("div", Qt, [u("span", $t, M(r[e.treeProps.label]), 1), r.suffix ? (S(), l("span", en, M(r.suffix), 1)) : c("", !0)])])]),
+					_: 2
+				}, 1032, ["node", "treeData"])], !0)]),
+				_: 3
+			}, 8, [
+				"modelValue",
+				"tree-list",
+				"tree-props",
+				"filter-keyword",
+				"text-config",
+				"getTabSelectedDocuments"
+			])) : (S(), s(Kt, {
+				key: 0,
+				items: k.value,
+				loading: y.value,
+				"has-more": b.value,
+				"min-item-size": 50,
+				buffer: 100,
+				"tree-props": e.treeProps,
+				"selected-documents": e.selectedDocuments,
+				onItemCheck: j,
+				onLoadMore: ee
+			}, null, 8, [
+				"items",
+				"loading",
+				"has-more",
+				"tree-props",
+				"selected-documents"
+			]))], 64))])
+		])]));
+	}
+}), [["__scopeId", "data-v-6bf8c501"]]);
+//#endregion
+//#region components/DocSyncSelect/useDocumentSelection.js
+function rn(e = {}) {
+	let { valueKey: t = "id" } = e, n = T(/* @__PURE__ */ new Map()), r = o(() => {
+		let e = [], r = /* @__PURE__ */ new Set();
+		return n.value.forEach((n) => {
+			n.forEach((n) => {
+				let i = n[t];
+				r.has(i) || (e.push(n), r.add(i));
+			});
+		}), e;
+	});
+	return {
+		allSelectedDocuments: r,
+		selectionMap: n,
+		getTabSelectedDocuments: (e) => {
+			let t = n.value.get(e);
+			return t ? Array.from(t.values()) : [];
+		},
+		updateTabSelection: (e, r = []) => {
+			n.value.has(e) || n.value.set(e, /* @__PURE__ */ new Map());
+			let i = /* @__PURE__ */ new Map();
+			r.forEach((e) => {
+				e && e[t] != null && i.set(e[t], e);
+			}), n.value.set(e, i), n.value = new Map(n.value);
+		},
+		removeDocument: (e) => {
+			let r = e[t], i = null;
+			return n.value.forEach((e, t) => {
+				e.has(r) && (e.delete(r), i = t);
+			}), i && (n.value = new Map(n.value)), i;
+		},
+		toggleDocument: (e, r, i) => {
+			n.value.has(e) || n.value.set(e, /* @__PURE__ */ new Map());
+			let a = n.value.get(e), o = r[t];
+			i ? a.set(o, r) : a.delete(o), n.value = new Map(n.value);
+		},
+		clearTabSelection: (e) => {
+			n.value.has(e) && (n.value.get(e).clear(), n.value = new Map(n.value));
+		},
+		clearAllSelection: () => {
+			n.value.clear(), n.value = new Map(n.value);
+		},
+		isDocumentSelected: (e, t) => {
+			let r = n.value.get(e);
+			return r ? r.has(t) : !1;
+		},
+		setAllDocuments: (e = [], r = "") => {
+			n.value.clear(), e.forEach((e) => {
+				let i = e.tabKey || r;
+				i && (n.value.has(i) || n.value.set(i, /* @__PURE__ */ new Map()), n.value.get(i).set(e[t], e));
+			}), n.value = new Map(n.value);
+		},
+		getStatistics: () => {
+			let e = {
+				total: r.value.length,
+				byTab: {}
+			};
+			return n.value.forEach((t, n) => {
+				e.byTab[n] = t.size;
+			}), e;
+		}
+	};
+}
+//#endregion
+//#region components/DocSyncSelect/useAllTabDocList.js
+function an(e = {}) {
+	let { valueKey: t = J.value, childrenKey: n = J.children } = e, r = T(/* @__PURE__ */ new Map()), i = T({});
+	return {
+		allTabDocList: r,
+		allTabTreeDataObject: o(() => {
+			let e = {};
+			return r.value.forEach((t, n) => {
+				e[n] = t;
+			}), e;
+		}),
+		responseSearchHook: i,
+		setAllTabsTreeData: (e = {}) => {
+			let t = /* @__PURE__ */ new Map();
+			e && typeof e == "object" && Object.keys(e).forEach((n) => {
+				let r = Array.isArray(e[n]) ? e[n] : [];
+				t.set(n, r);
+			}), r.value = t;
+		},
+		getTabTreeData: (e) => r.value.get(e) || [],
+		setTabTreeData: (e, t = []) => {
+			let n = new Map(r.value);
+			n.set(e, Array.isArray(t) ? t : []), r.value = n;
+		},
+		updateNodeChildren: (e, i, a = []) => {
+			let o = r.value.get(e);
+			if (!o || !Array.isArray(o)) return;
+			let s = (e) => e.map((e) => {
+				if (e[t] === i) return {
+					...e,
+					[n]: a
+				};
+				let r = e[n];
+				return Array.isArray(r) && r.length > 0 ? {
+					...e,
+					[n]: s(r)
+				} : e;
+			}), c = s(o), l = new Map(r.value);
+			l.set(e, c), r.value = l;
+		},
+		setResponseSearchHook: (e) => {
+			i.value = e;
+		}
+	};
+}
+//#endregion
+//#region components/DocSyncSelect/layout.vue
+var on = { class: "doc-sync-select" }, sn = n(/* @__PURE__ */ i(/* @__PURE__ */ Object.assign({ name: "DocSyncSelect" }, {
+	__name: "layout",
+	props: {
+		modelValue: {
+			type: Array,
+			default: () => []
+		},
+		treeData: {
+			type: Object,
+			default: () => ({})
+		},
+		updateMeta: {
+			type: Object,
+			default: () => ({
+				updateId: "",
+				operation: null,
+				context: {}
+			})
+		},
+		treeProps: {
+			type: Object,
+			default: () => J
+		},
+		tabs: {
+			type: Array,
+			default: () => []
+		},
+		searchType: {
+			type: String,
+			default: Y.FRONTEND,
+			validator: (e) => Object.values(Y).includes(e)
+		},
+		textConfig: {
+			type: Object,
+			default: () => ({ searchPlaceholder: "" })
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"change",
+		"search",
+		"load-node",
+		"recursive-load",
+		"load-more"
+	],
+	setup(e, { expose: t, emit: n }) {
+		let r = e, i = n, a = o(() => ({
+			...J,
+			...r.treeProps
+		})), s = o(() => a.value.value), c = o(() => a.value.children), u = T(), f = T(r.tabs[0]?.value || ""), { allSelectedDocuments: p, getTabSelectedDocuments: m, updateTabSelection: h, removeDocument: _, setAllDocuments: v, selectionMap: y, getAllSelectedIds: x } = rn({ valueKey: a.value.value }), C = (e = p.value) => {
+			i("update:modelValue", e), i("change", e);
+		}, { allTabTreeDataObject: w, setAllTabsTreeData: E, updateNodeChildren: D, responseSearchHook: O, setResponseSearchHook: k } = an({
+			valueKey: s.value,
+			childrenKey: c.value
+		});
+		F(() => r.treeData, (e) => {
+			E(e || {});
+		}, {
+			deep: !0,
+			immediate: !0
+		}), F(() => r.updateMeta, (e, t) => {
+			if (!e || !e.updateId || e.updateId === (t?.updateId || "")) return;
+			let { operation: n, context: r } = e;
+			switch (n) {
+				case "node-children-update":
+					te(r);
+					break;
+				case "recursive-load":
+					ne(r);
+					break;
+				case "search":
+				case "load-more":
+					B(r);
+					break;
+				default: break;
+			}
+		}, {
+			deep: !0,
+			immediate: !1
+		});
+		let A = o(() => m(f.value)), j = (e) => {
+			f.value = e;
+			let t = m(e);
+			u.value && u.value.syncSelectedNodes && g(() => {
+				let e = t.map((e) => e[a.value.value]);
+				u.value.syncSelectedNodes(e);
+			});
+		}, M = (e, t, n) => {
+			g(() => {
+				let r = t || [];
+				h(n, [
+					...Ie(e, a.value),
+					e,
+					...r
+				]), C();
+			});
+		}, N = (e) => {
+			let { selectedNode: t, checkedNode: n, isChecked: r } = e, i = m(f.value);
+			if (t = Be({
+				tabKey: f.value,
+				currentSelectedDocs: [n],
+				treeData: w.value,
+				treeProps: a.value,
+				hasSelectToRightDocList: i
+			}), !r) {
+				h(f.value, i.filter((e) => e.id !== n.id)), C();
+				return;
+			}
+			h(f.value, [...i, ...t]), C();
+		}, ee = (e) => {
+			let { selectedNode: t, checkedNode: n, isChecked: r } = e, i = m(f.value);
+			if (t = Be({
+				tabKey: f.value,
+				currentSelectedDocs: t,
+				treeData: w.value,
+				treeProps: a.value,
+				hasSelectToRightDocList: i
+			}), !n?.hasChildren) {
+				h(f.value, t), C();
+				return;
+			}
+			if (!r) {
+				let e = Ie(n, a.value), t = new Set([n[s.value], ...e.map((e) => e[s.value])]), r = m(f.value).filter((e) => !t.has(e[s.value]));
+				h(f.value, r), t.forEach((e) => {
+					u.value?.setNodeCheckStatus && u.value.setNodeCheckStatus(e, !1);
+				}), C();
+				return;
+			}
+			if (r && n && He(n, a.value)) {
+				R(n);
+				return;
+			} else M(n, t || [], f.value);
+		}, I = (e) => {
+			let t = a.value.value;
+			_(e) === f.value && u.value && u.value.setNodeCheckStatus && u.value.setNodeCheckStatus(e[t], !1), C();
+		}, L = ({ node: e, tabKey: t }) => {
+			let n = {};
+			t === X.FEISHU_KNOWLEDGE ? n = {
+				spaceId: e?.spaceId,
+				parentNodeToken: e?.nodeToken
+			} : t === X.MY_FILES && (n = { folderToken: e?.folderToken }), i("load-node", {
+				nodeKey: e[a.value?.value],
+				nodeData: e,
+				tabKey: t,
+				requestParams: n
+			});
+		}, R = (e) => {
+			let t = {};
+			f.value === X.FEISHU_KNOWLEDGE ? t = {
+				spaceId: e?.spaceId,
+				parentNodeToken: e?.nodeToken,
+				recursive: !0
+			} : f.value === X.MY_FILES && (t = {
+				folderToken: e?.folderToken,
+				recursive: !0
+			}), i("recursive-load", {
+				nodeKey: e[a.value?.value],
+				nodeData: e,
+				tabKey: f.value,
+				requestParams: t
+			});
+		}, z = (e, t) => {
+			u.value && u.value.updateNodeChildren && u.value.updateNodeChildren(e, t), f.value && D(f.value, e, t);
+		}, te = (e) => {
+			let { nodeKey: t, newChildren: n } = e;
+			u.value?.updateNodeChildren && u.value.updateNodeChildren(t, n);
+		}, ne = (e) => {
+			let { nodeKey: t, tabKey: n, newChildren: i, originalNode: o, nodeData: s, error: c } = e;
+			if (c) return;
+			let l = Ve(r.treeData[n] || [], o?.id || t, a.value);
+			l && M(l, m(n || f.value), n || f.value);
+		}, B = (e) => {
+			let { responseSearch: t } = e;
+			k(t);
+		}, re = ({ keyword: e }) => {
+			i("search", { keyword: e });
+		}, V = () => {
+			i("load-more", f.value);
+		};
+		return b(() => {
+			r.modelValue && r.modelValue.length > 0 && v(r.modelValue, f.value);
+		}), F(() => r.modelValue, (e, t) => {
+			if (!e || e.length === 0) {
+				t && t.length > 0 && v([]);
+				return;
+			}
+			let n = p.value;
+			n.length === e.length && e.every((e) => n.some((t) => t[a.value.value] === e[a.value.value])) || v(e, f.value);
+		}, { deep: !0 }), t({
+			clearSelection: () => {
+				v([]), C([]);
+			},
+			getSelectedDocuments: () => p.value,
+			setSelectedDocuments: (e) => {
+				v(e, f.value), C();
+			},
+			updateNodeChildren: z
+		}), (t, n) => (S(), l("div", on, [d(nn, {
+			tabs: e.tabs,
+			"tree-data": P(w),
+			"tree-props": a.value,
+			"selected-documents": A.value,
+			"current-tab": f.value,
+			"search-type": e.searchType,
+			"text-config": e.textConfig,
+			"response-search-hook": P(O),
+			ref_key: "leftLayoutRef",
+			ref: u,
+			onNodeCheck: ee,
+			onNodeCheckSearch: N,
+			onTabChange: j,
+			onSearch: re,
+			onNodeExpand: L,
+			onLoadMore: V,
+			getTabSelectedDocuments: P(m)
+		}, null, 8, [
+			"tabs",
+			"tree-data",
+			"tree-props",
+			"selected-documents",
+			"current-tab",
+			"search-type",
+			"text-config",
+			"response-search-hook",
+			"getTabSelectedDocuments"
+		]), d(Oe, {
+			"selected-documents": P(p),
+			"tree-props": a.value,
+			onDeleteNode: I
+		}, null, 8, ["selected-documents", "tree-props"])]));
+	}
+}), [["__scopeId", "data-v-c45c2d8e"]])), cn = n(Z);
+//#endregion
+export { cn as n, sn as t };