@ptahjs/dnd 0.1.2 → 0.1.3

package/dist/dnd.es.js

@@ -1,6 +1,6 @@
-(function(){try{const elementStyle=document.createElement('style');elementStyle.appendChild(document.createTextNode("/* 控制点 */\n.draggable-dot-wrap {\n    position: absolute;\n    inset: 0;\n    pointer-events: none;\n    z-index: 1;\n    box-sizing: border-box;\n}\n\n.draggable-dot {\n    display: block;\n    position: absolute;\n    z-index: 2;\n    width: 10px;\n    height: 10px;\n    border-radius: 50%;\n    background: #3a7afe;\n    transform: translate(-50%, -50%);\n    pointer-events: auto;\n}\n\n.draggable-dot[data-pos=\"tl\"] {\n    left: 0%;\n    top: 0%;\n    cursor: nw-resize;\n}\n\n.draggable-dot[data-pos=\"tm\"] {\n    left: 50%;\n    top: 0%;\n    width: 16px;\n    height: 8px;\n    border-radius: 8px;\n    cursor: n-resize;\n}\n\n.draggable-dot[data-pos=\"tr\"] {\n    top: 0%;\n    right: 0%;\n    transform: translate(50%, -50%);\n    cursor: ne-resize;\n}\n\n/* right */\n.draggable-dot[data-pos=\"rm\"] {\n    top: 50%;\n    right: 0%;\n    width: 8px;\n    height: 16px;\n    border-radius: 8px;\n    transform: translate(50%, -50%);\n    cursor: e-resize;\n}\n\n/* 下 */\n.draggable-dot[data-pos=\"br\"] {\n    right: 0%;\n    bottom: 0%;\n    transform: translate(50%, 50%);\n    cursor: se-resize;\n}\n\n.draggable-dot[data-pos=\"bm\"] {\n    left: 50%;\n    bottom: 0%;\n    width: 16px;\n    height: 8px;\n    border-radius: 8px;\n    transform: translate(-50%, 50%);\n    cursor: s-resize;\n}\n\n.draggable-dot[data-pos=\"bl\"] {\n    left: 0%;\n    bottom: 0%;\n    transform: translate(-50%, 50%);\n    cursor: sw-resize;\n}\n\n/* 左 */\n.draggable-dot[data-pos=\"lm\"] {\n    left: 0%;\n    top: 50%;\n    width: 8px;\n    height: 16px;\n    border-radius: 8px;\n    cursor: w-resize;\n}\n\n/* 旋转 */\n.draggable-rotate {\n    position: absolute;\n    top: 0;\n    left: 50%;\n    transform: translate(-50%, -200%);\n    z-index: 2;\n    cursor: grab;\n    pointer-events: auto;\n}\n\n.draggable-rotate::after {\n    content: \"\";\n    width: 16px;\n    height: 16px;\n    display: block;\n    background: center/contain no-repeat\n        url(\"data:image/svg+xml;charset=utf-8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20viewBox%3D%220%200%201024%201024%22%3E%3Cpath%20fill%3D%22%233a7afe%22%20d%3D%22M784.512%20230.272v-50.56a32%2032%200%201%201%2064%200v149.056a32%2032%200%200%201-32%2032H667.52a32%2032%200%201%201%200-64h92.992A320%20320%200%201%200%20524.8%20833.152a320%20320%200%200%200%20320-320h64a384%20384%200%200%201-384%20384%20384%20384%200%200%201-384-384%20384%20384%200%200%201%20643.712-282.88z%22/%3E%3C/svg%3E\");\n}\n.draggable-markline-x,\n.draggable-markline-y {\n    position: absolute;\n    left: 0;\n    top: 0;\n    display: none;\n    z-index: 9999;\n    background-color: #3a7afe;\n}\n\n.draggable-markline-x {\n    width: 1px;\n    height: 100%;\n}\n\n.draggable-markline-y {\n    width: 100%;\n    height: 1px;\n}\n.dnd-mirror {\n    position: fixed;\n    left: 0px;\n    top: 0px;\n    margin: 0px;\n    pointer-events: none;\n    z-index: 999999;\n    will-change: transform;\n    transform: translate3d(0, 0, 0);\n    opacity: 0.5;\n    background: #fff;\n}/* 变量集中管理 */\r\n.dnd-indicator {\r\n    --dnd-color: #3a7afe;\r\n    --dnd-dot: 6px;\r\n    --dnd-line: 2px;\r\n    position: absolute;\r\n    pointer-events: none;\r\n    background: var(--dnd-color);\r\n    display: none;\r\n}\r\n\r\n.dnd-indicator.dnd-indicator-active {\r\n    display: block;\r\n}\r\n\r\n/* 合并选择器，移除多余 opacity:0 */\r\n.dnd-indicator::before,\r\n.dnd-indicator::after {\r\n    content: '';\r\n    position: absolute;\r\n    background: var(--dnd-color);\r\n    width: var(--dnd-dot);\r\n    height: var(--dnd-dot);\r\n    border-radius: 50%;\r\n    opacity: 0;\r\n    transition: opacity .15s;\r\n}\r\n\r\n.dnd-indicator-active::before,\r\n.dnd-indicator-active::after {\r\n    opacity: 1;\r\n}\r\n\r\n/* 水平方向共用一套规则 */\r\n.dnd-indicator--top,\r\n.dnd-indicator--bottom {\r\n    height: var(--dnd-line);\r\n    width: 100%;\r\n    left: 0;\r\n}\r\n\r\n.dnd-indicator--top {\r\n    top: 0;\r\n}\r\n\r\n.dnd-indicator--bottom {\r\n    bottom: 0;\r\n}\r\n\r\n.dnd-indicator--top::before,\r\n.dnd-indicator--bottom::before {\r\n    left: -2px;\r\n}\r\n\r\n.dnd-indicator--top::after,\r\n.dnd-indicator--bottom::after {\r\n    right: -2px;\r\n}\r\n\r\n.dnd-indicator--top::before,\r\n.dnd-indicator--top::after {\r\n    top: -2px;\r\n}\r\n\r\n.dnd-indicator--bottom::before,\r\n.dnd-indicator--bottom::after {\r\n    bottom: -2px;\r\n}\r\n\r\n/* 垂直方向共用一套规则 */\r\n.dnd-indicator--left,\r\n.dnd-indicator--right {\r\n    width: var(--dnd-line);\r\n    height: 100%;\r\n    top: 0;\r\n}\r\n\r\n.dnd-indicator--left {\r\n    left: 0;\r\n}\r\n\r\n.dnd-indicator--right {\r\n    right: 0;\r\n}\r\n\r\n.dnd-indicator--left::before,\r\n.dnd-indicator--left::after {\r\n    left: -2px;\r\n}\r\n\r\n.dnd-indicator--right::before,\r\n.dnd-indicator--right::after {\r\n    right: -2px;\r\n}\r\n\r\n.dnd-indicator--left::before,\r\n.dnd-indicator--right::before {\r\n    top: -2px;\r\n}\r\n\r\n.dnd-indicator--left::after,\r\n.dnd-indicator--right::after {\r\n    bottom: -2px;\r\n}.dnd-marquee {\n    position: absolute;\n    background: rgba(64, 150, 255, 0.1);\n    border: 1px solid rgba(64, 150, 255, 0.6);\n    pointer-events: none;\n    z-index: 9999;\n}\n/*$vite$:1*/"));document.head.appendChild(elementStyle)}catch(e){console.error('PtahJs Style Inject:',e)}})();import { EventDispatcher } from "@ptahjs/shared";
+(function(){try{const elementStyle=document.createElement('style');elementStyle.appendChild(document.createTextNode(".draggable-dot-wrap{pointer-events:none;z-index:1;box-sizing:border-box;position:absolute;inset:0}.draggable-dot{z-index:2;pointer-events:auto;background:#3a7afe;border-radius:50%;width:10px;height:10px;display:block;position:absolute;transform:translate(-50%,-50%)}.draggable-dot[data-pos=tl]{cursor:nw-resize;top:0%;left:0%}.draggable-dot[data-pos=tm]{cursor:n-resize;border-radius:8px;width:16px;height:8px;top:0%;left:50%}.draggable-dot[data-pos=tr]{cursor:ne-resize;top:0%;right:0%;transform:translate(50%,-50%)}.draggable-dot[data-pos=rm]{cursor:e-resize;border-radius:8px;width:8px;height:16px;top:50%;right:0%;transform:translate(50%,-50%)}.draggable-dot[data-pos=br]{cursor:se-resize;bottom:0%;right:0%;transform:translate(50%,50%)}.draggable-dot[data-pos=bm]{cursor:s-resize;border-radius:8px;width:16px;height:8px;bottom:0%;left:50%;transform:translate(-50%,50%)}.draggable-dot[data-pos=bl]{cursor:sw-resize;bottom:0%;left:0%;transform:translate(-50%,50%)}.draggable-dot[data-pos=lm]{cursor:w-resize;border-radius:8px;width:8px;height:16px;top:50%;left:0%}.draggable-rotate{z-index:2;cursor:grab;pointer-events:auto;position:absolute;top:0;left:50%;transform:translate(-50%,-200%)}.draggable-rotate:after{content:\"\";background:url(data:image/svg+xml;charset=utf-8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20viewBox%3D%220%200%201024%201024%22%3E%3Cpath%20fill%3D%22%233a7afe%22%20d%3D%22M784.512%20230.272v-50.56a32%2032%200%201%201%2064%200v149.056a32%2032%200%200%201-32%2032H667.52a32%2032%200%201%201%200-64h92.992A320%20320%200%201%200%20524.8%20833.152a320%20320%200%200%200%20320-320h64a384%20384%200%200%201-384%20384%20384%20384%200%200%201-384-384%20384%20384%200%200%201%20643.712-282.88z%22/%3E%3C/svg%3E) 50%/contain no-repeat;width:16px;height:16px;display:block}.draggable-markline-x,.draggable-markline-y{z-index:9999;background-color:#3a7afe;display:none;position:absolute;top:0;left:0}.draggable-markline-x{width:1px;height:100%}.draggable-markline-y{width:100%;height:1px}.dnd-mirror{pointer-events:none;z-index:999999;will-change:transform;opacity:.5;background:#fff;margin:0;position:fixed;top:0;left:0;transform:translate(0,0)}.dnd-indicator{--dnd-color:#3a7afe;--dnd-dot:6px;--dnd-line:2px;pointer-events:none;background:var(--dnd-color);display:none;position:absolute}.dnd-indicator.dnd-indicator-active{display:block}.dnd-indicator:before,.dnd-indicator:after{content:\"\";background:var(--dnd-color);width:var(--dnd-dot);height:var(--dnd-dot);opacity:0;border-radius:50%;transition:opacity .15s;position:absolute}.dnd-indicator-active:before,.dnd-indicator-active:after{opacity:1}.dnd-indicator--top,.dnd-indicator--bottom{height:var(--dnd-line);width:100%;left:0}.dnd-indicator--top{top:0}.dnd-indicator--bottom{bottom:0}.dnd-indicator--top:before,.dnd-indicator--bottom:before{left:-2px}.dnd-indicator--top:after,.dnd-indicator--bottom:after{right:-2px}.dnd-indicator--top:before,.dnd-indicator--top:after{top:-2px}.dnd-indicator--bottom:before,.dnd-indicator--bottom:after{bottom:-2px}.dnd-indicator--left,.dnd-indicator--right{width:var(--dnd-line);height:100%;top:0}.dnd-indicator--left{left:0}.dnd-indicator--right{right:0}.dnd-indicator--left:before,.dnd-indicator--left:after{left:-2px}.dnd-indicator--right:before,.dnd-indicator--right:after{right:-2px}.dnd-indicator--left:before,.dnd-indicator--right:before{top:-2px}.dnd-indicator--left:after,.dnd-indicator--right:after{bottom:-2px}.dnd-marquee{pointer-events:none;z-index:9999;background:#4096ff1a;border:1px solid #4096ff99;position:absolute}\n/*$vite$:1*/"));document.head.appendChild(elementStyle)}catch(e){console.error('PtahJs Style Inject:',e)}})();import { EventDispatcher as e } from "@ptahjs/shared";
 //#region src/constant.js
-var ATTR = {
+var t = {
 	dataAttr: "data",
 	copyAttr: "copy",
 	dragAttr: "drag",
@@ -17,8 +17,7 @@ var ATTR = {
 	resizableAttr: "resizable",
 	rotatableAttr: "rotatable",
 	scaleRatioAttr: "scale-ratio"
-};
-var CLASS_NAMES = {
+}, n = {
 	canDrop: "dnd-canDrop",
 	noDrop: "dnd-noDrop",
 	dragging: "dnd-dragging",
@@ -31,1683 +30,948 @@ var CLASS_NAMES = {
 	indicatorBottom: "dnd-indicator--bottom",
 	indicatorLeft: "dnd-indicator--left",
 	marquee: "dnd-marquee"
-};
-var VERT_SPLIT = .5;
-var HORIZ_SPLIT = 1 / 3;
-var THRESHOLDS = {
+}, r = .5, i = 1 / 3, a = {
 	MARQUEE_MOVE: 5,
 	DRAG_START: 3
-};
-var AUTO_SCROLL = {
+}, o = {
 	EDGE: 48,
 	MIN_SPEED: 180,
 	MAX_SPEED: 600,
 	MIN_DT: 8,
 	MAX_DT: 64,
 	DEFAULT_DT: 16.67
-};
-var MARQUEE_OVERLAP_RATIO = .5;
-var CLAMP_TOLERANCE = .5;
+}, s = .5, c = .5;
 //#endregion
 //#region src/utils/computeDropRegion.js
-function computeDropRegion(monitor, support) {
-	let cacheKey;
-	if (support instanceof Set) cacheKey = support.__regionKey ?? (support.__regionKey = Array.from(support).sort().join(","));
-	else cacheKey = support;
-	const fullCacheKey = `dropRegionFns_${cacheKey || "all"}`;
-	if (monitor?.cache?.[fullCacheKey]) return monitor.cache[fullCacheKey];
-	const getDropRect = () => {
-		if (!monitor.currentDrop) return;
-		return monitor.currentDropRect || void 0;
-	};
-	const needsVertical = !support || support === "all" || support instanceof Set && (support.has("top") || support.has("bottom"));
-	const needsHorizontal = !support || support === "all" || support instanceof Set && (support.has("left") || support.has("right"));
-	const fns = {
-		isOverTop: needsVertical ? () => {
-			const r = getDropRect();
-			return r ? monitor.y < r.y + r.height * VERT_SPLIT : false;
-		} : () => false,
-		isOverBottom: needsVertical ? () => {
-			const r = getDropRect();
-			return r ? monitor.y > r.y + r.height * (1 - VERT_SPLIT) : false;
-		} : () => false,
-		isOverLeft: needsHorizontal ? () => {
-			const r = getDropRect();
-			return r ? monitor.x < r.x + r.width * HORIZ_SPLIT : false;
-		} : () => false,
-		isOverRight: needsHorizontal ? () => {
-			const r = getDropRect();
-			return r ? monitor.x > r.x + r.width * (1 - HORIZ_SPLIT) : false;
-		} : () => false
+function l(e, t) {
+	let n;
+	n = t instanceof Set ? t.__regionKey ??= Array.from(t).sort().join(",") : t;
+	let a = `dropRegionFns_${n || "all"}`;
+	if (e?.cache?.[a]) return e.cache[a];
+	let o = () => {
+		if (e.currentDrop) return e.currentDropRect || void 0;
+	}, s = !t || t === "all" || t instanceof Set && (t.has("top") || t.has("bottom")), c = !t || t === "all" || t instanceof Set && (t.has("left") || t.has("right")), l = {
+		isOverTop: s ? () => {
+			let t = o();
+			return t ? e.y < t.y + t.height * r : !1;
+		} : () => !1,
+		isOverBottom: s ? () => {
+			let t = o();
+			return t ? e.y > t.y + t.height * (1 - r) : !1;
+		} : () => !1,
+		isOverLeft: c ? () => {
+			let t = o();
+			return t ? e.x < t.x + t.width * i : !1;
+		} : () => !1,
+		isOverRight: c ? () => {
+			let t = o();
+			return t ? e.x > t.x + t.width * (1 - i) : !1;
+		} : () => !1
 	};
-	if (monitor?.cache) monitor.cache[fullCacheKey] = fns;
-	return fns;
+	return e?.cache && (e.cache[a] = l), l;
 }
 //#endregion
 //#region src/utils/parseData.js
-/** 解析 data 属性内容（支持 JSON） */
-function parseData(raw) {
-	if (raw === void 0) return;
-	const s = String(raw).trim();
-	if (!s) return "";
+function u(e) {
+	if (e === void 0) return;
+	let t = String(e).trim();
+	if (!t) return "";
 	try {
-		return JSON.parse(s);
+		return JSON.parse(t);
 	} catch {
-		return s;
+		return t;
 	}
 }
 //#endregion
 //#region src/utils/createPayload.js
-function createPayload(type, monitor) {
-	const getDropWorldPoint = () => {
-		const drop = monitor.currentDrop;
-		if (!drop) return void 0;
-		const rect = monitor.currentDropRect || drop.getBoundingClientRect();
-		const raw = monitor.adapter.getAttr(drop, ATTR.scaleRatioAttr) ?? drop.getAttribute?.("data-scale-ratio");
-		const n = Number(raw);
-		const scale = Number.isFinite(n) && n > 0 ? n : 1;
-		const left = rect.left + (drop.clientLeft || 0);
-		const top = rect.top + (drop.clientTop || 0);
-		const px = monitor.x - left;
-		const py = monitor.y - top;
-		const localPx = px + (drop.scrollLeft || 0);
-		const localPy = py + (drop.scrollTop || 0);
+function d(e, n) {
+	let r = () => {
+		let e = n.currentDrop;
+		if (!e) return;
+		let r = n.currentDropRect || e.getBoundingClientRect(), i = n.adapter.getAttr(e, t.scaleRatioAttr) ?? e.getAttribute?.("data-scale-ratio"), a = Number(i), o = Number.isFinite(a) && a > 0 ? a : 1, s = r.left + (e.clientLeft || 0), c = r.top + (e.clientTop || 0), l = n.x - s, u = n.y - c, d = l + (e.scrollLeft || 0), f = u + (e.scrollTop || 0);
 		return {
-			x: localPx / scale,
-			y: localPy / scale,
-			scale,
-			px: localPx,
-			py: localPy
+			x: d / o,
+			y: f / o,
+			scale: o,
+			px: d,
+			py: f
 		};
-	};
-	const getDropData = () => {
-		const drop = monitor.currentDrop;
-		const cache = monitor.cache;
-		if (!drop) {
-			cache.dropDataEl = void 0;
-			cache.dropDataRaw = void 0;
-			cache.dropDataParsed = void 0;
+	}, i = () => {
+		let e = n.currentDrop, r = n.cache;
+		if (!e) {
+			r.dropDataEl = void 0, r.dropDataRaw = void 0, r.dropDataParsed = void 0;
 			return;
 		}
-		const raw = monitor.adapter.getAttr(drop, ATTR.dataAttr);
-		if (cache.dropDataEl === drop && raw === cache.dropDataRaw) return cache.dropDataParsed;
-		cache.dropDataEl = drop;
-		cache.dropDataRaw = raw;
-		cache.dropDataParsed = parseData(raw);
-		return cache.dropDataParsed;
+		let i = n.adapter.getAttr(e, t.dataAttr);
+		return r.dropDataEl === e && i === r.dropDataRaw ? r.dropDataParsed : (r.dropDataEl = e, r.dropDataRaw = i, r.dropDataParsed = u(i), r.dropDataParsed);
 	};
-	if (!monitor.cache.hitDropFn) {
-		let lastFrameId = -1;
-		let lastX = 0;
-		let lastY = 0;
-		let lastIgnore = void 0;
-		let lastResult = void 0;
-		monitor.cache.hitDropFn = (x, y, ignoreRoot) => {
-			const frameId = monitor?.adapter?.frameId ?? monitor?.cache?.frameId ?? 0;
-			if (frameId === lastFrameId && x === lastX && y === lastY && ignoreRoot === lastIgnore) return lastResult;
-			lastFrameId = frameId;
-			lastX = x;
-			lastY = y;
-			lastIgnore = ignoreRoot;
-			const adapter = monitor.adapter;
-			if (!adapter?.hitDrop) throw new Error("createPayload requires monitor.adapter.hitDrop");
-			lastResult = adapter.hitDrop(x, y, monitor.namespace, ignoreRoot);
-			return lastResult;
+	if (!n.cache.hitDropFn) {
+		let e = -1, t = 0, r = 0, i, a;
+		n.cache.hitDropFn = (o, s, c) => {
+			let l = n?.adapter?.frameId ?? n?.cache?.frameId ?? 0;
+			if (l === e && o === t && s === r && c === i) return a;
+			e = l, t = o, r = s, i = c;
+			let u = n.adapter;
+			if (!u?.hitDrop) throw Error("createPayload requires monitor.adapter.hitDrop");
+			return a = u.hitDrop(o, s, n.namespace, c), a;
 		};
 	}
 	return {
-		type,
-		namespace: monitor.namespace,
-		data: monitor.data,
+		type: e,
+		namespace: n.namespace,
+		data: n.data,
 		get dropData() {
-			return getDropData();
+			return i();
 		},
 		get dropPoint() {
-			return getDropWorldPoint();
+			return r();
 		},
-		indicatorRegion: monitor.lastIndicatorRegion,
-		isDragScope: monitor.isDragScope,
-		isCopy: monitor.isCopy,
-		sourceEl: monitor.sourceEl,
-		handleEl: monitor.handleEl,
-		originDrop: monitor.originDrop,
-		currentDrop: monitor.currentDrop,
-		x: monitor.x,
-		y: monitor.y,
-		dx: monitor.dx,
-		dy: monitor.dy,
-		started: monitor.started,
-		hitDrop: monitor.cache.hitDropFn,
-		...computeDropRegion(monitor)
+		indicatorRegion: n.lastIndicatorRegion,
+		isDragScope: n.isDragScope,
+		isCopy: n.isCopy,
+		sourceEl: n.sourceEl,
+		handleEl: n.handleEl,
+		originDrop: n.originDrop,
+		currentDrop: n.currentDrop,
+		x: n.x,
+		y: n.y,
+		dx: n.dx,
+		dy: n.dy,
+		started: n.started,
+		hitDrop: n.cache.hitDropFn,
+		...l(n)
 	};
 }
 //#endregion
 //#region src/utils/createSession.js
-/**
-* 拖拽 session 状态（一次拖拽过程的运行时容器）
-*
-* 说明：
-* - session 是”短生命周期”：通常在一次 drag 开始创建/复用，结束后 reset。
-* - 为了兼容旧插件，这里保留了一些 legacy 字段（mirror/indicator/cache 等），
-*   同时新的运行时鼓励按 Measure / Compute / Commit 三阶段去组织逻辑。
-*/
-function createSession(store) {
+function f(e) {
 	return {
-		/** DOM adapter：由 Dnd 注入（用于命中检测、测量 rect、读写 data/caches 等） */
 		adapter: void 0,
-		/** 当前命中的 drop 容器 rect（每帧按需测量） */
 		currentDropRect: void 0,
-		/** 拖拽中止原因/标记（例如外部调用 abort、异常、系统取消等） */
 		dragAbort: void 0,
-		/** 是否处于”拖拽作用域/拖拽捕获”状态（框架内部用来控制一些分支逻辑） */
-		isDragScope: false,
-		/** 是否为”复制拖拽”（来自 sourceEl 的 copy=”true/false”） */
-		isCopy: false,
-		/** 是否处于 active（pointer down 后到 drag end 前） */
-		active: false,
-		/** pointerId：多指触控/PointerEvent 用于区分指针 */
+		isDragScope: !1,
+		isCopy: !1,
+		active: !1,
 		pointerId: void 0,
-		/** pointer down 时的起始坐标 */
 		startX: 0,
 		startY: 0,
-		/** 当前指针坐标（通常来自 move 事件） */
 		x: 0,
 		y: 0,
-		/** 相对起点位移：dx = x - startX, dy = y - startY */
 		dx: 0,
 		dy: 0,
-		/** 是否已经”真正开始拖拽”（超过阈值后置 true） */
-		started: false,
-		/** 开始拖拽的阈值（像素），避免轻微抖动误触发 drag */
-		threshold: THRESHOLDS.DRAG_START,
-		/** 最近一次 move 的时间戳（用于节流/惯性/autoScroll 等逻辑） */
+		started: !1,
+		threshold: a.DRAG_START,
 		lastMoveTs: 0,
-		/** 被拖拽的源元素（drag source） */
 		sourceEl: void 0,
-		/** 触发拖拽的 handle（如果支持把手拖拽） */
 		handleEl: void 0,
-		/** 拖拽开始时所在的 drop（原始容器/起始落点） */
 		originDrop: void 0,
-		/** 当前命中的 drop（命中检测结果） */
 		currentDrop: void 0,
-		/** namespace：用于隔离不同拖拽域（不同画布/列表间互不影响） */
 		namespace: void 0,
-		/** data：本次拖拽携带的业务数据（payload） */
 		data: void 0,
-		/** 镜像元素（拖拽时跟随指针移动的预览） */
 		mirrorEl: void 0,
-		/** 镜像相对指针的偏移（通常用于保持抓取点一致） */
 		mirrorOffsetX: 0,
 		mirrorOffsetY: 0,
-		/** 当前是否允许 drop（canDrop 计算结果，供 UI/indicator 使用） */
-		currentAllowed: false,
-		/** 本帧是否有变更需要在 rAF 里处理（驱动 Measure/Compute/Commit） */
-		dirty: false,
-		/** 上一帧坐标（用于计算本帧是否移动、速度等） */
+		currentAllowed: !1,
+		dirty: !1,
 		prevX: 0,
 		prevY: 0,
 		cache: {
-			/** 帧 id（自增），标识当前处于第几帧处理 */
 			frameId: 0,
-			/** drop 数据所在元素（比如 data-* 的宿主元素） */
 			dropDataEl: void 0,
-			/** drop 原始数据（字符串/对象等原始读取结果） */
 			dropDataRaw: void 0,
-			/** drop 解析后数据（结构化对象） */
 			dropDataParsed: void 0,
-			/** drop 区域函数列表/集合（用于自定义命中区域） */
 			dropRegionFns: void 0,
-			/** 命中检测函数缓存（加速 hitDrop） */
 			hitDropFn: void 0,
-			/** canDrop 的上下文对象（避免重复创建） */
 			canDropCtx: void 0,
-			/** dropRect 是否需要重新测量（drop 变化、布局变化等会置脏） */
-			dropRectDirty: false,
-			/** 自动滚动计划（例如方向/速度/目标容器） */
+			dropRectDirty: !1,
 			autoScrollPlan: void 0,
-			/** 自动滚动上次执行时间（用于节流） */
 			autoScrollLastTs: 0
 		},
-		/** indicator 元素（用于显示插入线/高亮等） */
 		indicatorEl: void 0,
-		/** indicator 当前所在区域/位置描述（用于渲染插入位置等） */
 		indicatorRegion: void 0,
 		lastIndicatorRegion: void 0,
-		/**
-		* 持久化选中集（按 namespace 分组）
-		* 注意：这里不是复制数据，而是引用 store 里的 Map，
-		* 让多次拖拽 session 之间共享选中状态。
-		*/
-		selectedByNs: store?.selectedByNs,
-		/** 最近一次 drag 的时间戳（可用于双击抑制、节流等） */
+		selectedByNs: e?.selectedByNs,
 		lastDragTs: 0,
-		/** 是否抑制下一次 click（防止拖拽结束触发误点击） */
-		suppressNextClick: false
+		suppressNextClick: !1
 	};
 }
 //#endregion
 //#region src/utils/createContext.js
-function createContext({ dnd, session, store, frame, adapter }) {
-	const payloadCache = /* @__PURE__ */ new Map();
-	const payload = (type = "drag") => {
-		if (payloadCache.has(type)) return payloadCache.get(type);
-		const p = createPayload(type, session);
-		payloadCache.set(type, p);
-		return p;
-	};
+function p({ dnd: e, session: t, store: n, frame: r, adapter: i }) {
+	let a = /* @__PURE__ */ new Map();
 	return {
-		dnd,
-		session,
-		store,
-		frame,
-		adapter,
-		payload,
+		dnd: e,
+		session: t,
+		store: n,
+		frame: r,
+		adapter: i,
+		payload: (e = "drag") => {
+			if (a.has(e)) return a.get(e);
+			let n = d(e, t);
+			return a.set(e, n), n;
+		},
 		resetPayloadCache() {
-			payloadCache.clear();
+			a.clear();
 		}
 	};
 }
 //#endregion
 //#region src/utils/isToggleEnabled.js
-function isToggleEnabled(el, attrName, defaultValue = true) {
-	if (!el?.getAttribute) return defaultValue;
-	const dataName = `data-${attrName}`;
-	const v = el.getAttribute(attrName) ?? el.getAttribute(dataName);
-	if (v === null) return defaultValue;
-	return String(v).toLowerCase() !== "false";
+function m(e, t, n = !0) {
+	if (!e?.getAttribute) return n;
+	let r = `data-${t}`, i = e.getAttribute(t) ?? e.getAttribute(r);
+	return i === null ? n : String(i).toLowerCase() !== "false";
 }
 //#endregion
 //#region src/utils/matchHandle.js
-function matchHandle(target, adapter) {
-	const draggable = adapter?.closestDraggable?.(target) || target?.closest?.(`[${ATTR.dragAttr}], [${ATTR.dragdropAttr}]`);
-	if (!draggable) return;
-	const rotatable = isToggleEnabled(draggable, ATTR.rotatableAttr, true);
-	const resizable = isToggleEnabled(draggable, ATTR.resizableAttr, true);
-	if (rotatable && (draggable.hasAttribute(ATTR.handleRotateAttr) || Boolean(draggable.querySelector?.(`[${ATTR.handleRotateAttr}]`))) || resizable && (draggable.hasAttribute(ATTR.handleResizeAttr) || Boolean(draggable.querySelector?.(`[${ATTR.handleResizeAttr}]`)))) {
-		const h = (rotatable ? target.closest?.(`[${ATTR.handleRotateAttr}]`) : null) || (resizable ? target.closest?.(`[${ATTR.handleResizeAttr}]`) : null);
-		if (h && draggable.contains(h)) return h;
-		return draggable;
-	}
-	if (draggable.hasAttribute(ATTR.handleAttr) || Boolean(draggable.querySelector?.(`[${ATTR.handleAttr}]`))) {
-		const h = target.closest?.(`[${ATTR.handleAttr}]`);
-		if (h && draggable.contains(h)) return h;
-		return;
-	}
-	return draggable;
+function h(e, n) {
+	let r = n?.closestDraggable?.(e) || e?.closest?.(`[${t.dragAttr}], [${t.dragdropAttr}]`);
+	if (!r) return;
+	let i = m(r, t.rotatableAttr, !0), a = m(r, t.resizableAttr, !0);
+	if (i && (r.hasAttribute(t.handleRotateAttr) || r.querySelector?.(`[${t.handleRotateAttr}]`)) || a && (r.hasAttribute(t.handleResizeAttr) || r.querySelector?.(`[${t.handleResizeAttr}]`))) {
+		let n = (i ? e.closest?.(`[${t.handleRotateAttr}]`) : null) || (a ? e.closest?.(`[${t.handleResizeAttr}]`) : null);
+		return n && r.contains(n) ? n : r;
+	}
+	if (r.hasAttribute(t.handleAttr) || r.querySelector?.(`[${t.handleAttr}]`)) {
+		let n = e.closest?.(`[${t.handleAttr}]`);
+		return n && r.contains(n) ? n : void 0;
+	}
+	return r;
 }
 //#endregion
 //#region src/utils/isHTMLElement.js
-function isHTMLElement(el) {
-	return el && typeof el === "object" && el.nodeType === 1;
+function g(e) {
+	return e && typeof e == "object" && e.nodeType === 1;
 }
 //#endregion
 //#region src/utils/isIgnoreClick.js
-/**
-* 检查元素或其祖先是否带有 ignore-click 属性
-* @param {Element} el - 要检查的元素
-* @returns {boolean} 是否应该忽略点击
-*/
-function isIgnoreClick(el) {
-	if (!isHTMLElement(el)) return false;
-	const name = ATTR.ignoreClickAttr;
-	const dataName = `data-${name}`;
-	return !!(el.closest?.(`[${name}], [${dataName}]`) || el.hasAttribute?.(name) || el.hasAttribute?.(dataName));
+function _(e) {
+	if (!g(e)) return !1;
+	let n = t.ignoreClickAttr, r = `data-${n}`;
+	return !!(e.closest?.(`[${n}], [${r}]`) || e.hasAttribute?.(n) || e.hasAttribute?.(r));
 }
 //#endregion
 //#region src/utils/scopeHelpers.js
-/**
-* drag-scope 属性名
-*/
-var SCOPE_ATTR = ATTR.dragScopeAttr;
-/**
-* drag-scope 选择器（支持标准属性和 data- 前缀）
-*/
-var SCOPE_SEL = `[${SCOPE_ATTR}], [data-${SCOPE_ATTR}]`;
-//#endregion
-//#region src/core/DomAdapter.js
-/**
-* DomAdapter
-*
-* Centralized DOM access + per-frame caching.
-*/
-var DomAdapter = class {
-	#frameId = 0;
-	#rectCache = /* @__PURE__ */ new WeakMap();
-	#nsCache = /* @__PURE__ */ new WeakMap();
+var v = t.dragScopeAttr, y = `[${v}], [data-${v}]`, b = class {
+	#e = 0;
+	#t = /* @__PURE__ */ new WeakMap();
+	#n = /* @__PURE__ */ new WeakMap();
 	get frameId() {
-		return this.#frameId;
+		return this.#e;
 	}
 	beginFrame() {
-		this.#frameId++;
+		this.#e++;
 	}
 	endFrame() {}
-	resolveRoot(root) {
-		if (!root) return;
-		if (typeof root === "string") {
-			const el = document.querySelector(root);
-			return el instanceof HTMLElement ? el : void 0;
-		}
-		return root instanceof HTMLElement ? root : void 0;
-	}
-	getAttr(el, name) {
-		return el?.getAttribute?.(name) ?? void 0;
-	}
-	getNamespace(el) {
-		if (!el) return "_default";
-		const cached = this.#nsCache.get(el);
-		if (cached && cached.frameId === this.#frameId) return cached.ns;
-		const ns = this.getAttr(el, ATTR.namespaceAttr) || "_default";
-		this.#nsCache.set(el, {
-			frameId: this.#frameId,
-			ns
-		});
-		return ns;
-	}
-	isDrop(el) {
-		if (!el) return false;
-		return el.hasAttribute?.(ATTR.dropAttr) || el.hasAttribute?.(ATTR.dragdropAttr);
-	}
-	closestDraggable(el) {
-		const { dragAttr, dragdropAttr } = ATTR;
-		if (!el) return;
-		if (el.hasAttribute(dragAttr) || el.hasAttribute(dragdropAttr)) return el;
-		return el.closest?.(`[${dragAttr}], [${dragdropAttr}]`) || void 0;
-	}
-	closestDrop(el) {
-		if (el) {
-			const { dropAttr, dragdropAttr } = ATTR;
-			return el.closest?.(`[${dropAttr}], [${dragdropAttr}]`) || void 0;
-		}
-	}
-	closestDragScope(el) {
-		const { dragScopeAttr } = ATTR;
-		if (!el) return;
-		if (el.hasAttribute(dragScopeAttr)) return el;
-		return el.closest?.(`[${dragScopeAttr}]`) || void 0;
-	}
-	measureRect(el) {
-		if (!el) return;
-		const cached = this.#rectCache.get(el);
-		if (cached && cached.frameId === this.#frameId) return cached.rect;
-		const rect = el.getBoundingClientRect();
-		this.#rectCache.set(el, {
-			frameId: this.#frameId,
-			rect
-		});
-		return rect;
-	}
-	/**
-	* Hit test drop at (x,y) with namespace validation.
-	* ignoreRoot: if provided, ignore ignoreRoot and all its descendants.
-	*/
-	hitDrop(x, y, ns, ignoreRoot) {
-		const el = document.elementFromPoint(x, y);
-		if (!el) return;
-		const targetNs = ns || "_default";
-		let p = el;
-		if (ignoreRoot && ignoreRoot.contains(p)) {
-			p = ignoreRoot.parentElement ?? null;
-			if (!p) return void 0;
-		}
-		while (p) {
-			if (this.isDrop(p)) {
-				if (this.getNamespace(p) === targetNs) return p;
+	resolveRoot(e) {
+		if (e) {
+			if (typeof e == "string") {
+				let t = document.querySelector(e);
+				return t instanceof HTMLElement ? t : void 0;
 			}
-			p = p.parentElement;
-		}
+			return e instanceof HTMLElement ? e : void 0;
+		}
+	}
+	getAttr(e, t) {
+		return e?.getAttribute?.(t) ?? void 0;
+	}
+	getNamespace(e) {
+		if (!e) return "_default";
+		let n = this.#n.get(e);
+		if (n && n.frameId === this.#e) return n.ns;
+		let r = this.getAttr(e, t.namespaceAttr) || "_default";
+		return this.#n.set(e, {
+			frameId: this.#e,
+			ns: r
+		}), r;
+	}
+	isDrop(e) {
+		return e ? e.hasAttribute?.(t.dropAttr) || e.hasAttribute?.(t.dragdropAttr) : !1;
+	}
+	closestDraggable(e) {
+		let { dragAttr: n, dragdropAttr: r } = t;
+		if (e) return e.hasAttribute(n) || e.hasAttribute(r) ? e : e.closest?.(`[${n}], [${r}]`) || void 0;
+	}
+	closestDrop(e) {
+		if (e) {
+			let { dropAttr: n, dragdropAttr: r } = t;
+			return e.closest?.(`[${n}], [${r}]`) || void 0;
+		}
+	}
+	closestDragScope(e) {
+		let { dragScopeAttr: n } = t;
+		if (e) return e.hasAttribute(n) ? e : e.closest?.(`[${n}]`) || void 0;
+	}
+	measureRect(e) {
+		if (!e) return;
+		let t = this.#t.get(e);
+		if (t && t.frameId === this.#e) return t.rect;
+		let n = e.getBoundingClientRect();
+		return this.#t.set(e, {
+			frameId: this.#e,
+			rect: n
+		}), n;
+	}
+	hitDrop(e, t, n, r) {
+		let i = document.elementFromPoint(e, t);
+		if (!i) return;
+		let a = n || "_default", o = i;
+		if (!(r && r.contains(o) && (o = r.parentElement ?? null, !o))) for (; o;) {
+			if (this.isDrop(o) && this.getNamespace(o) === a) return o;
+			o = o.parentElement;
+		}
+	}
+	hitDropForSource(e, t, n, r) {
+		let i = this.hitDrop(e, t, n, r);
+		if (i && r && this.isDrop(r)) {
+			let n = this.measureRect(r);
+			if (n && e >= n.left && e <= n.right && t >= n.top && t <= n.bottom) return;
+		}
+		return i;
+	}
+}, x = class {
+	#e = !1;
+	#t = !1;
+	#n = 0;
+	#r;
+	constructor(e) {
+		this.#r = typeof e == "function" ? e : () => !1;
 	}
-	/**
-	* Hit test 加“source-as-drop”特判：
-	* 若 sourceEl 本身是 drop 区，且指针仍在其矩形内，则不激活任何 drop（含父级）。
-	* onMeasure 与 onPointerUp 共用此判定，避免落点判定与拖拽过程分叉。
-	*/
-	hitDropForSource(x, y, ns, sourceEl) {
-		const drop = this.hitDrop(x, y, ns, sourceEl);
-		if (drop && sourceEl && this.isDrop(sourceEl)) {
-			const r = this.measureRect(sourceEl);
-			if (r && x >= r.left && x <= r.right && y >= r.top && y <= r.bottom) return;
-		}
-		return drop;
-	}
-};
-//#endregion
-//#region src/core/RafScheduler.js
-/**
-* RafScheduler（rAF 调度器）
-* - 将同一时间段内多次 `request()` 调用合并（coalesce）为一次 requestAnimationFrame。
-* - 每帧回调返回 boolean：是否需要在下一帧继续执行。
-*/
-var RafScheduler = class {
-	#running = false;
-	#pending = false;
-	#rafId = 0;
-	#frameCb;
-	constructor(frameCb) {
-		this.#frameCb = typeof frameCb === "function" ? frameCb : () => false;
-	}
-	/**
-	* 发起一次调度请求：
-	* - 标记 pending = true
-	* - 若尚未运行，则启动 rAF 循环
-	* - 若已在运行，则只做合并标记（下一帧会处理）
-	*/
 	request() {
-		this.#pending = true;
-		if (this.#running) return;
-		this.#running = true;
-		this.#rafId = requestAnimationFrame(this.#tick);
-	}
-	/**
-	* 取消调度：
-	* - 停止运行
-	* - 清空 pending
-	* - 若已挂了 rAF，则取消之
-	*/
+		this.#t = !0, !this.#e && (this.#e = !0, this.#n = requestAnimationFrame(this.#i));
+	}
 	cancel() {
-		if (!this.#running) return;
-		this.#running = false;
-		this.#pending = false;
-		if (this.#rafId) {
-			cancelAnimationFrame(this.#rafId);
-			this.#rafId = 0;
-		}
+		this.#e && (this.#e = !1, this.#t = !1, this.#n &&= (cancelAnimationFrame(this.#n), 0));
 	}
-	/**
-	* 每帧执行的 tick：
-	* - 消耗本帧的 pending
-	* - 执行 frameCb，并根据返回值决定是否继续下一帧
-	* - 若本帧执行期间又有人 request()，也会继续下一帧
-	*/
-	#tick = () => {
-		if (!this.#running) return;
-		this.#pending = false;
-		let keepGoing = false;
+	#i = () => {
+		if (!this.#e) return;
+		this.#t = !1;
+		let e = !1;
 		try {
-			keepGoing = Boolean(this.#frameCb(performance.now()));
-		} catch (err) {
-			keepGoing = false;
-			console.error("[RafScheduler] frame callback error:", err);
+			e = !!this.#r(performance.now());
+		} catch (t) {
+			e = !1, console.error("[RafScheduler] frame callback error:", t);
 		}
-		if (!this.#running) return;
-		if (keepGoing || this.#pending) {
-			this.#rafId = requestAnimationFrame(this.#tick);
-			return;
+		if (this.#e) {
+			if (e || this.#t) {
+				this.#n = requestAnimationFrame(this.#i);
+				return;
+			}
+			this.#e = !1, this.#n = 0;
 		}
-		this.#running = false;
-		this.#rafId = 0;
 	};
-};
-//#endregion
-//#region src/core/PointerSensor.js
-/**
-* PointerSensor（指针传感器）
-*
-* 职责：
-* - 监听 root 上的 `pointerdown`
-* - 若 consumer 接受本次交互，则在全局绑定 move/up/cancel/blur 监听（会话级监听）
-* - 对 pointermove 做坐标去重（与上一次坐标相同则跳过），只取末点坐标；
-*   真正的时间合并/节流交给上层 rAF 调度
-*/
-var PointerSensor = class {
-	#root;
-	#abort = new AbortController();
-	#active = false;
-	#pointerId;
-	#lastX = 0;
-	#lastY = 0;
-	#onDownCb;
-	#onMoveCb;
-	#onUpCb;
-	constructor({ onDown, onMove, onUp } = {}) {
-		this.#onDownCb = typeof onDown === "function" ? onDown : void 0;
-		this.#onMoveCb = typeof onMove === "function" ? onMove : void 0;
-		this.#onUpCb = typeof onUp === "function" ? onUp : void 0;
-	}
-	/**
-	* 设置/更换 root：
-	* - 若更换 root，会 abort 掉旧的监听并重新绑定
-	*/
-	setRoot(root) {
-		if (root === this.#root) return;
-		this.#abort.abort();
-		this.#abort = new AbortController();
-		this.#root = root;
-		if (!this.#root) return;
-		this.#root.addEventListener("pointerdown", this.#onDown, {
-			passive: false,
-			signal: this.#abort.signal
-		});
+}, S = class {
+	#e;
+	#t = new AbortController();
+	#n = !1;
+	#r;
+	#i = 0;
+	#a = 0;
+	#o;
+	#s;
+	#c;
+	constructor({ onDown: e, onMove: t, onUp: n } = {}) {
+		this.#o = typeof e == "function" ? e : void 0, this.#s = typeof t == "function" ? t : void 0, this.#c = typeof n == "function" ? n : void 0;
+	}
+	setRoot(e) {
+		e !== this.#e && (this.#t.abort(), this.#t = new AbortController(), this.#e = e, this.#e && this.#e.addEventListener("pointerdown", this.#l, {
+			passive: !1,
+			signal: this.#t.signal
+		}));
 	}
-	/**
-	* 销毁：
-	* - 解绑 root 监听
-	* - 清理会话状态
-	*/
 	destroy() {
-		this.#abort.abort();
-		this.#clearSession();
-		this.#root = void 0;
-	}
-	/**
-	* root 上的 pointerdown 处理：
-	* - 交给 consumer 判断是否接受本次交互
-	* - 若接受，拿到 pointerId 和 signal，并绑定全局会话监听
-	*/
-	#onDown = (event) => {
-		if (!this.#onDownCb || !this.#root) return;
-		const result = this.#onDownCb(event);
-		if (!result?.accepted || !result?.signal || !Number.isFinite(result.pointerId)) return;
-		this.#active = true;
-		this.#pointerId = result.pointerId;
-		this.#lastX = event.clientX;
-		this.#lastY = event.clientY;
-		this.#bindSession(result.signal);
+		this.#t.abort(), this.#d(), this.#e = void 0;
+	}
+	#l = (e) => {
+		if (!this.#o || !this.#e) return;
+		let t = this.#o(e);
+		!t?.accepted || !t?.signal || !Number.isFinite(t.pointerId) || (this.#n = !0, this.#r = t.pointerId, this.#i = e.clientX, this.#a = e.clientY, this.#u(t.signal));
 	};
-	/**
-	* 绑定会话期的全局监听：
-	* - 这些监听使用 consumer 提供的 signal 统一管理生命周期
-	* - consumer abort 时会自动移除（无需本类手动 removeEventListener）
-	*/
-	#bindSession(signal) {
-		globalThis.addEventListener("pointermove", this.#onMove, {
-			passive: false,
-			signal
-		});
-		globalThis.addEventListener("pointerup", this.#onUp, {
-			passive: false,
-			signal
-		});
-		globalThis.addEventListener("pointercancel", this.#onUp, {
-			passive: false,
-			signal
-		});
-		globalThis.addEventListener("blur", this.#onUp, {
-			passive: false,
-			signal
+	#u(e) {
+		globalThis.addEventListener("pointermove", this.#f, {
+			passive: !1,
+			signal: e
+		}), globalThis.addEventListener("pointerup", this.#p, {
+			passive: !1,
+			signal: e
+		}), globalThis.addEventListener("pointercancel", this.#p, {
+			passive: !1,
+			signal: e
+		}), globalThis.addEventListener("blur", this.#p, {
+			passive: !1,
+			signal: e
 		});
 	}
-	/**
-	* 清理当前会话状态（不负责解绑全局监听：由 signal 控制）
-	*/
-	#clearSession() {
-		this.#active = false;
-		this.#pointerId = void 0;
-	}
-	/**
-	* 全局 pointermove：
-	* - 只处理当前会话的 pointerId
-	* - 使用 coalesced events（若支持）取最后一个点作为最终坐标
-	* - 节流：在 throttle 时间窗内直接忽略
-	* - 去重：坐标未变化则忽略
-	*/
-	#onMove = (event) => {
-		if (!this.#active || !this.#onMoveCb) return;
-		if (event.pointerId !== this.#pointerId) return;
-		const coalesced = event.getCoalescedEvents?.();
-		const last = coalesced?.length ? coalesced[coalesced.length - 1] : event;
-		const now = performance.now();
-		const x = last.clientX;
-		const y = last.clientY;
-		if (x === this.#lastX && y === this.#lastY) {
-			event.preventDefault();
+	#d() {
+		this.#n = !1, this.#r = void 0;
+	}
+	#f = (e) => {
+		if (!this.#n || !this.#s || e.pointerId !== this.#r) return;
+		let t = e.getCoalescedEvents?.(), n = t?.length ? t[t.length - 1] : e, r = performance.now(), i = n.clientX, a = n.clientY;
+		if (i === this.#i && a === this.#a) {
+			e.preventDefault();
 			return;
 		}
-		this.#lastX = x;
-		this.#lastY = y;
-		this.#onMoveCb({
-			pointerId: event.pointerId,
-			x,
-			y,
-			event,
-			now
-		});
-		event.preventDefault();
+		this.#i = i, this.#a = a, this.#s({
+			pointerId: e.pointerId,
+			x: i,
+			y: a,
+			event: e,
+			now: r
+		}), e.preventDefault();
 	};
-	/**
-	* 全局 pointerup / pointercancel / blur：
-	* - blur 没有 pointerId，需要特殊处理
-	* - 先清理会话状态再回调，避免回调内副作用导致重入触发第二次 onUp
-	*/
-	#onUp = (event) => {
-		if (!this.#active || !this.#onUpCb) return;
-		if ("pointerId" in event && event.pointerId !== this.#pointerId) return;
-		const pointerId = this.#pointerId;
-		const reason = event.type;
-		this.#clearSession();
-		this.#onUpCb({
-			event,
-			pointerId,
-			reason
-		});
-		event.preventDefault?.();
+	#p = (e) => {
+		if (!this.#n || !this.#c || "pointerId" in e && e.pointerId !== this.#r) return;
+		let t = this.#r, n = e.type;
+		this.#d(), this.#c({
+			event: e,
+			pointerId: t,
+			reason: n
+		}), e.preventDefault?.();
 	};
-};
-//#endregion
-//#region src/core/FrameContext.js
-/**
-* FrameContext（帧上下文）
-*
-* 用于在每一帧中在各个插件之间共享的上下文数据。
-*
-* 插件约定：
-* - 只在 onMeasure 阶段读取 DOM（避免读写交错导致强制回流）
-* - 在 onCompute 阶段做纯计算（不触碰 DOM）
-* - 在 onCommit 阶段把 DOM 写操作通过 frame 入队（集中提交）
-*/
-var FrameContext = class {
-	scrolled = false;
+}, C = class {
+	scrolled = !1;
 	now = 0;
 	classOps = /* @__PURE__ */ new Map();
 	styleOps = /* @__PURE__ */ new Map();
 	appendOps = /* @__PURE__ */ new Map();
 	removeOps = /* @__PURE__ */ new Set();
 	fnOps = [];
-	/**
-	* 重置为新的一帧状态
-	* @param now 当前帧时间戳
-	*/
-	reset(now) {
-		this.now = now;
-		this.scrolled = false;
-		this.classOps.clear();
-		this.styleOps.clear();
-		this.appendOps.clear();
-		this.removeOps.clear();
-		this.fnOps.length = 0;
-	}
-	/**
-	* 记录一次 class toggle 操作（合并到队列中，last-write-wins）
-	*/
-	toggleClass(el, className, on) {
-		if (!el || !className) return;
-		if (this.removeOps.has(el)) return;
-		let m = this.classOps.get(el);
-		if (!m) {
-			m = /* @__PURE__ */ new Map();
-			this.classOps.set(el, m);
-		}
-		m.set(className, Boolean(on));
-	}
-	/**
-	* 记录一次 style 写操作（合并到队列中，last-write-wins）
-	*/
-	setStyle(el, prop, value) {
-		if (!el || !prop) return;
-		if (this.removeOps.has(el)) return;
-		let m = this.styleOps.get(el);
-		if (!m) {
-			m = /* @__PURE__ */ new Map();
-			this.styleOps.set(el, m);
-		}
-		m.set(prop, value);
-	}
-	/**
-	* 记录一次 append 操作（child 的归属 parent 以最后一次为准）
-	*/
-	append(parent, child) {
-		if (!parent || !child) return;
-		if (this.removeOps.has(child)) return;
-		this.appendOps.set(child, parent);
-	}
-	/**
-	* 记录一次 remove 操作（remove 优先级最高）
-	*/
-	remove(el) {
-		if (!el) return;
-		this.removeOps.add(el);
-		this.classOps.delete(el);
-		this.styleOps.delete(el);
-		this.appendOps.delete(el);
-	}
-	/**
-	* 记录一个待执行函数（保持顺序，允许重复）
-	*/
-	run(fn) {
-		if (typeof fn !== "function") return;
-		this.fnOps.push(fn);
-	}
-	/**
-	* 提交本帧所有操作（按固定顺序执行，尽量避免冲突）
-	*/
+	reset(e) {
+		this.now = e, this.scrolled = !1, this.classOps.clear(), this.styleOps.clear(), this.appendOps.clear(), this.removeOps.clear(), this.fnOps.length = 0;
+	}
+	toggleClass(e, t, n) {
+		if (!e || !t || this.removeOps.has(e)) return;
+		let r = this.classOps.get(e);
+		r || (r = /* @__PURE__ */ new Map(), this.classOps.set(e, r)), r.set(t, !!n);
+	}
+	setStyle(e, t, n) {
+		if (!e || !t || this.removeOps.has(e)) return;
+		let r = this.styleOps.get(e);
+		r || (r = /* @__PURE__ */ new Map(), this.styleOps.set(e, r)), r.set(t, n);
+	}
+	append(e, t) {
+		!e || !t || this.removeOps.has(t) || this.appendOps.set(t, e);
+	}
+	remove(e) {
+		e && (this.removeOps.add(e), this.classOps.delete(e), this.styleOps.delete(e), this.appendOps.delete(e));
+	}
+	run(e) {
+		typeof e == "function" && this.fnOps.push(e);
+	}
 	commit() {
-		for (const el of this.removeOps) el?.parentNode?.removeChild?.(el);
-		const hasRemovals = this.removeOps.size > 0;
-		for (const [child, parent] of this.appendOps) if (!hasRemovals || !this.removeOps.has(child) && !this.removeOps.has(parent)) parent?.appendChild?.(child);
-		for (const [el, classes] of this.classOps) if (!hasRemovals || !this.removeOps.has(el)) for (const [cls, on] of classes) if (on) el?.classList?.add?.(cls);
-		else el?.classList?.remove?.(cls);
-		for (const [el, styles] of this.styleOps) if (!hasRemovals || !this.removeOps.has(el)) {
-			for (const [prop, value] of styles) if (value === void 0 || value === null) {
-				if (prop.includes("-")) el?.style?.removeProperty?.(prop);
-				else if (el?.style) el.style[prop] = "";
-			} else if (prop.includes("-")) el?.style?.setProperty?.(prop, String(value));
-			else if (el?.style) el.style[prop] = value;
-		}
-		for (const fn of this.fnOps) fn?.();
+		for (let e of this.removeOps) e?.parentNode?.removeChild?.(e);
+		let e = this.removeOps.size > 0;
+		for (let [t, n] of this.appendOps) (!e || !this.removeOps.has(t) && !this.removeOps.has(n)) && n?.appendChild?.(t);
+		for (let [t, n] of this.classOps) if (!e || !this.removeOps.has(t)) for (let [e, r] of n) r ? t?.classList?.add?.(e) : t?.classList?.remove?.(e);
+		for (let [t, n] of this.styleOps) if (!e || !this.removeOps.has(t)) for (let [e, r] of n) r == null ? e.includes("-") ? t?.style?.removeProperty?.(e) : t?.style && (t.style[e] = "") : e.includes("-") ? t?.style?.setProperty?.(e, String(r)) : t?.style && (t.style[e] = r);
+		for (let e of this.fnOps) e?.();
 	}
-};
-//#endregion
-//#region src/core/PluginRuntime.js
-/**
-* PluginRuntime
-*
-* 插件运行时调度器：负责管理插件的注册、排序，以及在 DnD 生命周期内
-* 按顺序分发各阶段回调（onDown/onStart/onMeasure/onCompute/onCommit/onEnd...）。
-*
-* 设计要点：
-* 1) 插件按 order 升序执行（越小越早）。
-* 2) 所有回调都是可选的（?. 调用）。
-* 3) onAfterDrag 有返回值聚合逻辑：任一插件返回 true 或 { scrolled: true } 都视为发生了滚动。
-*/
-var PluginRuntime = class {
-	/**
-	* 已注册插件列表（内部私有）
-	* @type {Array<any>}
-	*/
-	#plugins = [];
-	/**
-	* 注册插件并排序，然后调用插件的 onAttach（用于做初始化、挂事件、扩展 dnd api 等）
-	*
-	* @param {any} plugin 插件实例（可包含 order、onAttach、各生命周期钩子）
-	* @param {any} dnd    Dnd 实例（传给插件做初始化）
-	*/
-	use(plugin, dnd) {
-		if (!plugin) return;
-		this.#plugins.push(plugin);
-		this.#plugins.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-		plugin.onAttach?.(dnd);
-	}
-	/**
-	* root 容器变更通知（比如 dnd.root 被替换）
-	* 插件可在此处重新绑定事件或做清理。
-	*
-	* @param {HTMLElement} nextRoot 新 root
-	* @param {HTMLElement} prevRoot 旧 root
-	* @param {AbortSignal} signal   用于自动解绑事件的 signal
-	*/
-	onRootChange(nextRoot, prevRoot, signal) {
-		for (const p of this.#plugins) p.onRootChange?.(nextRoot, prevRoot, signal);
-	}
-	/**
-	* pointer/mouse/touch 按下阶段（拖拽尚未开始）
-	* 通常用于：命中测试、准备 session、记录初始坐标等。
-	*
-	* @param {any} ctx   帧上下文/会话上下文
-	* @param {Event} event 原始事件对象
-	*/
-	onDown(ctx, event) {
-		for (const p of this.#plugins) p.onDown?.(ctx, event);
-	}
-	/**
-	* 真正开始拖拽（跨过 threshold / started=true）阶段
-	* 通常用于：创建 mirror、创建 indicator、更新选中态等。
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	*/
-	onStart(ctx) {
-		for (const p of this.#plugins) p.onStart?.(ctx);
-	}
-	/**
-	* Measure 阶段：只读测量（读 DOM）
-	* 通常用于：读取 rect、计算命中 drop、记录布局信息等。
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	*/
-	onMeasure(ctx) {
-		for (const p of this.#plugins) p.onMeasure?.(ctx);
-	}
-	/**
-	* Compute 阶段：纯计算（不写 DOM）
-	* 通常用于：根据 measure 的结果计算 region、allowed、snap 等。
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	*/
-	onCompute(ctx) {
-		for (const p of this.#plugins) p.onCompute?.(ctx);
-	}
-	/**
-	* Commit 阶段：写入（写 DOM）
-	* 通常用于：更新 class/style、移动 mirror、更新 indicator 形态等。
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	*/
-	onCommit(ctx) {
-		for (const p of this.#plugins) p.onCommit?.(ctx);
-	}
-	/**
-	* AfterDrag 阶段：拖拽过程中的后置处理（通常在 move 后）
-	* 用途：自动滚动（auto scroll）、边缘滚动等。
-	*
-	* 返回值聚合规则：
-	* - 任一插件返回 true 或 { scrolled: true } => 表示发生了滚动
-	* - 最终返回 scrolled（boolean）供上层决定是否需要额外刷新/下一帧等
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	* @returns {boolean} 是否发生滚动（或需要视为滚动）
-	*/
-	onAfterDrag(ctx) {
-		let scrolled = false;
-		for (const p of this.#plugins) {
-			const r = p.onAfterDrag?.(ctx);
-			if (r === true || r?.scrolled) scrolled = true;
+}, ee = class {
+	#e = [];
+	use(e, t) {
+		e && (this.#e.push(e), this.#e.sort((e, t) => (e.order ?? 0) - (t.order ?? 0)), e.onAttach?.(t));
+	}
+	onRootChange(e, t, n) {
+		for (let r of this.#e) r.onRootChange?.(e, t, n);
+	}
+	onDown(e, t) {
+		for (let n of this.#e) n.onDown?.(e, t);
+	}
+	onStart(e) {
+		for (let t of this.#e) t.onStart?.(e);
+	}
+	onMeasure(e) {
+		for (let t of this.#e) t.onMeasure?.(e);
+	}
+	onCompute(e) {
+		for (let t of this.#e) t.onCompute?.(e);
+	}
+	onCommit(e) {
+		for (let t of this.#e) t.onCommit?.(e);
+	}
+	onAfterDrag(e) {
+		let t = !1;
+		for (let n of this.#e) {
+			let r = n.onAfterDrag?.(e);
+			(r === !0 || r?.scrolled) && (t = !0);
 		}
-		return scrolled;
-	}
-	/**
-	* 拖拽结束阶段
-	* 通常用于：清理 DOM（mirror/indicator）、恢复样式、派发 drop 结果等。
-	*
-	* @param {any} ctx 帧上下文/会话上下文
-	* @param {any} meta 结束元信息（比如 drop 成功/取消、原因等）
-	*/
-	onEnd(ctx, meta) {
-		for (const p of this.#plugins) p.onEnd?.(ctx, meta);
-	}
-	/**
-	* Dnd 实例销毁阶段
-	* 通常用于：解绑事件、释放引用、兜底清理（防止中途销毁导致残留）。
-	*
-	* @param {any} dnd Dnd 实例
-	* @param {any} session 当前会话/monitor（用于清理残留 DOM）
-	*/
-	onDestroy(dnd, session) {
-		for (const p of this.#plugins) p.onDestroy?.(dnd, session);
-	}
-	/**
-	* 释放插件强引用，断开 plugin <-> dnd 之间的循环引用，便于 GC。
-	* 应该在 dnd.destroy() 末尾调用。
-	*/
+		return t;
+	}
+	onEnd(e, t) {
+		for (let n of this.#e) n.onEnd?.(e, t);
+	}
+	onDestroy(e, t) {
+		for (let n of this.#e) n.onDestroy?.(e, t);
+	}
 	dispose() {
-		this.#plugins.length = 0;
+		this.#e.length = 0;
 	}
-};
-//#endregion
-//#region src/core/State.js
-var State = class {
-	#store;
-	#session;
-	constructor({ store, session } = {}) {
-		this.#store = store;
-		this.#session = session;
+}, te = class {
+	#e;
+	#t;
+	constructor({ store: e, session: t } = {}) {
+		this.#e = e, this.#t = t;
 	}
 	get session() {
-		return this.#session;
+		return this.#t;
 	}
 	get store() {
-		return this.#store;
-	}
-	/**
-	* Dispatch an action to update session state.
-	* Returns small effects flags for the facade.
-	*/
-	dispatch(action) {
-		if (!action || !this.#session) return { handled: false };
-		switch (action.type) {
+		return this.#e;
+	}
+	dispatch(e) {
+		if (!e || !this.#t) return { handled: !1 };
+		switch (e.type) {
 			case "DOWN": {
-				if (this.#session.active) return { handled: false };
-				Object.assign(this.#session, {
-					active: true,
-					started: false,
-					dirty: false,
-					pointerId: action.pointerId,
-					startX: action.x,
-					startY: action.y,
-					x: action.x,
-					y: action.y,
-					prevX: action.x,
-					prevY: action.y,
+				if (this.#t.active) return { handled: !1 };
+				Object.assign(this.#t, {
+					active: !0,
+					started: !1,
+					dirty: !1,
+					pointerId: e.pointerId,
+					startX: e.x,
+					startY: e.y,
+					x: e.x,
+					y: e.y,
+					prevX: e.x,
+					prevY: e.y,
 					dx: 0,
 					dy: 0,
-					namespace: action.namespace,
-					data: action.data,
-					sourceEl: action.sourceEl,
-					handleEl: action.handleEl,
-					originDrop: action.originDrop,
+					namespace: e.namespace,
+					data: e.data,
+					sourceEl: e.sourceEl,
+					handleEl: e.handleEl,
+					originDrop: e.originDrop,
 					currentDrop: void 0,
 					currentDropRect: void 0,
-					isDragScope: Boolean(action.isDragScope),
-					isCopy: Boolean(action.isCopy),
-					mirrorOffsetX: action.mirrorOffsetX ?? 0,
-					mirrorOffsetY: action.mirrorOffsetY ?? 0,
+					isDragScope: !!e.isDragScope,
+					isCopy: !!e.isCopy,
+					mirrorOffsetX: e.mirrorOffsetX ?? 0,
+					mirrorOffsetY: e.mirrorOffsetY ?? 0,
 					lastMoveTs: 0
-				});
-				this.#session.dragAbort = new AbortController();
-				const { cache } = this.#session;
-				if (cache) {
-					cache.dropDataEl = void 0;
-					cache.dropDataRaw = void 0;
-					cache.dropDataParsed = void 0;
-					cache.hitDropFn = void 0;
-					cache.dropRectDirty = true;
-				}
-				return {
-					handled: true,
-					accepted: true,
-					dragAbort: this.#session.dragAbort
+				}), this.#t.dragAbort = new AbortController();
+				let { cache: t } = this.#t;
+				return t && (t.dropDataEl = void 0, t.dropDataRaw = void 0, t.dropDataParsed = void 0, t.hitDropFn = void 0, t.dropRectDirty = !0), {
+					handled: !0,
+					accepted: !0,
+					dragAbort: this.#t.dragAbort
 				};
 			}
 			case "MOVE": {
-				if (!this.#session.active || action.pointerId !== this.#session.pointerId) return { handled: false };
-				const nextX = action.x;
-				const nextY = action.y;
-				if (nextX === this.#session.x && nextY === this.#session.y) return {
-					handled: true,
-					moved: false
+				if (!this.#t.active || e.pointerId !== this.#t.pointerId) return { handled: !1 };
+				let t = e.x, n = e.y;
+				if (t === this.#t.x && n === this.#t.y) return {
+					handled: !0,
+					moved: !1
 				};
-				this.#session.prevX = this.#session.x;
-				this.#session.prevY = this.#session.y;
-				this.#session.x = nextX;
-				this.#session.y = nextY;
-				this.#session.dx = nextX - this.#session.startX;
-				this.#session.dy = nextY - this.#session.startY;
-				this.#session.dirty = true;
-				let startedNow = false;
-				if (!this.#session.started) {
-					if (Math.hypot(this.#session.dx, this.#session.dy) >= this.#session.threshold) {
-						this.#session.started = true;
-						startedNow = true;
-					}
-				}
-				return {
-					handled: true,
-					moved: true,
-					startedNow,
-					started: this.#session.started
+				this.#t.prevX = this.#t.x, this.#t.prevY = this.#t.y, this.#t.x = t, this.#t.y = n, this.#t.dx = t - this.#t.startX, this.#t.dy = n - this.#t.startY, this.#t.dirty = !0;
+				let r = !1;
+				return this.#t.started || Math.hypot(this.#t.dx, this.#t.dy) >= this.#t.threshold && (this.#t.started = !0, r = !0), {
+					handled: !0,
+					moved: !0,
+					startedNow: r,
+					started: this.#t.started
 				};
 			}
 			case "END": {
-				if (!this.#session.active) return { handled: false };
-				if (action.pointerId !== void 0 && action.pointerId !== this.#session.pointerId) return { handled: false };
-				const ended = Boolean(this.#session.started);
-				this.#session.active = false;
-				return {
-					handled: true,
-					ended,
-					reason: action.reason
+				if (!this.#t.active || e.pointerId !== void 0 && e.pointerId !== this.#t.pointerId) return { handled: !1 };
+				let t = !!this.#t.started;
+				return this.#t.active = !1, {
+					handled: !0,
+					ended: t,
+					reason: e.reason
 				};
 			}
-			default: return { handled: false };
-		}
-	}
-	/** Reset session after end/destroy, preserving store references. */
-	resetSession({ ended } = { ended: false }) {
-		const store = this.#store;
-		const prev = this.#session;
-		const next = createSession(store);
-		next.adapter = prev?.adapter;
-		if (ended) {
-			next.suppressNextClick = true;
-			next.lastDragTs = performance.now();
-		}
-		this.#session = next;
-		return next;
-	}
-};
-//#endregion
-//#region src/core/Dnd.js
-/**
-* Dnd Facade（对外门面）
-*
-* 设计目标：
-* - 内部拆分职责：sensor（输入采集）/ engine(state)（状态机）/ runtime（插件调度）
-*   / adapter（DOM 适配）/ scheduler（rAF 驱动）
-*/
-var Dnd = class extends EventDispatcher {
-	#abort = new AbortController();
-	#root;
-	#config;
-	#adapter = new DomAdapter();
-	#frame = new FrameContext();
-	#store = { selectedByNs: /* @__PURE__ */ new Map() };
-	#state;
-	#runtime = new PluginRuntime();
-	#scheduler;
-	#sensor;
-	#destroyed = false;
-	#frameCtx;
-	canDrop = () => true;
+			default: return { handled: !1 };
+		}
+	}
+	resetSession({ ended: e } = { ended: !1 }) {
+		let t = this.#e, n = this.#t, r = f(t);
+		return r.adapter = n?.adapter, e && (r.suppressNextClick = !0, r.lastDragTs = performance.now()), this.#t = r, r;
+	}
+}, w = class extends e {
+	#e = new AbortController();
+	#t;
+	#n;
+	#r = new b();
+	#i = new C();
+	#a = { selectedByNs: /* @__PURE__ */ new Map() };
+	#o;
+	#s = new ee();
+	#c;
+	#l;
+	#u = !1;
+	#d;
+	canDrop = () => !0;
 	renderMirror = void 0;
-	/** 当前 root */
 	get root() {
-		return this.#root;
+		return this.#t;
 	}
-	/** 对外暴露 monitor（当前 session），用于观察拖拽状态 */
 	get monitor() {
-		if (this.#destroyed) return void 0;
-		return this.#state?.session;
+		if (!this.#u) return this.#o?.session;
 	}
-	/** 是否已销毁（destroy 后只读） */
 	get destroyed() {
-		return this.#destroyed;
-	}
-	constructor(config = {}) {
-		super();
-		this.#config = { threshold: config.threshold ?? THRESHOLDS.DRAG_START };
-		const session = createSession(this.#store);
-		session.threshold = this.#config.threshold;
-		session.adapter = this.#adapter;
-		this.#state = new State({
-			store: this.#store,
-			session
-		});
-		this.#scheduler = new RafScheduler(this.#onFrame);
-		this.#sensor = new PointerSensor({
-			onDown: this.#onPointerDown,
-			onMove: this.#onPointerMove,
-			onUp: this.#onPointerUp
-		});
-		this.setRoot(config.root);
-	}
-	/**
-	* 注册插件（按 order 升序执行）
-	*/
-	use(plugin) {
-		if (!plugin) return this;
-		this.#runtime.use(plugin, this);
-		if (this.#root) plugin.onRootChange?.(this.#root, void 0, this.#abort.signal);
-		return this;
-	}
-	/**
-	* 设置/更换 root
-	* - 会 abort 旧 root 相关监听
-	* - 通知 sensor 绑定 root pointerdown
-	* - 通知 plugins root 变化
-	*/
-	setRoot(root) {
-		const nextRoot = this.#adapter.resolveRoot(root);
-		if (nextRoot === this.#root) return;
-		const prevRoot = this.#root;
-		this.#abort.abort();
-		this.#abort = new AbortController();
-		this.#root = nextRoot;
-		this.#sensor.setRoot(this.#root);
-		if (!this.#root) return;
-		this.#runtime.onRootChange(this.#root, prevRoot, this.#abort.signal);
-		this.#root.addEventListener("click", this.#onClickCapture, {
-			capture: true,
-			passive: false,
-			signal: this.#abort.signal
-		});
+		return this.#u;
+	}
+	constructor(e = {}) {
+		super(), this.#n = { threshold: e.threshold ?? a.DRAG_START };
+		let t = f(this.#a);
+		t.threshold = this.#n.threshold, t.adapter = this.#r, this.#o = new te({
+			store: this.#a,
+			session: t
+		}), this.#c = new x(this.#g), this.#l = new S({
+			onDown: this.#p,
+			onMove: this.#m,
+			onUp: this.#h
+		}), this.setRoot(e.root);
+	}
+	use(e) {
+		return e ? (this.#s.use(e, this), this.#t && e.onRootChange?.(this.#t, void 0, this.#e.signal), this) : this;
+	}
+	setRoot(e) {
+		let t = this.#r.resolveRoot(e);
+		if (t === this.#t) return;
+		let n = this.#t;
+		this.#e.abort(), this.#e = new AbortController(), this.#t = t, this.#l.setRoot(this.#t), this.#t && (this.#s.onRootChange(this.#t, n, this.#e.signal), this.#t.addEventListener("click", this.#f, {
+			capture: !0,
+			passive: !1,
+			signal: this.#e.signal
+		}));
 	}
-	/**
-	* 销毁：
-	* - 解绑 root 事件、停止 sensor
-	* - 停止 rAF
-	* - 结束活跃 session（不触发 drop/cancel 事件）
-	* - 通知插件销毁
-	* - 重置 session
-	*/
 	destroy() {
-		if (this.#destroyed) return;
-		this.#abort.abort();
-		this.#sensor.destroy();
-		this.#scheduler.cancel();
-		const monitor = this.#state.session;
-		if (monitor?.active) {
-			this.#runtime.onEnd(createContext({
-				dnd: this,
-				session: monitor,
-				store: this.#store,
-				frame: this.#frame,
-				adapter: this.#adapter
-			}), {
-				ended: false,
-				reason: "destroy"
-			});
-			monitor.dragAbort?.abort();
-		}
-		this.#runtime.onDestroy(this, monitor);
-		this.#runtime.dispose?.();
-		this.#frameCtx = void 0;
-		this.offAll();
-		this.#destroyed = true;
-	}
-	#onClickCapture = (e) => {
-		const m = this.#state?.session;
-		if (!m?.suppressNextClick) return;
-		const now = performance.now();
-		const withinWindow = !m.lastDragTs || now - m.lastDragTs < 800;
-		m.suppressNextClick = false;
-		if (!withinWindow) return;
-		e.preventDefault?.();
-		e.stopPropagation?.();
-		e.stopImmediatePropagation?.();
+		if (this.#u) return;
+		this.#e.abort(), this.#l.destroy(), this.#c.cancel();
+		let e = this.#o.session;
+		e?.active && (this.#s.onEnd(p({
+			dnd: this,
+			session: e,
+			store: this.#a,
+			frame: this.#i,
+			adapter: this.#r
+		}), {
+			ended: !1,
+			reason: "destroy"
+		}), e.dragAbort?.abort()), this.#s.onDestroy(this, e), this.#s.dispose?.(), this.#d = void 0, this.offAll(), this.#u = !0;
+	}
+	#f = (e) => {
+		let t = this.#o?.session;
+		if (!t?.suppressNextClick) return;
+		let n = performance.now(), r = !t.lastDragTs || n - t.lastDragTs < 800;
+		t.suppressNextClick = !1, r && (e.preventDefault?.(), e.stopPropagation?.(), e.stopImmediatePropagation?.());
 	};
-	/**
-	* pointerdown：
-	* - 校验 root、按键、handle、draggable
-	* - dispatch DOWN 到状态机
-	* - 执行插件 onDown（允许入队 DOM 写操作）
-	* - 返回给 sensor：accepted/pointerId/signal，用于建立会话监听
-	*/
-	#onPointerDown = (event) => {
-		if (!this.#root) return { accepted: false };
-		if (event.button !== 0) return { accepted: false };
-		const handle = matchHandle(event.target, this.#adapter);
-		if (!handle) return { accepted: false };
-		const draggable = this.#adapter.closestDraggable(handle);
-		if (!draggable) return { accepted: false };
-		if (event.target?.closest?.("input, textarea, select, button, a[href], [contenteditable]")) return { accepted: false };
-		event.preventDefault();
-		event.target?.setPointerCapture?.(event.pointerId);
-		const ns = this.#adapter.getNamespace(draggable);
-		const originDrop = this.#adapter.closestDrop(draggable);
-		const rect = draggable.getBoundingClientRect();
-		const data = parseData(this.#adapter.getAttr(draggable, ATTR.dataAttr));
-		if (!this.#state.dispatch({
+	#p = (e) => {
+		if (!this.#t || e.button !== 0) return { accepted: !1 };
+		let n = h(e.target, this.#r);
+		if (!n) return { accepted: !1 };
+		let r = this.#r.closestDraggable(n);
+		if (!r || e.target?.closest?.("input, textarea, select, button, a[href], [contenteditable]")) return { accepted: !1 };
+		e.preventDefault(), e.target?.setPointerCapture?.(e.pointerId);
+		let i = this.#r.getNamespace(r), a = this.#r.closestDrop(r), o = r.getBoundingClientRect(), s = u(this.#r.getAttr(r, t.dataAttr));
+		if (!this.#o.dispatch({
 			type: "DOWN",
-			pointerId: event.pointerId,
-			x: event.clientX,
-			y: event.clientY,
-			namespace: ns,
-			data,
-			sourceEl: draggable,
-			handleEl: handle,
-			originDrop,
-			isDragScope: Boolean(this.#adapter.closestDragScope(draggable)),
-			isCopy: Boolean(this.#adapter.getAttr(draggable, ATTR.copyAttr)),
-			mirrorOffsetX: event.clientX - rect.left,
-			mirrorOffsetY: event.clientY - rect.top
-		})?.accepted) return { accepted: false };
-		const monitor = this.#state.session;
-		monitor.threshold = this.#config.threshold;
-		monitor.adapter = this.#adapter;
-		this.#frame.reset(performance.now());
-		this.#adapter.beginFrame();
-		monitor.cache.frameId = this.#adapter.frameId;
-		const ctx = createContext({
+			pointerId: e.pointerId,
+			x: e.clientX,
+			y: e.clientY,
+			namespace: i,
+			data: s,
+			sourceEl: r,
+			handleEl: n,
+			originDrop: a,
+			isDragScope: !!this.#r.closestDragScope(r),
+			isCopy: !!this.#r.getAttr(r, t.copyAttr),
+			mirrorOffsetX: e.clientX - o.left,
+			mirrorOffsetY: e.clientY - o.top
+		})?.accepted) return { accepted: !1 };
+		let c = this.#o.session;
+		c.threshold = this.#n.threshold, c.adapter = this.#r, this.#i.reset(performance.now()), this.#r.beginFrame(), c.cache.frameId = this.#r.frameId;
+		let l = p({
 			dnd: this,
-			session: monitor,
-			store: this.#store,
-			frame: this.#frame,
-			adapter: this.#adapter
+			session: c,
+			store: this.#a,
+			frame: this.#i,
+			adapter: this.#r
 		});
-		this.#runtime.onDown(ctx, event);
-		this.#frame.commit();
-		this.#adapter.endFrame();
-		return {
-			accepted: true,
-			pointerId: event.pointerId,
-			signal: monitor.dragAbort.signal
+		return this.#s.onDown(l, e), this.#i.commit(), this.#r.endFrame(), {
+			accepted: !0,
+			pointerId: e.pointerId,
+			signal: c.dragAbort.signal
 		};
 	};
-	/**
-	* pointermove：
-	* - dispatch MOVE 到状态机（更新坐标、started/dirty 等）
-	* - startedNow：触发 onStart + emit dragstart
-	* - started：请求 rAF 进入 per-frame 驱动
-	*/
-	#onPointerMove = ({ pointerId, x, y }) => {
-		const effects = this.#state.dispatch({
+	#m = ({ pointerId: e, x: t, y: n }) => {
+		let r = this.#o.dispatch({
 			type: "MOVE",
-			pointerId,
-			x,
-			y
+			pointerId: e,
+			x: t,
+			y: n
 		});
-		if (!effects?.handled) return;
-		const monitor = this.#state.session;
-		if (effects.startedNow) {
-			const ctx = createContext({
+		if (!r?.handled) return;
+		let i = this.#o.session;
+		if (r.startedNow) {
+			let e = p({
 				dnd: this,
-				session: monitor,
-				store: this.#store,
-				frame: this.#frame,
-				adapter: this.#adapter
+				session: i,
+				store: this.#a,
+				frame: this.#i,
+				adapter: this.#r
 			});
-			this.#runtime.onStart(ctx);
-			this.emit("dragstart", createPayload("dragstart", monitor));
+			this.#s.onStart(e), this.emit("dragstart", d("dragstart", i));
 		}
-		if (effects.started) this.#scheduler.request();
+		r.started && this.#c.request();
 	};
-	/**
-	* pointerup / pointercancel / blur：
-	* - dispatch END 到状态机
-	* - 确保 drop 命中信息是最新的（避免最后一帧没跑）
-	* - 插件 onEnd 清理
-	* - 发出 drop/cancel 事件
-	* - abort 会话信号 & 重置 session
-	*/
-	#onPointerUp = ({ event, pointerId, reason }) => {
-		const effects = this.#state.dispatch({
+	#h = ({ event: e, pointerId: t, reason: n }) => {
+		let r = this.#o.dispatch({
 			type: "END",
-			pointerId,
-			reason
+			pointerId: t,
+			reason: n
 		});
-		if (!effects?.handled) return;
-		const monitor = this.#state.session;
-		if ("pointerId" in event) event.target?.releasePointerCapture?.(event.pointerId);
-		const ended = Boolean(effects.ended);
-		this.#adapter.beginFrame();
-		monitor.cache.frameId = this.#adapter.frameId;
-		monitor.currentDrop = this.#adapter.hitDropForSource(monitor.x, monitor.y, monitor.namespace, monitor.sourceEl);
-		monitor.currentDropRect = monitor.currentDrop ? this.#adapter.measureRect(monitor.currentDrop) : void 0;
-		this.#adapter.endFrame();
-		const ctx = createContext({
+		if (!r?.handled) return;
+		let i = this.#o.session;
+		"pointerId" in e && e.target?.releasePointerCapture?.(e.pointerId);
+		let a = !!r.ended;
+		this.#r.beginFrame(), i.cache.frameId = this.#r.frameId, i.currentDrop = this.#r.hitDropForSource(i.x, i.y, i.namespace, i.sourceEl), i.currentDropRect = i.currentDrop ? this.#r.measureRect(i.currentDrop) : void 0, this.#r.endFrame();
+		let o = p({
 			dnd: this,
-			session: monitor,
-			store: this.#store,
-			frame: this.#frame,
-			adapter: this.#adapter
+			session: i,
+			store: this.#a,
+			frame: this.#i,
+			adapter: this.#r
 		});
-		this.#runtime.onEnd(ctx, {
-			ended,
-			reason: reason || "pointerup"
+		this.#s.onEnd(o, {
+			ended: a,
+			reason: n || "pointerup"
 		});
-		const payload = createPayload(ended ? "drop" : "cancel", monitor);
-		monitor.dragAbort?.abort();
-		monitor.dragAbort = void 0;
-		this.#scheduler.cancel();
-		this.#frameCtx = void 0;
-		const next = this.#state.resetSession({ ended });
-		next.adapter = this.#adapter;
-		ended ? this.emit("drop", payload) : this.emit("cancel", payload);
-		event.preventDefault?.();
+		let s = d(a ? "drop" : "cancel", i);
+		i.dragAbort?.abort(), i.dragAbort = void 0, this.#c.cancel(), this.#d = void 0;
+		let c = this.#o.resetSession({ ended: a });
+		c.adapter = this.#r, a ? this.emit("drop", s) : this.emit("cancel", s), e.preventDefault?.();
 	};
-	/**
-	* 单帧 rAF 回调：
-	* - started 且 active 才会运行
-	* - 若 monitor.dirty：执行 measure/compute/commit，并 emit drag
-	* - afterDrag 钩子用于处理滚动/惯性等副作用
-	* - 返回 true 表示下一帧继续
-	*/
-	#onFrame = (now) => {
-		const monitor = this.#state.session;
-		if (!monitor.active || !monitor.started) return false;
-		this.#frame.reset(now);
-		this.#adapter.beginFrame();
-		monitor.cache.frameId = this.#adapter.frameId;
-		let ctx = this.#frameCtx;
-		if (!ctx || ctx.session !== monitor) ctx = this.#frameCtx = createContext({
+	#g = (e) => {
+		let t = this.#o.session;
+		if (!t.active || !t.started) return !1;
+		this.#i.reset(e), this.#r.beginFrame(), t.cache.frameId = this.#r.frameId;
+		let n = this.#d;
+		!n || n.session !== t ? n = this.#d = p({
 			dnd: this,
-			session: monitor,
-			store: this.#store,
-			frame: this.#frame,
-			adapter: this.#adapter
-		});
-		else ctx.resetPayloadCache();
-		let scrolled = false;
-		if (monitor.dirty) {
-			this.#runtime.onMeasure(ctx);
-			this.#runtime.onCompute(ctx);
-			this.emit("drag", ctx.payload("drag"));
-			this.#runtime.onCommit(ctx);
-			this.#frame.commit();
-			if (this.#frame.scrolled) scrolled = true;
-			monitor.dirty = false;
-		}
-		if (this.#runtime.onAfterDrag(ctx)) scrolled = true;
-		if (scrolled) monitor.dirty = true;
-		this.#adapter.endFrame();
-		return monitor.dirty || scrolled;
+			session: t,
+			store: this.#a,
+			frame: this.#i,
+			adapter: this.#r
+		}) : n.resetPayloadCache();
+		let r = !1;
+		return t.dirty &&= (this.#s.onMeasure(n), this.#s.onCompute(n), this.emit("drag", n.payload("drag")), this.#s.onCommit(n), this.#i.commit(), this.#i.scrolled && (r = !0), !1), this.#s.onAfterDrag(n) && (r = !0), r && (t.dirty = !0), this.#r.endFrame(), t.dirty || r;
 	};
-};
-//#endregion
-//#region src/services/DropService.js
-/**
-* DropService
-*
-* 目标：
-* - 在每一帧（onMeasure 阶段）保证 drop 命中信息的”单一事实来源”（single source of truth）
-* - 统一维护以下字段，避免多处重复计算/不一致：
-*   - monitor.currentDrop：当前命中的 drop 元素
-*   - monitor.currentDropRect：当前 drop 的测量矩形（DOMRect/自定义 rect）
-*   - monitor.currentAllowed：当前是否允许 drop（权威数据源）
-* - 统一维护 canDrop/视觉反馈：
-*   - 给 currentDrop 添加/移除 CLASS_NAMES.canDrop / CLASS_NAMES.noDrop
-*
-* 注意：
-* - order = 10，确保在其他依赖 drop 状态的服务（如 DropIndicatorService）之前执行
-* - currentAllowed 由本服务在 onCompute 阶段计算，其他服务应直接使用该值
-*/
-var DropService = class {
+}, T = class {
 	order = 10;
-	/**
-	* onMeasure：
-	* - 只做 DOM 读取/测量相关工作（命中测试、measureRect）
-	* - 负责在每帧更新 currentDrop / currentDropRect
-	*/
-	onMeasure(ctx) {
-		const m = ctx.session;
-		if (!m.active || !m.started) return;
-		const drop = ctx.adapter.hitDropForSource(m.x, m.y, m.namespace, m.sourceEl);
-		if (drop !== m.currentDrop) {
-			m.currentDrop = drop;
-			if (m.cache) m.cache.dropRectDirty = true;
-		}
-		if (!drop) {
-			m.currentDropRect = void 0;
-			if (m.cache) m.cache.dropRectDirty = false;
+	onMeasure(e) {
+		let t = e.session;
+		if (!t.active || !t.started) return;
+		let n = e.adapter.hitDropForSource(t.x, t.y, t.namespace, t.sourceEl);
+		if (n !== t.currentDrop && (t.currentDrop = n, t.cache && (t.cache.dropRectDirty = !0)), !n) {
+			t.currentDropRect = void 0, t.cache && (t.cache.dropRectDirty = !1);
 			return;
 		}
-		if (m.cache?.dropRectDirty || !m.currentDropRect) {
-			m.currentDropRect = ctx.adapter.measureRect(drop);
-			m.cache.dropRectDirty = false;
-		}
+		(t.cache?.dropRectDirty || !t.currentDropRect) && (t.currentDropRect = e.adapter.measureRect(n), t.cache.dropRectDirty = !1);
 	}
-	/**
-	* onCompute：
-	* - 计算当前 drop 是否允许（dnd.canDrop(payload)）
-	* - 只写 session，不写 DOM
-	* - 这是 currentAllowed 的权威计算点，其他服务应直接使用该值
-	*/
-	onCompute(ctx) {
-		const m = ctx.session;
-		if (!m.active || !m.started) return;
-		if (!m.currentDrop) {
-			m.currentAllowed = false;
+	onCompute(e) {
+		let t = e.session;
+		if (!t.active || !t.started) return;
+		if (!t.currentDrop) {
+			t.currentAllowed = !1;
 			return;
 		}
-		const fn = ctx.dnd?.canDrop;
-		if (typeof fn !== "function") {
-			m.currentAllowed = true;
+		let n = e.dnd?.canDrop;
+		if (typeof n != "function") {
+			t.currentAllowed = !0;
 			return;
 		}
 		try {
-			m.currentAllowed = !!fn(ctx.payload("drag"));
+			t.currentAllowed = !!n(e.payload("drag"));
 		} catch {
-			m.currentAllowed = false;
+			t.currentAllowed = !1;
 		}
 	}
-	/**
-	* onCommit：
-	* - 根据 currentDrop/currentAllowed 写入 drop 的 class
-	*/
-	onCommit(ctx) {
-		const m = ctx.session;
-		if (!m?.active || !m?.started) return;
-		const cache = m.cache || (m.cache = {});
-		const prev = cache._dropClassEl;
-		const cur = m.currentDrop;
-		if (isHTMLElement(prev) && prev !== cur) {
-			ctx.frame.toggleClass(prev, CLASS_NAMES.canDrop, false);
-			ctx.frame.toggleClass(prev, CLASS_NAMES.noDrop, false);
-		}
-		if (isHTMLElement(cur)) {
-			ctx.frame.toggleClass(cur, CLASS_NAMES.canDrop, !!m.currentAllowed);
-			ctx.frame.toggleClass(cur, CLASS_NAMES.noDrop, !m.currentAllowed);
-		}
-		cache._dropClassEl = cur;
+	onCommit(e) {
+		let t = e.session;
+		if (!t?.active || !t?.started) return;
+		let r = t.cache ||= {}, i = r._dropClassEl, a = t.currentDrop;
+		g(i) && i !== a && (e.frame.toggleClass(i, n.canDrop, !1), e.frame.toggleClass(i, n.noDrop, !1)), g(a) && (e.frame.toggleClass(a, n.canDrop, !!t.currentAllowed), e.frame.toggleClass(a, n.noDrop, !t.currentAllowed)), r._dropClassEl = a;
 	}
-	onEnd(ctx) {
-		const m = ctx?.session;
-		if (!m) return;
-		const prev = m.cache?._dropClassEl;
-		if (isHTMLElement(prev)) prev.classList.remove(CLASS_NAMES.canDrop, CLASS_NAMES.noDrop);
-		if (m.cache) m.cache._dropClassEl = void 0;
+	onEnd(e) {
+		let t = e?.session;
+		if (!t) return;
+		let r = t.cache?._dropClassEl;
+		g(r) && r.classList.remove(n.canDrop, n.noDrop), t.cache && (t.cache._dropClassEl = void 0);
 	}
-	onDestroy(_dnd, session) {
-		this.onEnd({ session });
+	onDestroy(e, t) {
+		this.onEnd({ session: t });
 	}
-};
-//#endregion
-//#region src/services/MirrorService.js
-var MirrorService = class {
+}, E = class {
 	order = 0;
-	onStart = (ctx) => {
-		const s = ctx?.session;
-		if (!s?.sourceEl || s.mirrorEl) return;
-		s.sourceEl.classList.add(CLASS_NAMES.dragging);
-		if (s.sourceEl.hasAttribute?.(ATTR.ignoreMirrorAttr)) return;
-		const rect = ctx.adapter.measureRect(s.sourceEl);
-		const m = typeof ctx?.dnd?.renderMirror === "function" ? ctx.dnd.renderMirror(ctx) : s.sourceEl.cloneNode(true);
-		if (!(m instanceof HTMLElement)) return;
-		m.setAttribute(ATTR.ignoreMirrorAttr, "");
-		m.classList.add(CLASS_NAMES.mirror);
-		Object.assign(m.style, {
-			width: `${rect.width}px`,
-			height: `${rect.height}px`,
+	onStart = (e) => {
+		let r = e?.session;
+		if (!r?.sourceEl || r.mirrorEl || (r.sourceEl.classList.add(n.dragging), r.sourceEl.hasAttribute?.(t.ignoreMirrorAttr))) return;
+		let i = e.adapter.measureRect(r.sourceEl), a = typeof e?.dnd?.renderMirror == "function" ? e.dnd.renderMirror(e) : r.sourceEl.cloneNode(!0);
+		a instanceof HTMLElement && (a.setAttribute(t.ignoreMirrorAttr, ""), a.classList.add(n.mirror), Object.assign(a.style, {
+			width: `${i.width}px`,
+			height: `${i.height}px`,
 			position: "fixed"
-		});
-		(ctx.dnd?.root || document.body).appendChild(m);
-		s.mirrorEl = m;
+		}), (e.dnd?.root || document.body).appendChild(a), r.mirrorEl = a);
 	};
-	onCommit = (ctx) => {
-		const s = ctx?.session;
-		if (!s?.active || !s.started) return;
-		if (s.mirrorEl) {
-			const x = s.x - (s.mirrorOffsetX || 0);
-			const y = s.y - (s.mirrorOffsetY || 0);
-			ctx.frame.setStyle(s.mirrorEl, "transform", `translate3d(${x}px, ${y}px, 0)`);
+	onCommit = (e) => {
+		let t = e?.session;
+		if (!(!t?.active || !t.started) && t.mirrorEl) {
+			let n = t.x - (t.mirrorOffsetX || 0), r = t.y - (t.mirrorOffsetY || 0);
+			e.frame.setStyle(t.mirrorEl, "transform", `translate3d(${n}px, ${r}px, 0)`);
 		}
 	};
-	onEnd = (ctx) => {
-		const s = ctx?.session;
-		if (!s) return;
-		if (s.mirrorEl) {
-			s.mirrorEl.remove();
-			s.mirrorEl = void 0;
-		}
-		s.sourceEl?.classList.remove(CLASS_NAMES.dragging);
+	onEnd = (e) => {
+		let t = e?.session;
+		t && (t.mirrorEl &&= (t.mirrorEl.remove(), void 0), t.sourceEl?.classList.remove(n.dragging));
 	};
-	onDestroy = (_dnd, session) => {
-		this.onEnd({ session });
+	onDestroy = (e, t) => {
+		this.onEnd({ session: t });
 	};
-};
-//#endregion
-//#region src/services/AutoScrollService.js
-var OVERFLOW_RE = /(auto|scroll|overlay)/i;
-function isScrollable(el) {
-	if (!(el instanceof HTMLElement)) return false;
-	const s = getComputedStyle(el);
-	const oy = OVERFLOW_RE.test(s.overflowY) && el.scrollHeight > el.clientHeight + 1;
-	return OVERFLOW_RE.test(s.overflowX) && el.scrollWidth > el.clientWidth + 1 || oy;
+}, D = /(auto|scroll|overlay)/i;
+function ne(e) {
+	if (!(e instanceof HTMLElement)) return !1;
+	let t = getComputedStyle(e), n = D.test(t.overflowY) && e.scrollHeight > e.clientHeight + 1;
+	return D.test(t.overflowX) && e.scrollWidth > e.clientWidth + 1 || n;
 }
-function findScrollTarget(fromEl) {
-	let el = fromEl;
-	while (el) {
-		if (isScrollable(el)) return el;
-		el = el.parentElement;
+function re(e) {
+	let t = e;
+	for (; t;) {
+		if (ne(t)) return t;
+		t = t.parentElement;
 	}
 }
-function edgePlan(p, start, end, edge) {
-	if (p < start + edge) return {
+function O(e, t, n, r) {
+	return e < t + r ? {
 		dir: -1,
-		k: (start + edge - p) / edge
-	};
-	if (p > end - edge) return {
+		k: (t + r - e) / r
+	} : e > n - r ? {
 		dir: 1,
-		k: (p - (end - edge)) / edge
-	};
-	return {
+		k: (e - (n - r)) / r
+	} : {
 		dir: 0,
 		k: 0
 	};
 }
-var AutoScrollService = class {
+var ie = class {
 	order = 1e4;
-	constructor(opts = {}) {
-		this.edge = opts.edge ?? AUTO_SCROLL.EDGE;
-		this.minSpeed = opts.minSpeed ?? AUTO_SCROLL.MIN_SPEED;
-		this.maxSpeed = opts.maxSpeed ?? AUTO_SCROLL.MAX_SPEED;
-		this.allowWindowScroll = opts.allowWindowScroll ?? true;
-	}
-	onAfterDrag = (ctx) => {
-		const s = ctx.session;
-		if (!s.active || !s.started) return false;
-		const cache = s.cache;
-		let targetEl;
-		let useWindow;
-		if (cache && cache.autoScrollTargetDrop === s.currentDrop) {
-			targetEl = cache.autoScrollTarget;
-			useWindow = cache.autoScrollUseWindow;
-		} else {
-			targetEl = s.currentDrop ? findScrollTarget(s.currentDrop) : void 0;
-			useWindow = false;
-			if (!targetEl && this.allowWindowScroll) {
-				targetEl = document.scrollingElement || document.documentElement;
-				useWindow = !!targetEl;
-			}
-			if (cache) {
-				cache.autoScrollTargetDrop = s.currentDrop;
-				cache.autoScrollTarget = targetEl;
-				cache.autoScrollUseWindow = useWindow;
-			}
-		}
-		if (!targetEl) return false;
-		const now = ctx.frame.now;
-		const last = s.cache.autoScrollLastTs || 0;
-		const dt = last ? Math.max(AUTO_SCROLL.MIN_DT, Math.min(AUTO_SCROLL.MAX_DT, now - last)) : AUTO_SCROLL.DEFAULT_DT;
-		if (s.cache) s.cache.autoScrollLastTs = now;
-		const rect = useWindow ? {
+	constructor(e = {}) {
+		this.edge = e.edge ?? o.EDGE, this.minSpeed = e.minSpeed ?? o.MIN_SPEED, this.maxSpeed = e.maxSpeed ?? o.MAX_SPEED, this.allowWindowScroll = e.allowWindowScroll ?? !0;
+	}
+	onAfterDrag = (e) => {
+		let t = e.session;
+		if (!t.active || !t.started) return !1;
+		let n = t.cache, r, i;
+		if (n && n.autoScrollTargetDrop === t.currentDrop ? (r = n.autoScrollTarget, i = n.autoScrollUseWindow) : (r = t.currentDrop ? re(t.currentDrop) : void 0, i = !1, !r && this.allowWindowScroll && (r = document.scrollingElement || document.documentElement, i = !!r), n && (n.autoScrollTargetDrop = t.currentDrop, n.autoScrollTarget = r, n.autoScrollUseWindow = i)), !r) return !1;
+		let a = e.frame.now, s = t.cache.autoScrollLastTs || 0, c = s ? Math.max(o.MIN_DT, Math.min(o.MAX_DT, a - s)) : o.DEFAULT_DT;
+		t.cache && (t.cache.autoScrollLastTs = a);
+		let l = i ? {
 			left: 0,
 			top: 0,
 			right: innerWidth,
 			bottom: innerHeight
-		} : ctx.adapter.measureRect(targetEl);
-		const px = s.x, py = s.y;
-		const ex = edgePlan(px, rect.left, rect.right, this.edge);
-		const ey = edgePlan(py, rect.top, rect.bottom, this.edge);
-		const speed = (k) => this.minSpeed + (this.maxSpeed - this.minSpeed) * k;
-		const dx = ex.dir ? ex.dir * speed(ex.k) * dt / 1e3 : 0;
-		const dy = ey.dir ? ey.dir * speed(ey.k) * dt / 1e3 : 0;
-		if (!dx && !dy) return false;
-		const beforeTop = targetEl.scrollTop, beforeLeft = targetEl.scrollLeft;
-		if (useWindow) window.scrollBy(dx, dy);
-		else targetEl.scrollBy({
-			left: dx,
-			top: dy,
+		} : e.adapter.measureRect(r), u = t.x, d = t.y, f = O(u, l.left, l.right, this.edge), p = O(d, l.top, l.bottom, this.edge), m = (e) => this.minSpeed + (this.maxSpeed - this.minSpeed) * e, h = f.dir ? f.dir * m(f.k) * c / 1e3 : 0, g = p.dir ? p.dir * m(p.k) * c / 1e3 : 0;
+		if (!h && !g) return !1;
+		let _ = r.scrollTop, v = r.scrollLeft;
+		i ? window.scrollBy(h, g) : r.scrollBy({
+			left: h,
+			top: g,
 			behavior: "auto"
 		});
-		const scrolled = beforeTop !== targetEl.scrollTop || beforeLeft !== targetEl.scrollLeft;
-		if (scrolled && ctx.frame) ctx.frame.scrolled = true;
-		return scrolled;
+		let y = _ !== r.scrollTop || v !== r.scrollLeft;
+		return y && e.frame && (e.frame.scrolled = !0), y;
 	};
-	onEnd = (ctx) => {
-		const s = ctx?.session;
-		if (s?.cache) {
-			s.cache.autoScrollLastTs = 0;
-			s.cache.autoScrollTargetDrop = void 0;
-			s.cache.autoScrollTarget = void 0;
-			s.cache.autoScrollUseWindow = false;
-		}
+	onEnd = (e) => {
+		let t = e?.session;
+		t?.cache && (t.cache.autoScrollLastTs = 0, t.cache.autoScrollTargetDrop = void 0, t.cache.autoScrollTarget = void 0, t.cache.autoScrollUseWindow = !1);
 	};
-};
-//#endregion
-//#region src/services/DropIndicatorService.js
-var REGION_CLS = {
-	top: CLASS_NAMES.indicatorTop,
-	right: CLASS_NAMES.indicatorRight,
-	bottom: CLASS_NAMES.indicatorBottom,
-	left: CLASS_NAMES.indicatorLeft
-};
-var REGION_LIST = Object.values(REGION_CLS);
-var VALID = /* @__PURE__ */ new Set([
+}, k = {
+	top: n.indicatorTop,
+	right: n.indicatorRight,
+	bottom: n.indicatorBottom,
+	left: n.indicatorLeft
+}, A = Object.values(k), j = /* @__PURE__ */ new Set([
 	"top",
 	"right",
 	"bottom",
 	"left"
 ]);
-function toggle(ctx, el, cls, on) {
-	if (!isHTMLElement(el)) return;
-	ctx.frame.toggleClass(el, cls, !!on);
+function M(e, t, n, r) {
+	g(t) && e.frame.toggleClass(t, n, !!r);
 }
-function parseSupport(dropEl) {
-	if (!isHTMLElement(dropEl)) return;
-	const name = ATTR.dropIndicatorAttr || "drop-indicator";
-	const dataName = `data-${name}`;
-	let raw = void 0;
-	if (dropEl.hasAttribute?.(name)) raw = dropEl.getAttribute?.(name);
-	else if (dropEl.hasAttribute?.(dataName)) raw = dropEl.getAttribute?.(dataName);
+function N(e) {
+	if (!g(e)) return;
+	let n = t.dropIndicatorAttr || "drop-indicator", r = `data-${n}`, i;
+	if (e.hasAttribute?.(n)) i = e.getAttribute?.(n);
+	else if (e.hasAttribute?.(r)) i = e.getAttribute?.(r);
 	else return;
-	const text = (raw ?? "").trim();
-	if (!text) return "all";
-	const set = /* @__PURE__ */ new Set();
-	for (const p of text.split(/[,\s]+/)) {
-		const k = (p || "").trim().toLowerCase();
-		if (VALID.has(k)) set.add(k);
-	}
-	return set.size ? set : void 0;
+	let a = (i ?? "").trim();
+	if (!a) return "all";
+	let o = /* @__PURE__ */ new Set();
+	for (let e of a.split(/[,\s]+/)) {
+		let t = (e || "").trim().toLowerCase();
+		j.has(t) && o.add(t);
+	}
+	return o.size ? o : void 0;
 }
-function getSupport(ctx, dropEl) {
-	const cache = ctx.session?.cache;
-	if (!cache) return parseSupport(dropEl);
-	if (cache.indicatorSupportEl === dropEl) return cache.indicatorSupport;
-	const support = parseSupport(dropEl);
-	cache.indicatorSupportEl = dropEl;
-	cache.indicatorSupport = support;
-	return support;
+function ae(e, t) {
+	let n = e.session?.cache;
+	if (!n) return N(t);
+	if (n.indicatorSupportEl === t) return n.indicatorSupport;
+	let r = N(t);
+	return n.indicatorSupportEl = t, n.indicatorSupport = r, r;
 }
-function ensureIndicator(ctx) {
-	const m = ctx.session;
-	const doc = ctx.dnd?.root?.ownerDocument || document;
-	let el = m.indicatorEl;
-	if (!isHTMLElement(el)) {
-		el = doc.createElement("div");
-		el.classList.add(CLASS_NAMES.dropIndicator);
-		m.indicatorEl = el;
-	}
-	const parent = m.currentDrop || ctx.dnd?.root || doc.body;
-	if (isHTMLElement(parent) && el.parentNode !== parent) parent.appendChild(el);
-	return el;
+function oe(e) {
+	let t = e.session, r = e.dnd?.root?.ownerDocument || document, i = t.indicatorEl;
+	g(i) || (i = r.createElement("div"), i.classList.add(n.dropIndicator), t.indicatorEl = i);
+	let a = t.currentDrop || e.dnd?.root || r.body;
+	return g(a) && i.parentNode !== a && a.appendChild(i), i;
 }
-function computeRegion(m, support) {
-	if (!m.currentDrop || !m.currentDropRect) return;
-	const f = computeDropRegion(m, support);
-	if (f.isOverLeft()) return "left";
-	if (f.isOverRight()) return "right";
-	if (f.isOverTop()) return "top";
-	if (f.isOverBottom()) return "bottom";
+function se(e, t) {
+	if (!e.currentDrop || !e.currentDropRect) return;
+	let n = l(e, t);
+	if (n.isOverLeft()) return "left";
+	if (n.isOverRight()) return "right";
+	if (n.isOverTop()) return "top";
+	if (n.isOverBottom()) return "bottom";
 }
-/**
-* 获取当前 drop 是否允许
-* 优先使用 DropService 已计算的 currentAllowed
-* 这样避免重复计算，保持单一数据源
-*/
-function resolveAllowed(ctx) {
-	const m = ctx.session;
-	if (!m.currentDrop) return false;
-	if (typeof m.currentAllowed === "boolean") return m.currentAllowed;
-	return true;
+function ce(e) {
+	let t = e.session;
+	return t.currentDrop ? typeof t.currentAllowed == "boolean" ? t.currentAllowed : !0 : !1;
 }
-var DropIndicatorService = class {
+var le = class {
 	order = 40;
-	onCommit(ctx) {
-		const m = ctx.session;
-		if (!m?.active || !m?.started) return;
-		const drop = m.currentDrop;
-		const support = getSupport(ctx, drop);
-		if (!support) {
-			const ind = m.indicatorEl;
-			if (isHTMLElement(ind)) {
-				toggle(ctx, ind, CLASS_NAMES.dropIndicatorActive, false);
-				for (const c of REGION_LIST) toggle(ctx, ind, c, false);
+	onCommit(e) {
+		let t = e.session;
+		if (!t?.active || !t?.started) return;
+		let r = t.currentDrop, i = ae(e, r);
+		if (!i) {
+			let r = t.indicatorEl;
+			if (g(r)) {
+				M(e, r, n.dropIndicatorActive, !1);
+				for (let t of A) M(e, r, t, !1);
 			}
-			m.indicatorRegion = void 0;
+			t.indicatorRegion = void 0;
 			return;
 		}
-		const ind = ensureIndicator(ctx);
-		const allowed = resolveAllowed(ctx);
-		const region = computeRegion(m, support);
-		const okRegion = support === "all" ? region : region && support.has(region) ? region : void 0;
-		const show = !!(drop && m.currentDropRect && allowed && okRegion);
-		toggle(ctx, ind, CLASS_NAMES.dropIndicatorActive, show);
-		m.indicatorRegion = show ? okRegion : void 0;
-		if (!show) for (const c of REGION_LIST) toggle(ctx, ind, c, false);
-		else for (const [r, c] of Object.entries(REGION_CLS)) toggle(ctx, ind, c, r === okRegion);
-	}
-	onEnd(ctx) {
-		const m = ctx.session;
-		if (!m) return;
-		m.lastIndicatorRegion = m.indicatorRegion ?? "inside";
-		if (isHTMLElement(m.indicatorEl)) m.indicatorEl.remove();
-		m.indicatorEl = void 0;
-		m.indicatorRegion = void 0;
-	}
-	onDestroy(_dnd, session) {
-		this.onEnd({ session });
+		let a = oe(e), o = ce(e), s = se(t, i), c = i === "all" || s && i.has(s) ? s : void 0, l = !!(r && t.currentDropRect && o && c);
+		if (M(e, a, n.dropIndicatorActive, l), t.indicatorRegion = l ? c : void 0, l) for (let [t, n] of Object.entries(k)) M(e, a, n, t === c);
+		else for (let t of A) M(e, a, t, !1);
 	}
-};
-//#endregion
-//#region src/services/ActiveSelectionService.js
-var ACTIVE_WRAP_CLASS = "draggable-dot-wrap";
-var DOT_CLASS = "draggable-dot";
-var ROTATE_CLASS = "draggable-rotate";
-function buildWrap(doc, opt = {}) {
-	const { resizable = true, rotatable = true } = opt;
-	const wrap = doc.createElement("div");
-	wrap.classList.add(ACTIVE_WRAP_CLASS);
-	wrap.dataset.resizable = String(resizable);
-	wrap.dataset.rotatable = String(rotatable);
-	if (resizable) for (const [dir, pos] of [
+	onEnd(e) {
+		let t = e.session;
+		t && (t.lastIndicatorRegion = t.indicatorRegion ?? "inside", g(t.indicatorEl) && t.indicatorEl.remove(), t.indicatorEl = void 0, t.indicatorRegion = void 0);
+	}
+	onDestroy(e, t) {
+		this.onEnd({ session: t });
+	}
+}, P = "draggable-dot-wrap", F = "draggable-dot", I = "draggable-rotate";
+function ue(e, n = {}) {
+	let { resizable: r = !0, rotatable: i = !0 } = n, a = e.createElement("div");
+	if (a.classList.add(P), a.dataset.resizable = String(r), a.dataset.rotatable = String(i), r) for (let [n, r] of [
 		["nw", "tl"],
 		["n", "tm"],
 		["ne", "tr"],
@@ -1717,394 +981,255 @@ function buildWrap(doc, opt = {}) {
 		["sw", "bl"],
 		["w", "lm"]
 	]) {
-		const dot = doc.createElement("div");
-		dot.classList.add(DOT_CLASS);
-		dot.setAttribute(ATTR.handleResizeAttr, "");
-		dot.dataset.dir = dir;
-		dot.dataset.pos = pos;
-		wrap.appendChild(dot);
-	}
-	if (rotatable) {
-		const rotate = doc.createElement("div");
-		rotate.classList.add(ROTATE_CLASS);
-		rotate.setAttribute(ATTR.handleRotateAttr, "");
-		rotate.dataset.dir = "rotate";
-		wrap.appendChild(rotate);
-	}
-	return wrap;
+		let i = e.createElement("div");
+		i.classList.add(F), i.setAttribute(t.handleResizeAttr, ""), i.dataset.dir = n, i.dataset.pos = r, a.appendChild(i);
+	}
+	if (i) {
+		let n = e.createElement("div");
+		n.classList.add(I), n.setAttribute(t.handleRotateAttr, ""), n.dataset.dir = "rotate", a.appendChild(n);
+	}
+	return a;
 }
-function removeWrap(el) {
-	if (!isHTMLElement(el)) return;
-	el.querySelector?.(`.${ACTIVE_WRAP_CLASS}`)?.remove();
+function L(e) {
+	g(e) && e.querySelector?.(`.${P}`)?.remove();
 }
-function ensureWrapIfScoped(el) {
-	if (!isHTMLElement(el)) return;
-	const scoped = !!el.closest?.(SCOPE_SEL);
-	let existedWrap = el.querySelector?.(`.draggable-dot-wrap`) || null;
-	let hasWrap = !!existedWrap;
-	const resizable = isToggleEnabled(el, ATTR.resizableAttr, true);
-	const rotatable = isToggleEnabled(el, ATTR.rotatableAttr, true);
-	const needWrap = resizable || rotatable;
-	if (!scoped) {
-		if (hasWrap) removeWrap(el);
+function R(e) {
+	if (!g(e)) return;
+	let n = !!e.closest?.(y), r = e.querySelector?.(".draggable-dot-wrap") || null, i = !!r, a = m(e, t.resizableAttr, !0), o = m(e, t.rotatableAttr, !0), s = a || o;
+	if (!n) {
+		i && L(e);
 		return;
 	}
-	if (!needWrap) {
-		if (hasWrap) removeWrap(el);
+	if (!s) {
+		i && L(e);
 		return;
 	}
-	if (!!existedWrap && (String(existedWrap.dataset?.resizable) !== String(resizable) || String(existedWrap.dataset?.rotatable) !== String(rotatable))) {
-		existedWrap.remove();
-		existedWrap = null;
-		hasWrap = false;
-	}
-	if (!hasWrap) {
-		const pos = getComputedStyle(el).position;
-		if (pos === "static" || !pos) el.style.position = "relative";
-		el.appendChild(buildWrap(el.ownerDocument || document, {
-			resizable,
-			rotatable
+	if (r && (String(r.dataset?.resizable) !== String(a) || String(r.dataset?.rotatable) !== String(o)) && (r.remove(), r = null, i = !1), !i) {
+		let t = getComputedStyle(e).position;
+		(t === "static" || !t) && (e.style.position = "relative"), e.appendChild(ue(e.ownerDocument || document, {
+			resizable: a,
+			rotatable: o
 		}));
 	}
 }
-/**
-* 清理一个选中值（可能是数组[多选]或单个元素）：移除 active class + wrap。
-* toggleFn 可选：若传入则走帧队列（ctx.frame.toggleClass），否则直接 classList。
-*/
-function clearSelectionValue(value, toggleFn) {
-	if (!value) return;
-	const els = Array.isArray(value) ? value : [value];
-	for (const el of els) {
-		if (toggleFn) toggleFn(el, CLASS_NAMES.active, false);
-		else el?.classList?.remove?.(CLASS_NAMES.active);
-		removeWrap(el);
-	}
+function z(e, t) {
+	if (!e) return;
+	let r = Array.isArray(e) ? e : [e];
+	for (let e of r) t ? t(e, n.active, !1) : e?.classList?.remove?.(n.active), L(e);
 }
-function setActiveWithWrap(ctx, map, dragEl, ns) {
-	const prev = map.get(ns);
-	if (prev && prev !== dragEl) clearSelectionValue(prev);
-	dragEl.classList.add(CLASS_NAMES.active);
-	ensureWrapIfScoped(dragEl);
-	map.set(ns, dragEl);
+function B(e, t, r, i) {
+	let a = t.get(i);
+	a && a !== r && z(a), r.classList.add(n.active), R(r), t.set(i, r);
 }
-function setMultipleActive(map, elements, ns) {
-	clearSelectionValue(map.get(ns));
-	for (const el of elements) {
-		el.classList.add(CLASS_NAMES.active);
-		ensureWrapIfScoped(el);
-	}
-	map.set(ns, elements);
+function V(e, t, r) {
+	z(e.get(r));
+	for (let e of t) e.classList.add(n.active), R(e);
+	e.set(r, t);
 }
-function clearAll(map, namespace) {
-	if (namespace !== void 0) {
-		const val = map.get(namespace);
-		if (val) {
-			clearSelectionValue(val);
-			map.delete(namespace);
-		}
+function H(e, t) {
+	if (t !== void 0) {
+		let n = e.get(t);
+		n && (z(n), e.delete(t));
 		return;
 	}
-	for (const val of map.values()) clearSelectionValue(val);
-	map.clear();
+	for (let t of e.values()) z(t);
+	e.clear();
 }
-var ActiveSelectionService = class {
+var U = class {
 	order = -50;
-	#dnd;
-	onAttach(dnd) {
-		this.#dnd = dnd;
-	}
-	onRootChange(nextRoot, _prevRoot, signal) {
-		if (!isHTMLElement(nextRoot)) return;
-		const monitor = this.#dnd.monitor;
-		nextRoot.addEventListener("pointerdown", (e) => {
-			if (e.button !== 0) return;
-			if (isIgnoreClick(e.target)) return;
-			const map = monitor.selectedByNs;
-			if (!map) return;
-			const drag = monitor.adapter.closestDraggable(e.target);
-			if (!drag) {
-				clearAll(map);
+	#e;
+	onAttach(e) {
+		this.#e = e;
+	}
+	onRootChange(e, t, n) {
+		if (!g(e)) return;
+		let r = this.#e.monitor;
+		e.addEventListener("pointerdown", (e) => {
+			if (e.button !== 0 || _(e.target)) return;
+			let t = r.selectedByNs;
+			if (!t) return;
+			let n = r.adapter.closestDraggable(e.target);
+			if (!n) {
+				H(t);
 				return;
 			}
-			const ns = monitor.adapter.getNamespace(drag);
-			const prev = map.get(ns);
-			if (Array.isArray(prev) && prev.length > 1 && prev.includes(drag)) return;
-			setActiveWithWrap(null, map, drag, ns);
+			let i = r.adapter.getNamespace(n), a = t.get(i);
+			Array.isArray(a) && a.length > 1 && a.includes(n) || B(null, t, n, i);
 		}, {
-			capture: true,
-			signal
+			capture: !0,
+			signal: n
 		});
 	}
-	onDown(ctx, event) {
-		const m = ctx?.session;
-		if (!m?.sourceEl || event?.button !== 0) return;
-		if (isIgnoreClick(event.target)) return;
-		const map = ctx.store?.selectedByNs || m.selectedByNs;
-		if (!map) return;
-		const ns = m.namespace || ctx.adapter.getNamespace(m.sourceEl);
-		const prev = map.get(ns);
-		if (Array.isArray(prev) && prev.length > 1 && prev.includes(m.sourceEl)) return;
-		if (prev && prev !== m.sourceEl) clearSelectionValue(prev, (el, cls, on) => ctx.frame.toggleClass(el, cls, on));
-		ctx.frame.toggleClass(m.sourceEl, CLASS_NAMES.active, true);
-		ensureWrapIfScoped(m.sourceEl);
-		map.set(ns, m.sourceEl);
-	}
-	onDestroy(_dnd, session) {
-		const map = session?.selectedByNs;
-		if (!map) return;
-		clearAll(map);
+	onDown(e, t) {
+		let r = e?.session;
+		if (!r?.sourceEl || t?.button !== 0 || _(t.target)) return;
+		let i = e.store?.selectedByNs || r.selectedByNs;
+		if (!i) return;
+		let a = r.namespace || e.adapter.getNamespace(r.sourceEl), o = i.get(a);
+		Array.isArray(o) && o.length > 1 && o.includes(r.sourceEl) || (o && o !== r.sourceEl && z(o, (t, n, r) => e.frame.toggleClass(t, n, r)), e.frame.toggleClass(r.sourceEl, n.active, !0), R(r.sourceEl), i.set(a, r.sourceEl));
+	}
+	onDestroy(e, t) {
+		let n = t?.selectedByNs;
+		n && H(n);
 	}
 };
 //#endregion
 //#region src/services/MarqueeSelectionService.js
-function normalizeRect(x1, y1, x2, y2) {
+function de(e, t, n, r) {
 	return {
-		left: Math.min(x1, x2),
-		right: Math.max(x1, x2),
-		top: Math.min(y1, y2),
-		bottom: Math.max(y1, y2),
-		width: Math.abs(x2 - x1),
-		height: Math.abs(y2 - y1)
+		left: Math.min(e, n),
+		right: Math.max(e, n),
+		top: Math.min(t, r),
+		bottom: Math.max(t, r),
+		width: Math.abs(n - e),
+		height: Math.abs(r - t)
 	};
 }
-function isHalfOverlap(selectRect, elementRect) {
-	const overlapLeft = Math.max(selectRect.left, elementRect.left);
-	const overlapRight = Math.min(selectRect.right, elementRect.right);
-	const overlapTop = Math.max(selectRect.top, elementRect.top);
-	const overlapBottom = Math.min(selectRect.bottom, elementRect.bottom);
-	const overlapW = overlapRight - overlapLeft;
-	const overlapH = overlapBottom - overlapTop;
-	if (overlapW <= 0 || overlapH <= 0) return false;
-	return overlapW * overlapH > (elementRect.right - elementRect.left) * (elementRect.bottom - elementRect.top) * MARQUEE_OVERLAP_RATIO;
+function fe(e, t) {
+	let n = Math.max(e.left, t.left), r = Math.min(e.right, t.right), i = Math.max(e.top, t.top), a = Math.min(e.bottom, t.bottom), o = r - n, c = a - i;
+	return o <= 0 || c <= 0 ? !1 : o * c > (t.right - t.left) * (t.bottom - t.top) * s;
 }
-var MarqueeSelectionService = class {
+var pe = class {
 	order = -40;
-	#dnd;
-	#rootSignal;
-	onAttach(dnd) {
-		this.#dnd = dnd;
-	}
-	onRootChange(nextRoot, _prevRoot, signal) {
-		this.#rootSignal = signal;
-		if (!isHTMLElement(nextRoot)) return;
-		nextRoot.addEventListener("pointerdown", (e) => {
-			if (e.button !== 0) return;
-			if (isIgnoreClick(e.target)) return;
-			const scope = e.target.closest(SCOPE_SEL);
-			if (!scope) return;
-			if (this.#dnd.monitor.adapter.closestDraggable(e.target)) return;
-			this.#startMarquee(scope, e);
+	#e;
+	#t;
+	onAttach(e) {
+		this.#e = e;
+	}
+	onRootChange(e, t, n) {
+		this.#t = n, g(e) && e.addEventListener("pointerdown", (e) => {
+			if (e.button !== 0 || _(e.target)) return;
+			let t = e.target.closest(y);
+			t && (this.#e.monitor.adapter.closestDraggable(e.target) || this.#n(t, e));
 		}, {
-			capture: true,
-			signal
+			capture: !0,
+			signal: n
 		});
 	}
-	#startMarquee(scope, startEvent) {
-		const startX = startEvent.clientX;
-		const startY = startEvent.clientY;
-		const adapter = this.#dnd.monitor.adapter;
-		const namespace = adapter.getNamespace(scope);
-		const scaleRatio = parseFloat(scope.getAttribute(ATTR.scaleRatioAttr) || "1");
-		const marquee = document.createElement("div");
-		marquee.classList.add(CLASS_NAMES.marquee);
-		scope.appendChild(marquee);
-		const scopeRect = scope.getBoundingClientRect();
-		const candidates = [];
-		for (const el of scope.querySelectorAll(`[${ATTR.dragAttr}], [${ATTR.dragdropAttr}]`)) if (adapter.getNamespace(el) === namespace) candidates.push(el);
-		let hasMoved = false;
-		let rafId = 0;
-		let lastEvent = null;
-		const rootSignal = this.#rootSignal;
-		const sessionAbort = new AbortController();
-		const onRootAbort = () => cleanup();
-		const cleanup = () => {
-			if (sessionAbort.signal.aborted) return;
-			if (rafId) {
-				cancelAnimationFrame(rafId);
-				rafId = 0;
+	#n(e, r) {
+		let i = r.clientX, o = r.clientY, s = this.#e.monitor.adapter, c = s.getNamespace(e), l = parseFloat(e.getAttribute(t.scaleRatioAttr) || "1"), u = document.createElement("div");
+		u.classList.add(n.marquee), e.appendChild(u);
+		let d = e.getBoundingClientRect(), f = [];
+		for (let n of e.querySelectorAll(`[${t.dragAttr}], [${t.dragdropAttr}]`)) s.getNamespace(n) === c && f.push(n);
+		let p = !1, m = 0, h = null, g = this.#t, _ = new AbortController(), v = () => y(), y = () => {
+			if (!_.signal.aborted) {
+				m &&= (cancelAnimationFrame(m), 0), g?.removeEventListener?.("abort", v);
+				try {
+					u.remove();
+				} catch {}
+				_.abort();
 			}
-			rootSignal?.removeEventListener?.("abort", onRootAbort);
-			try {
-				marquee.remove();
-			} catch (_) {}
-			sessionAbort.abort();
-		};
-		const processMove = () => {
-			rafId = 0;
-			const e = lastEvent;
+		}, b = () => {
+			m = 0;
+			let e = h;
 			if (!e) return;
-			const rect = normalizeRect(startX, startY, e.clientX, e.clientY);
-			this.#updateMarqueeDOM(marquee, rect, scopeRect, scaleRatio);
-			const selected = this.#detectCollisions(candidates, adapter, rect);
-			const map = this.#dnd.monitor.selectedByNs;
-			if (map) {
-				clearAll(map, namespace);
-				if (selected.length > 0) setMultipleActive(map, selected, namespace);
-			}
-		};
-		const onMove = (e) => {
-			const dx = e.clientX - startX;
-			const dy = e.clientY - startY;
-			if (!hasMoved && Math.abs(dx) < THRESHOLDS.MARQUEE_MOVE && Math.abs(dy) < THRESHOLDS.MARQUEE_MOVE) return;
-			hasMoved = true;
-			lastEvent = e;
-			if (!rafId) rafId = requestAnimationFrame(processMove);
-		};
-		const onUp = () => {
-			if (!hasMoved) {
-				const map = this.#dnd.monitor?.selectedByNs;
-				if (map) clearAll(map, namespace);
+			let t = de(i, o, e.clientX, e.clientY);
+			this.#r(u, t, d, l);
+			let n = this.#i(f, s, t), r = this.#e.monitor.selectedByNs;
+			r && (H(r, c), n.length > 0 && V(r, n, c));
+		}, x = (e) => {
+			let t = e.clientX - i, n = e.clientY - o;
+			!p && Math.abs(t) < a.MARQUEE_MOVE && Math.abs(n) < a.MARQUEE_MOVE || (p = !0, h = e, m ||= requestAnimationFrame(b));
+		}, S = () => {
+			if (!p) {
+				let e = this.#e.monitor?.selectedByNs;
+				e && H(e, c);
 			}
-			cleanup();
+			y();
 		};
-		if (rootSignal?.aborted) {
-			cleanup();
+		if (g?.aborted) {
+			y();
 			return;
 		}
-		rootSignal?.addEventListener?.("abort", onRootAbort, { once: true });
-		const opts = { signal: sessionAbort.signal };
-		document.addEventListener("pointermove", onMove, opts);
-		document.addEventListener("pointerup", onUp, opts);
-		document.addEventListener("pointercancel", cleanup, opts);
-		window.addEventListener("blur", cleanup, opts);
-	}
-	#updateMarqueeDOM(marquee, rect, scopeRect, scaleRatio) {
-		const left = (rect.left - scopeRect.left) / scaleRatio;
-		const top = (rect.top - scopeRect.top) / scaleRatio;
-		const width = rect.width / scaleRatio;
-		const height = rect.height / scaleRatio;
-		marquee.style.left = `${left}px`;
-		marquee.style.top = `${top}px`;
-		marquee.style.width = `${width}px`;
-		marquee.style.height = `${height}px`;
-	}
-	#detectCollisions(candidates, adapter, selectRect) {
-		const selected = [];
-		for (const el of candidates) {
-			const elRect = adapter.measureRect(el);
-			if (elRect && isHalfOverlap(selectRect, elRect)) selected.push(el);
+		g?.addEventListener?.("abort", v, { once: !0 });
+		let C = { signal: _.signal };
+		document.addEventListener("pointermove", x, C), document.addEventListener("pointerup", S, C), document.addEventListener("pointercancel", y, C), window.addEventListener("blur", y, C);
+	}
+	#r(e, t, n, r) {
+		let i = (t.left - n.left) / r, a = (t.top - n.top) / r, o = t.width / r, s = t.height / r;
+		e.style.left = `${i}px`, e.style.top = `${a}px`, e.style.width = `${o}px`, e.style.height = `${s}px`;
+	}
+	#i(e, t, n) {
+		let r = [];
+		for (let i of e) {
+			let e = t.measureRect(i);
+			e && fe(n, e) && r.push(i);
 		}
-		return selected;
+		return r;
 	}
 };
 //#endregion
 //#region src/services/transform/utils/geometry.js
-/**
-* 几何计算工具函数
-*/
-/**
-* 添加单位（px），保留亚像素精度（四舍五入到 2 位小数去除浮点噪声）
-*/
-function withUnit(v = 0) {
-	const n = Number(v);
-	if (!Number.isFinite(n)) return "0px";
-	return `${Math.round(n * 100) / 100}px`;
+function W(e = 0) {
+	let t = Number(e);
+	return Number.isFinite(t) ? `${Math.round(t * 100) / 100}px` : "0px";
 }
-/**
-* 角度转弧度
-*/
-function toRad(deg) {
-	return deg * Math.PI / 180;
+function G(e) {
+	return e * Math.PI / 180;
 }
-/**
-* 计算向量长度
-*/
-function getLength(x, y) {
-	return Math.sqrt(x * x + y * y);
+function me(e, t) {
+	return Math.sqrt(e * e + t * t);
 }
-/**
-* 网格吸附计算
-*/
-function calcGrid(diff, grid) {
-	const g = Math.max(1, Number(grid) || 1);
-	const r = Math.abs(diff) % g;
-	const mul = diff > 0 ? g : -g;
-	if (r > g / 2) return mul * Math.ceil(Math.abs(diff) / g);
-	return mul * Math.floor(Math.abs(diff) / g);
+function K(e, t) {
+	let n = Math.max(1, Number(t) || 1), r = Math.abs(e) % n, i = e > 0 ? n : -n;
+	return r > n / 2 ? i * Math.ceil(Math.abs(e) / n) : i * Math.floor(Math.abs(e) / n);
 }
-/**
-* 根据缩放比例获取元素矩形
-*/
-function getRectByScale(el, scale = 1, adapter) {
-	const r = adapter.measureRect(el);
-	const s = Number(scale) || 1;
+function q(e, t = 1, n) {
+	let r = n.measureRect(e), i = Number(t) || 1;
 	return {
-		bottom: r.bottom / s,
-		height: r.height / s,
-		left: r.left / s,
-		right: r.right / s,
-		top: r.top / s,
-		width: r.width / s
+		bottom: r.bottom / i,
+		height: r.height / i,
+		left: r.left / i,
+		right: r.right / i,
+		top: r.top / i,
+		width: r.width / i
 	};
 }
-/**
-* 计算指针相对中心点的角度
-*/
-function angleToPointer(cx, cy, px, py) {
-	const dx = px - cx;
-	const dy = py - cy;
-	let deg = Math.atan2(dy, dx) * 180 / Math.PI + 90;
-	deg = (deg % 360 + 360) % 360;
-	return deg;
+function J(e, t, n, r) {
+	let i = n - e, a = r - t, o = Math.atan2(a, i) * 180 / Math.PI + 90;
+	return o = (o % 360 + 360) % 360, o;
 }
-/**
-* 格式化变换数据（中心点坐标系）
-*/
-function formatData(data, cx, cy) {
-	const { width, height } = data;
+function he(e, t, n) {
+	let { width: r, height: i } = e;
 	return {
-		height: Math.abs(height),
-		width: Math.abs(width),
-		x: cx - Math.abs(width) / 2,
-		y: cy - Math.abs(height) / 2
+		height: Math.abs(i),
+		width: Math.abs(r),
+		x: t - Math.abs(r) / 2,
+		y: n - Math.abs(i) / 2
 	};
 }
-/**
-* 中心点坐标转左上角坐标
-*/
-function centerToTL({ centerX, centerY, width, height, angle }) {
+function ge({ centerX: e, centerY: t, width: n, height: r, angle: i }) {
 	return {
-		angle,
-		height,
-		width,
-		x: centerX - width / 2,
-		y: centerY - height / 2
+		angle: i,
+		height: r,
+		width: n,
+		x: e - n / 2,
+		y: t - r / 2
 	};
 }
-/**
-* 获取元素的 transform 信息
-*/
-function getElementTransformInfo(el) {
-	const style = getComputedStyle(el);
-	let matrix = {};
+function Y(e) {
+	let t = getComputedStyle(e), n = {};
 	try {
-		matrix = new DOMMatrixReadOnly(style.transform);
+		n = new DOMMatrixReadOnly(t.transform);
 	} catch {
-		matrix = new DOMMatrixReadOnly();
+		n = new DOMMatrixReadOnly();
 	}
-	const x = matrix.m41;
-	const y = matrix.m42;
-	let width = Number.parseFloat(style.width);
-	let height = Number.parseFloat(style.height);
-	if (!Number.isFinite(width) || !Number.isFinite(height)) {
-		const r = el.getBoundingClientRect();
-		width = r.width;
-		height = r.height;
+	let r = n.m41, i = n.m42, a = Number.parseFloat(t.width), o = Number.parseFloat(t.height);
+	if (!Number.isFinite(a) || !Number.isFinite(o)) {
+		let t = e.getBoundingClientRect();
+		a = t.width, o = t.height;
 	}
 	return {
-		angle: -Math.atan2(matrix.m21, matrix.m11) * (180 / Math.PI),
-		height,
-		width,
-		x,
-		y
+		angle: -Math.atan2(n.m21, n.m11) * (180 / Math.PI),
+		height: o,
+		width: a,
+		x: r,
+		y: i
 	};
 }
 //#endregion
 //#region src/services/transform/utils/cursor.js
-/**
-* 光标映射工具
-*/
-var resizableMap = {
+var _e = {
 	e: "right",
 	n: "top",
 	ne: "top-right",
@@ -2113,8 +1238,7 @@ var resizableMap = {
 	se: "bottom-right",
 	sw: "bottom-left",
 	w: "left"
-};
-var cursorDir = [
+}, ve = [
 	"n",
 	"ne",
 	"e",
@@ -2123,8 +1247,7 @@ var cursorDir = [
 	"sw",
 	"w",
 	"nw"
-];
-var cursorMap = {
+], ye = {
 	0: 0,
 	1: 1,
 	2: 1,
@@ -2137,8 +1260,7 @@ var cursorMap = {
 	9: 6,
 	10: 7,
 	11: 7
-};
-var cursorStartMap = {
+}, be = {
 	e: 2,
 	n: 0,
 	ne: 1,
@@ -2148,445 +1270,251 @@ var cursorStartMap = {
 	sw: 5,
 	w: 6
 };
-/**
-* 根据旋转角度和方向获取光标样式
-*/
-function getCursor(angle, d) {
-	const inc = cursorMap[Math.floor((angle % 360 + 360) % 360 / 30)];
-	return cursorDir[(cursorStartMap[d] + inc) % 8];
+function xe(e, t) {
+	let n = ye[Math.floor((e % 360 + 360) % 360 / 30)];
+	return ve[(be[t] + n) % 8];
 }
 //#endregion
 //#region src/services/transform/utils/markline.js
-/**
-* Markline（对齐辅助线）工具
-*/
-/**
-* 计算对齐线
-* @param {Array} list - 其他元素的位置信息列表
-* @param {Object} current - 当前元素的位置信息
-* @returns {Object} 对齐线信息
-*/
-function calcLines(list, current) {
-	const lines = {
+function Se(e, t) {
+	let n = {
 		x: [],
 		y: []
-	};
-	const { width = 0, height = 0 } = current;
-	list.forEach((b) => {
-		const { top: ATop, left: ALeft, width: AWidth, height: AHeight } = b;
-		lines.y.push({
-			showTop: ATop,
-			top: ATop
-		});
-		lines.y.push({
-			showTop: ATop,
-			top: ATop - height
+	}, { width: r = 0, height: i = 0 } = t;
+	return e.forEach((e) => {
+		let { top: t, left: a, width: o, height: s } = e;
+		n.y.push({
+			showTop: t,
+			top: t
+		}), n.y.push({
+			showTop: t,
+			top: t - i
+		}), n.y.push({
+			showTop: t + s / 2,
+			top: t + s / 2 - i / 2
+		}), n.y.push({
+			showTop: t + s,
+			top: t + s
+		}), n.y.push({
+			showTop: t + s,
+			top: t + s - i
+		}), n.x.push({
+			left: a,
+			showLeft: a
+		}), n.x.push({
+			left: a + o,
+			showLeft: a + o
+		}), n.x.push({
+			left: a + o / 2 - r / 2,
+			showLeft: a + o / 2
+		}), n.x.push({
+			left: a + o - r,
+			showLeft: a + o
+		}), n.x.push({
+			left: a - r,
+			showLeft: a
 		});
-		lines.y.push({
-			showTop: ATop + AHeight / 2,
-			top: ATop + AHeight / 2 - height / 2
-		});
-		lines.y.push({
-			showTop: ATop + AHeight,
-			top: ATop + AHeight
-		});
-		lines.y.push({
-			showTop: ATop + AHeight,
-			top: ATop + AHeight - height
-		});
-		lines.x.push({
-			left: ALeft,
-			showLeft: ALeft
-		});
-		lines.x.push({
-			left: ALeft + AWidth,
-			showLeft: ALeft + AWidth
-		});
-		lines.x.push({
-			left: ALeft + AWidth / 2 - width / 2,
-			showLeft: ALeft + AWidth / 2
-		});
-		lines.x.push({
-			left: ALeft + AWidth - width,
-			showLeft: ALeft + AWidth
-		});
-		lines.x.push({
-			left: ALeft - width,
-			showLeft: ALeft
-		});
-	});
-	return lines;
+	}), n;
 }
-/**
-* Resize 专用吸附解算（纯函数）
-*
-* 与 calcLines（为 move 设计、把当前 width/height 烘进候选线）不同：
-* resize 只把「正在拖动的那条边」吸附到邻居的裸边（left/中线/right，top/中线/bottom），
-* 对侧边保持锚定。返回移动边需要的位移 diff 与命中线在 viewport 坐标的位置 guide。
-*
-* @param {Object} arg
-* @param {string} arg.side - left/right/top/bottom/top-left/top-right/bottom-left/bottom-right
-* @param {Object} arg.source - 当前盒子矩形（viewport-scaled，含 left/right/top/bottom）
-* @param {Array} arg.targetRects - 邻居元素矩形列表（viewport-scaled，含 left/top/width/height）
-* @param {number} arg.threshold - 吸附阈值（viewport-scaled 像素）
-* @returns {{diffX:number, diffY:number, guideLeft:(number|undefined), guideTop:(number|undefined)}}
-*/
-function resolveResizeSnap({ side = "", source, targetRects = [], threshold = 10 }) {
-	const result = {
+function Ce({ side: e = "", source: t, targetRects: n = [], threshold: r = 10 }) {
+	let i = {
 		diffX: 0,
 		diffY: 0,
 		guideLeft: void 0,
 		guideTop: void 0
 	};
-	if (!source) return result;
-	const movesLeft = side.includes("left");
-	const movesRight = side.includes("right");
-	const movesTop = side.includes("top");
-	const movesBottom = side.includes("bottom");
-	if (movesLeft || movesRight) {
-		const edge = movesLeft ? source.left : source.right;
-		for (const t of targetRects) {
-			const candidates = [
+	if (!t) return i;
+	let a = e.includes("left"), o = e.includes("right"), s = e.includes("top"), c = e.includes("bottom");
+	if (a || o) {
+		let e = a ? t.left : t.right;
+		for (let t of n) {
+			let n = [
 				t.left,
 				t.left + t.width / 2,
 				t.left + t.width
-			];
-			let hit;
-			for (const c of candidates) if (Math.abs(c - edge) < threshold) {
-				hit = c;
+			], a;
+			for (let t of n) if (Math.abs(t - e) < r) {
+				a = t;
 				break;
 			}
-			if (hit !== void 0) {
-				result.diffX = hit - edge;
-				result.guideLeft = hit;
+			if (a !== void 0) {
+				i.diffX = a - e, i.guideLeft = a;
 				break;
 			}
 		}
 	}
-	if (movesTop || movesBottom) {
-		const edge = movesTop ? source.top : source.bottom;
-		for (const t of targetRects) {
-			const candidates = [
+	if (s || c) {
+		let e = s ? t.top : t.bottom;
+		for (let t of n) {
+			let n = [
 				t.top,
 				t.top + t.height / 2,
 				t.top + t.height
-			];
-			let hit;
-			for (const c of candidates) if (Math.abs(c - edge) < threshold) {
-				hit = c;
+			], a;
+			for (let t of n) if (Math.abs(t - e) < r) {
+				a = t;
 				break;
 			}
-			if (hit !== void 0) {
-				result.diffY = hit - edge;
-				result.guideTop = hit;
+			if (a !== void 0) {
+				i.diffY = a - e, i.guideTop = a;
 				break;
 			}
 		}
 	}
-	return result;
+	return i;
 }
-/**
-* 创建临时对齐线容器
-*/
-function createTempMarklines(container) {
-	let x = container.querySelector(".draggable-markline-x");
-	let y = container.querySelector(".draggable-markline-y");
-	if (!x) {
-		x = document.createElement("div");
-		x.className = "draggable-markline-x";
-		container.appendChild(x);
-	}
-	if (!y) {
-		y = document.createElement("div");
-		y.className = "draggable-markline-y";
-		container.appendChild(y);
-	}
-	return {
-		x,
-		y
+function X(e) {
+	let t = e.querySelector(".draggable-markline-x"), n = e.querySelector(".draggable-markline-y");
+	return t || (t = document.createElement("div"), t.className = "draggable-markline-x", e.appendChild(t)), n || (n = document.createElement("div"), n.className = "draggable-markline-y", e.appendChild(n)), {
+		x: t,
+		y: n
 	};
 }
-/**
-* 隐藏对齐线
-*/
-function hideMarkline(el) {
-	if (!el) return;
-	el.style.display = "none";
+function Z(e) {
+	e && (e.style.display = "none");
 }
 //#endregion
 //#region src/services/transform/utils/resize.js
-/**
-* Resize 尺寸计算工具
-*/
-/**
-* 设置宽度和增量，考虑最小宽度限制
-*/
-function setWidthAndDeltaW(width, deltaW, minWidth) {
-	const expected = width + deltaW;
-	if (expected > minWidth) width = expected;
-	else {
-		deltaW = minWidth - width;
-		width = minWidth;
-	}
-	return {
-		deltaW,
-		width
+function Q(e, t, n) {
+	let r = e + t;
+	return r > n ? e = r : (t = n - e, e = n), {
+		deltaW: t,
+		width: e
 	};
 }
-/**
-* 设置高度和增量，考虑最小高度限制
-*/
-function setHeightAndDeltaH(height, deltaH, minHeight) {
-	const expected = height + deltaH;
-	if (expected > minHeight) height = expected;
-	else {
-		deltaH = minHeight - height;
-		height = minHeight;
-	}
-	return {
-		deltaH,
-		height
+function $(e, t, n) {
+	let r = e + t;
+	return r > n ? e = r : (t = n - e, e = n), {
+		deltaH: t,
+		height: e
 	};
 }
-/**
-* 根据 resize 类型计算新的样式
-* @param {string} type - resize 方向（top/right/bottom/left/top-right/...）
-* @param {Object} rect - 当前矩形信息
-* @param {number} deltaW - 宽度变化量
-* @param {number} deltaH - 高度变化量
-* @param {number} ratio - 宽高比（可选）
-* @param {number} minWidth - 最小宽度
-* @param {number} minHeight - 最小高度
-* @returns {Object} 新的样式信息
-*/
-function getNewStyle(type, rect, deltaW, deltaH, ratio, minWidth, minHeight) {
-	let { width, height, centerX, centerY, rotateAngle } = rect;
-	const wf = width < 0 ? -1 : 1;
-	const hf = height < 0 ? -1 : 1;
-	width = Math.abs(width);
-	height = Math.abs(height);
-	const rad = toRad(rotateAngle);
-	const cos = Math.cos(rad);
-	const sin = Math.sin(rad);
-	if ([
+function we(e, t, n, r, i, a, o) {
+	let { width: s, height: c, centerX: l, centerY: u, rotateAngle: d } = t, f = s < 0 ? -1 : 1, p = c < 0 ? -1 : 1;
+	s = Math.abs(s), c = Math.abs(c);
+	let m = G(d), h = Math.cos(m), g = Math.sin(m);
+	switch ([
 		"top-left",
 		"top-right",
 		"bottom-left",
 		"bottom-right"
-	].includes(type)) {
-		if (type === "top-right") deltaH = -deltaH;
-		else if (type === "bottom-left") deltaW = -deltaW;
-		else if (type === "top-left") {
-			deltaW = -deltaW;
-			deltaH = -deltaH;
-		}
-		({width, deltaW} = setWidthAndDeltaW(width, deltaW, minWidth));
-		({height, deltaH} = setHeightAndDeltaH(height, deltaH, minHeight));
-		if (ratio) {
-			deltaH = deltaW / ratio;
-			height = width / ratio;
-		}
-	}
-	switch (type) {
+	].includes(e) && (e === "top-right" ? r = -r : e === "bottom-left" ? n = -n : e === "top-left" && (n = -n, r = -r), {width: s, deltaW: n} = Q(s, n, a), {height: c, deltaH: r} = $(c, r, o), i && (r = n / i, c = s / i)), e) {
 		case "right":
-			({width, deltaW} = setWidthAndDeltaW(width, deltaW, minWidth));
-			if (ratio) {
-				deltaH = deltaW / ratio;
-				height = width / ratio;
-				centerX += deltaW / 2 * cos - deltaH / 2 * sin;
-				centerY += deltaW / 2 * sin + deltaH / 2 * cos;
-			} else {
-				centerX += deltaW / 2 * cos;
-				centerY += deltaW / 2 * sin;
-			}
+			({width: s, deltaW: n} = Q(s, n, a)), i ? (r = n / i, c = s / i, l += n / 2 * h - r / 2 * g, u += n / 2 * g + r / 2 * h) : (l += n / 2 * h, u += n / 2 * g);
 			break;
 		case "top-right":
-			centerX += deltaW / 2 * cos + deltaH / 2 * sin;
-			centerY += deltaW / 2 * sin - deltaH / 2 * cos;
+			l += n / 2 * h + r / 2 * g, u += n / 2 * g - r / 2 * h;
 			break;
 		case "bottom-right":
-			centerX += deltaW / 2 * cos - deltaH / 2 * sin;
-			centerY += deltaW / 2 * sin + deltaH / 2 * cos;
+			l += n / 2 * h - r / 2 * g, u += n / 2 * g + r / 2 * h;
 			break;
 		case "bottom":
-			({height, deltaH} = setHeightAndDeltaH(height, deltaH, minHeight));
-			if (ratio) {
-				deltaW = deltaH * ratio;
-				width = height * ratio;
-				centerX += deltaW / 2 * cos - deltaH / 2 * sin;
-				centerY += deltaW / 2 * sin + deltaH / 2 * cos;
-			} else {
-				centerX -= deltaH / 2 * sin;
-				centerY += deltaH / 2 * cos;
-			}
+			({height: c, deltaH: r} = $(c, r, o)), i ? (n = r * i, s = c * i, l += n / 2 * h - r / 2 * g, u += n / 2 * g + r / 2 * h) : (l -= r / 2 * g, u += r / 2 * h);
 			break;
 		case "bottom-left":
-			centerX -= deltaW / 2 * cos + deltaH / 2 * sin;
-			centerY -= deltaW / 2 * sin - deltaH / 2 * cos;
+			l -= n / 2 * h + r / 2 * g, u -= n / 2 * g - r / 2 * h;
 			break;
 		case "left":
-			deltaW = -deltaW;
-			({width, deltaW} = setWidthAndDeltaW(width, deltaW, minWidth));
-			if (ratio) {
-				height = width / ratio;
-				deltaH = deltaW / ratio;
-				centerX -= deltaW / 2 * cos + deltaH / 2 * sin;
-				centerY -= deltaW / 2 * sin - deltaH / 2 * cos;
-			} else {
-				centerX -= deltaW / 2 * cos;
-				centerY -= deltaW / 2 * sin;
-			}
+			n = -n, {width: s, deltaW: n} = Q(s, n, a), i ? (c = s / i, r = n / i, l -= n / 2 * h + r / 2 * g, u -= n / 2 * g - r / 2 * h) : (l -= n / 2 * h, u -= n / 2 * g);
 			break;
 		case "top-left":
-			centerX -= deltaW / 2 * cos - deltaH / 2 * sin;
-			centerY -= deltaW / 2 * sin + deltaH / 2 * cos;
+			l -= n / 2 * h - r / 2 * g, u -= n / 2 * g + r / 2 * h;
 			break;
 		case "top":
-			deltaH = -deltaH;
-			({height, deltaH} = setHeightAndDeltaH(height, deltaH, minHeight));
-			if (ratio) {
-				width = height * ratio;
-				deltaW = deltaH * ratio;
-				centerX += deltaW / 2 * cos + deltaH / 2 * sin;
-				centerY += deltaW / 2 * sin - deltaH / 2 * cos;
-			} else {
-				centerX += deltaH / 2 * sin;
-				centerY -= deltaH / 2 * cos;
-			}
+			r = -r, {height: c, deltaH: r} = $(c, r, o), i ? (s = c * i, n = r * i, l += n / 2 * h + r / 2 * g, u += n / 2 * g - r / 2 * h) : (l += r / 2 * g, u -= r / 2 * h);
 			break;
 		default: break;
 	}
 	return {
 		position: {
-			centerX,
-			centerY
+			centerX: l,
+			centerY: u
 		},
 		size: {
-			height: height * hf,
-			width: width * wf
+			height: c * p,
+			width: s * f
 		}
 	};
 }
 //#endregion
 //#region src/services/transform/utils/handles.js
-/**
-* Handle（控制点）管理工具
-*/
-/**
-* 查找元素内的所有 resize 控制点
-*/
-function findDots(el) {
-	const wrap = el?.querySelector?.(`:scope > .draggable-dot-wrap`);
-	return wrap ? [...wrap.querySelectorAll?.(`.draggable-dot`) || []] : [];
+function Te(e) {
+	let t = e?.querySelector?.(":scope > .draggable-dot-wrap");
+	return t ? [...t.querySelectorAll?.(".draggable-dot") || []] : [];
 }
-/**
-* 从 handle 元素获取 resize 方向
-*/
-function getResizeSideFromHandle(handleEl) {
-	const dir = handleEl?.dataset?.dir;
-	return dir && resizableMap[dir] || "right";
+function Ee(e) {
+	let t = e?.dataset?.dir;
+	return t && _e[t] || "right";
 }
-/**
-* 判断是否为 rotate handle
-*/
-function isRotateHandle(handleEl) {
-	return Boolean(handleEl?.hasAttribute?.(ATTR.handleRotateAttr));
+function De(e) {
+	return !!e?.hasAttribute?.(t.handleRotateAttr);
 }
-/**
-* 判断是否为 resize handle
-*/
-function isResizeHandle(handleEl) {
-	return Boolean(handleEl?.hasAttribute?.(ATTR.handleResizeAttr));
+function Oe(e) {
+	return !!e?.hasAttribute?.(t.handleResizeAttr);
 }
 //#endregion
 //#region src/services/TransformControllerService.js
-var TransformControllerService = class {
+var ke = class {
 	order = 25;
-	#opt;
-	constructor(options = {}) {
-		this.#opt = {
-			resizable: true,
-			rotatable: true,
-			/** 是否限制在 drag-scope 容器内 */
-			boundary: true,
-			/** 外层缩放比例（画布缩放） */
+	#e;
+	constructor(e = {}) {
+		this.#e = {
+			resizable: !0,
+			rotatable: !0,
+			boundary: !0,
 			scaleRatio: 1,
-			/** 吸附到网格 */
-			snapToGrid: false,
+			snapToGrid: !1,
 			gridX: 10,
 			gridY: 10,
-			/** resize 约束 */
 			aspectRatio: void 0,
 			minWidth: 10,
 			minHeight: 10,
 			maxWidth: 0,
 			maxHeight: 0,
-			/** rotate 吸附 */
-			rotateSnap: false,
+			rotateSnap: !1,
 			rotateStep: 15,
-			/** markline + snap */
-			snap: true,
+			snap: !0,
 			snapThreshold: 10,
-			markline: true,
-			/** 在 drag-scope 内默认关闭镜像与 drop 指示器 */
-			disableMirrorInScope: true,
-			disableDropIndicatorInScope: true,
-			/** 是否允许 transform（业务可覆写） */
-			canTransform: () => true,
-			...options
+			markline: !0,
+			disableMirrorInScope: !0,
+			disableDropIndicatorInScope: !0,
+			canTransform: () => !0,
+			...e
 		};
 	}
-	/**
-	* 获取当前 drag-scope/drop 容器的缩放比例：
-	* - 优先读取容器上的 [scale-ratio]（或 [data-scale-ratio]）
-	* - 若未设置/非法，则回退到 options.scaleRatio
-	*/
-	#resolveScaleRatio(container, adapter) {
-		const name = ATTR.scaleRatioAttr || "scale-ratio";
-		const v = adapter?.getAttr?.(container, name) ?? adapter?.getAttr?.(container, `data-${name}`) ?? container?.getAttribute?.(name) ?? container?.getAttribute?.(`data-${name}`);
-		const n = Number.parseFloat(String(v ?? ""));
-		if (Number.isFinite(n) && n > 0) return n;
-		const opt = Number(this.#opt.scaleRatio);
-		return Number.isFinite(opt) && opt > 0 ? opt : 1;
-	}
-	#getScaleRatio(st) {
-		const n = Number(st?.scaleRatio);
-		if (Number.isFinite(n) && n > 0) return n;
-		const opt = Number(this.#opt.scaleRatio);
-		return Number.isFinite(opt) && opt > 0 ? opt : 1;
-	}
-	onDown(ctx) {
-		const m = ctx?.session;
-		if (!m?.isDragScope || !isHTMLElement(m.sourceEl)) return;
-		if (!this.#opt.resizable) return;
-		const { angle } = getElementTransformInfo(m.sourceEl);
-		if (angle) this.#updateDotCursors(m.sourceEl, angle);
-	}
-	onStart(ctx) {
-		const m = ctx.session;
-		if (!m?.active || !m?.started || !m.isDragScope) return;
-		if (!isHTMLElement(m.sourceEl)) return;
-		if (typeof this.#opt.canTransform === "function" && !this.#opt.canTransform(m.sourceEl)) return;
-		const selectedValue = m.selectedByNs?.get(m.namespace);
-		const isMultiSelect = Array.isArray(selectedValue) && selectedValue.length > 1;
-		let type = "move";
-		let side = "";
-		const canRotate = this.#opt.rotatable && isToggleEnabled(m.sourceEl, ATTR.rotatableAttr, true);
-		const canResize = this.#opt.resizable && isToggleEnabled(m.sourceEl, ATTR.resizableAttr, true);
-		if (isRotateHandle(m.handleEl) && canRotate) {
-			if (isMultiSelect) return;
-			type = "rotate";
-		} else if (isResizeHandle(m.handleEl) && canResize) {
-			if (isMultiSelect) return;
-			type = "resize";
-			side = getResizeSideFromHandle(m.handleEl);
-		}
-		if (this.#opt.disableMirrorInScope) this.#disableMirrorNow(m);
-		if (this.#opt.disableDropIndicatorInScope) this.#disableIndicatorNow(m);
-		m.cache.__transform = {
+	#t(e, n) {
+		let r = t.scaleRatioAttr || "scale-ratio", i = n?.getAttr?.(e, r) ?? n?.getAttr?.(e, `data-${r}`) ?? e?.getAttribute?.(r) ?? e?.getAttribute?.(`data-${r}`), a = Number.parseFloat(String(i ?? ""));
+		if (Number.isFinite(a) && a > 0) return a;
+		let o = Number(this.#e.scaleRatio);
+		return Number.isFinite(o) && o > 0 ? o : 1;
+	}
+	#n(e) {
+		let t = Number(e?.scaleRatio);
+		if (Number.isFinite(t) && t > 0) return t;
+		let n = Number(this.#e.scaleRatio);
+		return Number.isFinite(n) && n > 0 ? n : 1;
+	}
+	onDown(e) {
+		let t = e?.session;
+		if (!t?.isDragScope || !g(t.sourceEl) || !this.#e.resizable) return;
+		let { angle: n } = Y(t.sourceEl);
+		n && this.#u(t.sourceEl, n);
+	}
+	onStart(e) {
+		let n = e.session;
+		if (!n?.active || !n?.started || !n.isDragScope || !g(n.sourceEl) || typeof this.#e.canTransform == "function" && !this.#e.canTransform(n.sourceEl)) return;
+		let r = n.selectedByNs?.get(n.namespace), i = Array.isArray(r) && r.length > 1, a = "move", o = "", s = this.#e.rotatable && m(n.sourceEl, t.rotatableAttr, !0), c = this.#e.resizable && m(n.sourceEl, t.resizableAttr, !0);
+		if (De(n.handleEl) && s) {
+			if (i) return;
+			a = "rotate";
+		} else if (Oe(n.handleEl) && c) {
+			if (i) return;
+			a = "resize", o = Ee(n.handleEl);
+		}
+		this.#e.disableMirrorInScope && this.#h(n), this.#e.disableDropIndicatorInScope && this.#g(n), n.cache.__transform = {
 			phase: 0,
-			type,
-			side,
+			type: a,
+			side: o,
 			scaleRatio: void 0,
 			container: void 0,
 			containerRect: void 0,
@@ -2607,7 +1535,7 @@ var TransformControllerService = class {
 				left: void 0,
 				top: void 0
 			},
-			didCompute: false,
+			didCompute: !1,
 			lastValidData: void 0,
 			lastAppliedX: void 0,
 			lastAppliedY: void 0,
@@ -2615,500 +1543,299 @@ var TransformControllerService = class {
 			lastAppliedH: void 0,
 			lastAppliedAngle: void 0,
 			multiSelection: {
-				enabled: isMultiSelect,
+				enabled: i,
 				elements: [],
 				initialTransforms: []
 			}
 		};
 	}
-	onMeasure(ctx) {
-		const m = ctx.session;
-		const st = m?.cache?.__transform;
-		if (!m?.active || !m?.started || !m.isDragScope || !st || st.phase !== 0) return;
-		if (!isHTMLElement(m.sourceEl)) {
-			m.cache.__transform = void 0;
+	onMeasure(e) {
+		let n = e.session, r = n?.cache?.__transform;
+		if (!n?.active || !n?.started || !n.isDragScope || !r || r.phase !== 0) return;
+		if (!g(n.sourceEl)) {
+			n.cache.__transform = void 0;
 			return;
 		}
-		const container = ctx.adapter.closestDragScope(m.sourceEl);
-		if (!isHTMLElement(container)) {
-			m.cache.__transform = void 0;
+		let i = e.adapter.closestDragScope(n.sourceEl);
+		if (!g(i)) {
+			n.cache.__transform = void 0;
 			return;
 		}
-		const scale = this.#resolveScaleRatio(container, ctx.adapter);
-		const info = getElementTransformInfo(m.sourceEl);
-		const cRect = ctx.adapter.measureRect(container);
-		const cRectScaled = {
-			height: cRect.height / scale,
-			left: cRect.left / scale,
-			top: cRect.top / scale,
-			width: cRect.width / scale
-		};
-		st.container = container;
-		st.scaleRatio = scale;
-		st.containerRect = cRect;
-		st.containerRectScaled = cRectScaled;
-		st.start = { ...info };
-		st.data = { ...info };
-		st.center = {
-			x: info.x + info.width / 2,
-			y: info.y + info.height / 2
+		let a = this.#t(i, e.adapter), o = Y(n.sourceEl), s = e.adapter.measureRect(i), c = {
+			height: s.height / a,
+			left: s.left / a,
+			top: s.top / a,
+			width: s.width / a
 		};
-		if (this.#opt.boundary) st.boundary = {
-			w: Math.max(0, container.clientWidth),
-			h: Math.max(0, container.clientHeight)
-		};
-		if (st.type === "rotate") {
-			const mx = (m.x - cRect.left) / scale;
-			const my = (m.y - cRect.top) / scale;
-			st.rotateOffset = angleToPointer(st.center.x, st.center.y, mx, my) - st.data.angle;
-		}
-		if (this.#opt.snap || this.#opt.markline) {
-			const startRect = getRectByScale(m.sourceEl, scale, ctx.adapter);
-			st.startRect = startRect;
-			st.viewportCenterOffset = {
-				x: startRect.left + startRect.width / 2 - st.center.x,
-				y: startRect.top + startRect.height / 2 - st.center.y
+		if (r.container = i, r.scaleRatio = a, r.containerRect = s, r.containerRectScaled = c, r.start = { ...o }, r.data = { ...o }, r.center = {
+			x: o.x + o.width / 2,
+			y: o.y + o.height / 2
+		}, this.#e.boundary && (r.boundary = {
+			w: Math.max(0, i.clientWidth),
+			h: Math.max(0, i.clientHeight)
+		}), r.type === "rotate") {
+			let e = (n.x - s.left) / a, t = (n.y - s.top) / a;
+			r.rotateOffset = J(r.center.x, r.center.y, e, t) - r.data.angle;
+		}
+		if (this.#e.snap || this.#e.markline) {
+			let o = q(n.sourceEl, a, e.adapter);
+			r.startRect = o, r.viewportCenterOffset = {
+				x: o.left + o.width / 2 - r.center.x,
+				y: o.top + o.height / 2 - r.center.y
 			};
-			const els = [...container.querySelectorAll?.(`[${ATTR.dragAttr}]`) || []];
-			const targets = [];
-			for (const node of els) {
-				if (node === m.sourceEl) continue;
-				if (!isHTMLElement(node)) continue;
-				targets.push(getRectByScale(node, scale, ctx.adapter));
-			}
-			st.lines = calcLines(targets, startRect);
-			st.targetRects = targets;
-			if (this.#opt.markline) {
-				const guides = createTempMarklines(container);
-				st.guideX = guides.x;
-				st.guideY = guides.y;
+			let s = [...i.querySelectorAll?.(`[${t.dragAttr}]`) || []], c = [];
+			for (let t of s) t !== n.sourceEl && g(t) && c.push(q(t, a, e.adapter));
+			if (r.lines = Se(c, o), r.targetRects = c, this.#e.markline) {
+				let e = X(i);
+				r.guideX = e.x, r.guideY = e.y;
 			}
 		}
-		if (st.multiSelection.enabled) {
-			const selectedValue = m.selectedByNs?.get(m.namespace);
-			if (Array.isArray(selectedValue)) {
-				for (const el of selectedValue) if (el !== m.sourceEl && isHTMLElement(el)) {
-					st.multiSelection.elements.push(el);
-					st.multiSelection.initialTransforms.push(getElementTransformInfo(el));
-				}
-			}
-		}
-		st.phase = 1;
-	}
-	onCompute(ctx) {
-		const m = ctx.session;
-		const st = m?.cache?.__transform;
-		if (!m?.active || !m?.started || !m.isDragScope || !st || st.phase !== 1) return;
-		if (!isHTMLElement(m.sourceEl)) return;
-		st.didCompute = true;
-		if (st.type === "move") this.#computeMove(m, st);
-		else if (st.type === "rotate") this.#computeRotate(m, st);
-		else if (st.type === "resize") this.#computeResize(m, st);
-	}
-	onCommit(ctx) {
-		const m = ctx.session;
-		const st = m?.cache?.__transform;
-		if (!m?.active || !m?.started || !m.isDragScope || !st || st.phase !== 1) return;
-		if (!st.didCompute || !isHTMLElement(m.sourceEl)) return;
-		this.#apply(ctx, m.sourceEl, st);
-		if (st.multiSelection.enabled && st.type === "move") {
-			const deltaX = st.data.x - st.start.x;
-			const deltaY = st.data.y - st.start.y;
-			for (let i = 0; i < st.multiSelection.elements.length; i++) {
-				const el = st.multiSelection.elements[i];
-				const initialInfo = st.multiSelection.initialTransforms[i];
-				const newData = {
-					x: initialInfo.x + deltaX,
-					y: initialInfo.y + deltaY,
-					width: initialInfo.width,
-					height: initialInfo.height,
-					angle: initialInfo.angle
+		if (r.multiSelection.enabled) {
+			let e = n.selectedByNs?.get(n.namespace);
+			if (Array.isArray(e)) for (let t of e) t !== n.sourceEl && g(t) && (r.multiSelection.elements.push(t), r.multiSelection.initialTransforms.push(Y(t)));
+		}
+		r.phase = 1;
+	}
+	onCompute(e) {
+		let t = e.session, n = t?.cache?.__transform;
+		!t?.active || !t?.started || !t.isDragScope || !n || n.phase !== 1 || g(t.sourceEl) && (n.didCompute = !0, n.type === "move" ? this.#r(t, n) : n.type === "rotate" ? this.#i(t, n) : n.type === "resize" && this.#a(t, n));
+	}
+	onCommit(e) {
+		let t = e.session, n = t?.cache?.__transform;
+		if (!t?.active || !t?.started || !t.isDragScope || !n || n.phase !== 1 || !n.didCompute || !g(t.sourceEl)) return;
+		if (this.#f(e, t.sourceEl, n), n.multiSelection.enabled && n.type === "move") {
+			let t = n.data.x - n.start.x, r = n.data.y - n.start.y;
+			for (let i = 0; i < n.multiSelection.elements.length; i++) {
+				let a = n.multiSelection.elements[i], o = n.multiSelection.initialTransforms[i], s = {
+					x: o.x + t,
+					y: o.y + r,
+					width: o.width,
+					height: o.height,
+					angle: o.angle
 				};
-				this.#applyTransform(ctx, el, newData);
+				this.#d(e, a, s);
 			}
 		}
-		if (st.type === "rotate" && this.#opt.resizable && st.lastCursorAngle !== st.data?.angle) {
-			st.lastCursorAngle = st.data?.angle;
-			ctx.frame?.run?.(() => {
-				this.#updateDotCursors(m.sourceEl, st.lastCursorAngle || 0);
-			});
-		}
-		if (this.#opt.markline) this.#commitMarkline(ctx, st);
-		const dnd = ctx.dnd;
-		if (dnd?.emit && st?.data) {
-			let payload = st.__emitPayload;
-			if (!payload) {
-				payload = st.__emitPayload = {
-					type: st.type,
-					el: m.sourceEl
-				};
-				st.__emitEvt = st.type === "move" ? "draggable:drag" : st.type === "rotate" ? "draggable:rotate" : "draggable:resize";
-				st.__emitRun = () => dnd.emit(st.__emitEvt, st.__emitPayload);
-			}
-			payload.el = m.sourceEl;
-			payload.x = st.data.x;
-			payload.y = st.data.y;
-			payload.width = st.data.width;
-			payload.height = st.data.height;
-			payload.angle = st.data.angle;
-			ctx.frame?.run?.(st.__emitRun);
-		}
-		st.didCompute = false;
-	}
-	onEnd(ctx, meta) {
-		const m = ctx.session;
-		const st = m?.cache?.__transform;
-		if (!st) return;
-		hideMarkline(st.guideX);
-		hideMarkline(st.guideY);
-		if (meta?.ended && isHTMLElement(m?.sourceEl) && st?.data) {
-			ctx.dnd?.emit?.("draggable:drop", {
-				type: st.type,
-				el: m.sourceEl,
-				data: m.data,
-				...st.data
-			});
-			if (st.multiSelection?.enabled && st.type === "move") {
-				const deltaX = st.data.x - st.start.x;
-				const deltaY = st.data.y - st.start.y;
-				const elements = [{
-					el: m.sourceEl,
-					x: st.data.x,
-					y: st.data.y,
-					width: st.data.width,
-					height: st.data.height,
-					angle: st.data.angle,
-					data: m.data
-				}, ...st.multiSelection.elements.map((el, i) => {
-					const init = st.multiSelection.initialTransforms[i];
+		n.type === "rotate" && this.#e.resizable && n.lastCursorAngle !== n.data?.angle && (n.lastCursorAngle = n.data?.angle, e.frame?.run?.(() => {
+			this.#u(t.sourceEl, n.lastCursorAngle || 0);
+		})), this.#e.markline && this.#l(e, n);
+		let r = e.dnd;
+		if (r?.emit && n?.data) {
+			let i = n.__emitPayload;
+			i || (i = n.__emitPayload = {
+				type: n.type,
+				el: t.sourceEl
+			}, n.__emitEvt = n.type === "move" ? "draggable:drag" : n.type === "rotate" ? "draggable:rotate" : "draggable:resize", n.__emitRun = () => r.emit(n.__emitEvt, n.__emitPayload)), i.el = t.sourceEl, i.x = n.data.x, i.y = n.data.y, i.width = n.data.width, i.height = n.data.height, i.angle = n.data.angle, e.frame?.run?.(n.__emitRun);
+		}
+		n.didCompute = !1;
+	}
+	onEnd(e, n) {
+		let r = e.session, i = r?.cache?.__transform;
+		if (i) {
+			if (Z(i.guideX), Z(i.guideY), n?.ended && g(r?.sourceEl) && i?.data && (e.dnd?.emit?.("draggable:drop", {
+				type: i.type,
+				el: r.sourceEl,
+				data: r.data,
+				...i.data
+			}), i.multiSelection?.enabled && i.type === "move")) {
+				let n = i.data.x - i.start.x, a = i.data.y - i.start.y, o = [{
+					el: r.sourceEl,
+					x: i.data.x,
+					y: i.data.y,
+					width: i.data.width,
+					height: i.data.height,
+					angle: i.data.angle,
+					data: r.data
+				}, ...i.multiSelection.elements.map((r, o) => {
+					let s = i.multiSelection.initialTransforms[o];
 					return {
-						el,
-						x: init.x + deltaX,
-						y: init.y + deltaY,
-						width: init.width,
-						height: init.height,
-						angle: init.angle,
-						data: parseData(ctx.adapter?.getAttr?.(el, ATTR.dataAttr))
+						el: r,
+						x: s.x + n,
+						y: s.y + a,
+						width: s.width,
+						height: s.height,
+						angle: s.angle,
+						data: u(e.adapter?.getAttr?.(r, t.dataAttr))
 					};
 				})];
-				ctx.dnd?.emit?.("draggable:multi-drop", elements);
+				e.dnd?.emit?.("draggable:multi-drop", o);
 			}
-		}
-		if (meta?.ended && st.type === "rotate" && this.#opt.resizable && isHTMLElement(m?.sourceEl)) this.#updateDotCursors(m.sourceEl, st.data?.angle || 0);
-		m.cache.__transform = void 0;
-	}
-	onDestroy(_dnd, session) {
-		const st = session?.cache?.__transform;
-		if (st) {
-			hideMarkline(st.guideX);
-			hideMarkline(st.guideY);
-			session.cache.__transform = void 0;
-		}
-	}
-	#computeMove(m, st) {
-		const scale = this.#getScaleRatio(st);
-		let x = st.start.x + m.dx / scale;
-		let y = st.start.y + m.dy / scale;
-		if (this.#opt.snapToGrid) {
-			x = st.start.x + calcGrid(x - st.start.x, this.#opt.gridX);
-			y = st.start.y + calcGrid(y - st.start.y, this.#opt.gridY);
-		}
-		st.data = {
-			...st.data,
-			x,
-			y
-		};
-		this.#markline(st);
-		this.#clampMove(st.data, st.boundary);
-	}
-	#computeRotate(m, st) {
-		const scale = this.#getScaleRatio(st);
-		const cRect = st.containerRect;
-		if (!cRect) return;
-		const mx = (m.x - cRect.left) / scale;
-		const my = (m.y - cRect.top) / scale;
-		let deg = angleToPointer(st.center.x, st.center.y, mx, my) - (st.rotateOffset ?? 0);
-		deg = (deg % 360 + 360) % 360;
-		if (this.#opt.rotateSnap) {
-			const step = Number(this.#opt.rotateStep) || 15;
-			deg = Math.round(deg / step) * step;
-		}
-		st.data = {
-			...st.data,
-			angle: deg
+			n?.ended && i.type === "rotate" && this.#e.resizable && g(r?.sourceEl) && this.#u(r.sourceEl, i.data?.angle || 0), r.cache.__transform = void 0;
+		}
+	}
+	onDestroy(e, t) {
+		let n = t?.cache?.__transform;
+		n && (Z(n.guideX), Z(n.guideY), t.cache.__transform = void 0);
+	}
+	#r(e, t) {
+		let n = this.#n(t), r = t.start.x + e.dx / n, i = t.start.y + e.dy / n;
+		this.#e.snapToGrid && (r = t.start.x + K(r - t.start.x, this.#e.gridX), i = t.start.y + K(i - t.start.y, this.#e.gridY)), t.data = {
+			...t.data,
+			x: r,
+			y: i
+		}, this.#s(t), this.#p(t.data, t.boundary);
+	}
+	#i(e, t) {
+		let n = this.#n(t), r = t.containerRect;
+		if (!r) return;
+		let i = (e.x - r.left) / n, a = (e.y - r.top) / n, o = J(t.center.x, t.center.y, i, a) - (t.rotateOffset ?? 0);
+		if (o = (o % 360 + 360) % 360, this.#e.rotateSnap) {
+			let e = Number(this.#e.rotateStep) || 15;
+			o = Math.round(o / e) * e;
+		}
+		t.data = {
+			...t.data,
+			angle: o
 		};
 	}
-	#computeResize(m, st) {
-		const scale = this.#getScaleRatio(st);
-		const ratio = this.#opt.aspectRatio;
-		const dx = m.dx / scale;
-		const dy = m.dy / scale;
-		const alpha = Math.atan2(dy, dx);
-		const deltaL = getLength(dx, dy);
-		const beta = alpha - toRad(st.start.angle);
-		const deltaW = deltaL * Math.cos(beta);
-		const deltaH = deltaL * Math.sin(beta);
-		const rect = {
-			centerX: st.start.x + st.start.width / 2,
-			centerY: st.start.y + st.start.height / 2,
-			height: st.start.height,
-			rotateAngle: st.start.angle,
-			width: st.start.width
+	#a(e, t) {
+		let n = this.#n(t), r = this.#e.aspectRatio, i = e.dx / n, a = e.dy / n, o = Math.atan2(a, i), s = me(i, a), c = o - G(t.start.angle), l = s * Math.cos(c), u = s * Math.sin(c), d = {
+			centerX: t.start.x + t.start.width / 2,
+			centerY: t.start.y + t.start.height / 2,
+			height: t.start.height,
+			rotateAngle: t.start.angle,
+			width: t.start.width
+		}, { position: { centerX: f, centerY: p }, size: { width: m, height: h } } = we(t.side, d, l, u, r, this.#e.minWidth, this.#e.minHeight), g = ge({
+			angle: t.data.angle,
+			centerX: f,
+			centerY: p,
+			height: h,
+			width: m
+		}), _ = {
+			...t.data,
+			...he(g, f, p)
 		};
-		const { position: { centerX, centerY }, size: { width: nw, height: nh } } = getNewStyle(st.side, rect, deltaW, deltaH, ratio, this.#opt.minWidth, this.#opt.minHeight);
-		const tl = centerToTL({
-			angle: st.data.angle,
-			centerX,
-			centerY,
-			height: nh,
-			width: nw
-		});
-		const next = {
-			...st.data,
-			...formatData(tl, centerX, centerY)
-		};
-		if (this.#opt.maxWidth > 0) next.width = Math.min(next.width, this.#opt.maxWidth);
-		if (this.#opt.maxHeight > 0) next.height = Math.min(next.height, this.#opt.maxHeight);
-		if (this.#opt.snapToGrid) {
-			const cx = next.x + next.width / 2;
-			const cy = next.y + next.height / 2;
-			const gx = this.#opt.gridX;
-			const gy = this.#opt.gridY;
-			let w = st.start.width + calcGrid(next.width - st.start.width, gx);
-			let h;
-			if (ratio) h = w / ratio;
-			else h = st.start.height + calcGrid(next.height - st.start.height, gy);
-			next.width = Math.abs(w);
-			next.height = Math.abs(h);
-			next.x = cx - next.width / 2;
-			next.y = cy - next.height / 2;
+		if (this.#e.maxWidth > 0 && (_.width = Math.min(_.width, this.#e.maxWidth)), this.#e.maxHeight > 0 && (_.height = Math.min(_.height, this.#e.maxHeight)), this.#e.snapToGrid) {
+			let e = _.x + _.width / 2, n = _.y + _.height / 2, i = this.#e.gridX, a = this.#e.gridY, o = t.start.width + K(_.width - t.start.width, i), s;
+			s = r ? o / r : t.start.height + K(_.height - t.start.height, a), _.width = Math.abs(o), _.height = Math.abs(s), _.x = e - _.width / 2, _.y = n - _.height / 2;
 		}
-		const tentativeData = next;
-		if (this.#clampResize(tentativeData, st.boundary)) {
-			st.data = tentativeData;
-			st.lastValidData = { ...tentativeData };
-		} else st.data = st.lastValidData ? { ...st.lastValidData } : { ...st.start };
-		this.#marklineResize(st);
-	}
-	#calcViewportRect(st) {
-		const d = st?.data;
-		const off = st?.viewportCenterOffset;
-		if (!d || !off) return st.startRect;
-		const rad = toRad(d.angle || 0);
-		const cos = Math.cos(rad);
-		const sin = Math.sin(rad);
-		const aabbW = Math.abs(d.width * cos) + Math.abs(d.height * sin);
-		const aabbH = Math.abs(d.width * sin) + Math.abs(d.height * cos);
-		const cx = d.x + d.width / 2 + off.x;
-		const cy = d.y + d.height / 2 + off.y;
-		const left = cx - aabbW / 2;
-		const top = cy - aabbH / 2;
+		let v = _;
+		this.#m(v, t.boundary) ? (t.data = v, t.lastValidData = { ...v }) : t.data = t.lastValidData ? { ...t.lastValidData } : { ...t.start }, this.#c(t);
+	}
+	#o(e) {
+		let t = e?.data, n = e?.viewportCenterOffset;
+		if (!t || !n) return e.startRect;
+		let r = G(t.angle || 0), i = Math.cos(r), a = Math.sin(r), o = Math.abs(t.width * i) + Math.abs(t.height * a), s = Math.abs(t.width * a) + Math.abs(t.height * i), c = t.x + t.width / 2 + n.x, l = t.y + t.height / 2 + n.y, u = c - o / 2, d = l - s / 2;
 		return {
-			bottom: top + aabbH,
-			height: aabbH,
-			left,
-			right: left + aabbW,
-			top,
-			width: aabbW
+			bottom: d + s,
+			height: s,
+			left: u,
+			right: u + o,
+			top: d,
+			width: o
 		};
 	}
-	#markline(st) {
-		if (!this.#opt.snap && !this.#opt.markline) return;
-		if (!st?.lines || !st.containerRectScaled) return;
-		const source = this.#calcViewportRect(st);
-		const lines = st.lines || {
+	#s(e) {
+		if (!this.#e.snap && !this.#e.markline || !e?.lines || !e.containerRectScaled) return;
+		let t = this.#o(e), n = e.lines || {
 			x: [],
 			y: []
-		};
-		const mark = {
+		}, r = {
 			diffX: 0,
 			diffY: 0,
 			left: void 0,
 			top: void 0
 		};
-		for (let i = 0; i < (lines.y.length || 0); i++) {
-			const { top, showTop } = lines.y[i];
-			const diff = top - source.top;
-			if (Math.abs(diff) < this.#opt.snapThreshold) {
-				mark.diffY = diff;
-				mark.top = showTop - st.containerRectScaled.top;
+		for (let i = 0; i < (n.y.length || 0); i++) {
+			let { top: a, showTop: o } = n.y[i], s = a - t.top;
+			if (Math.abs(s) < this.#e.snapThreshold) {
+				r.diffY = s, r.top = o - e.containerRectScaled.top;
 				break;
 			}
 		}
-		for (let i = 0; i < (lines.x.length || 0); i++) {
-			const { left, showLeft } = lines.x[i];
-			const diff = left - source.left;
-			if (Math.abs(diff) < this.#opt.snapThreshold) {
-				mark.diffX = diff;
-				mark.left = showLeft - st.containerRectScaled.left;
+		for (let i = 0; i < (n.x.length || 0); i++) {
+			let { left: a, showLeft: o } = n.x[i], s = a - t.left;
+			if (Math.abs(s) < this.#e.snapThreshold) {
+				r.diffX = s, r.left = o - e.containerRectScaled.left;
 				break;
 			}
 		}
-		if (this.#opt.snap) {
-			if (mark.diffX) st.data.x += mark.diffX;
-			if (mark.diffY) st.data.y += mark.diffY;
-		}
-		st.mark = mark;
+		this.#e.snap && (r.diffX && (e.data.x += r.diffX), r.diffY && (e.data.y += r.diffY)), e.mark = r;
 	}
-	#marklineResize(st) {
-		if (!this.#opt.snap && !this.#opt.markline) return;
-		if (!st?.targetRects || !st.containerRectScaled) return;
-		const mark = {
+	#c(e) {
+		if (!this.#e.snap && !this.#e.markline || !e?.targetRects || !e.containerRectScaled) return;
+		let t = {
 			diffX: 0,
 			diffY: 0,
 			left: void 0,
 			top: void 0
 		};
-		if ((st.data.angle || 0) !== 0 || this.#opt.aspectRatio) {
-			st.mark = mark;
+		if ((e.data.angle || 0) !== 0 || this.#e.aspectRatio) {
+			e.mark = t;
 			return;
 		}
-		const source = this.#calcViewportRect(st);
-		const { diffX, diffY, guideLeft, guideTop } = resolveResizeSnap({
-			side: st.side,
-			source,
-			targetRects: st.targetRects,
-			threshold: this.#opt.snapThreshold
+		let n = this.#o(e), { diffX: r, diffY: i, guideLeft: a, guideTop: o } = Ce({
+			side: e.side,
+			source: n,
+			targetRects: e.targetRects,
+			threshold: this.#e.snapThreshold
 		});
-		mark.diffX = diffX;
-		mark.diffY = diffY;
-		mark.left = guideLeft === void 0 ? void 0 : guideLeft - st.containerRectScaled.left;
-		mark.top = guideTop === void 0 ? void 0 : guideTop - st.containerRectScaled.top;
-		if (this.#opt.snap && (diffX || diffY)) {
-			const scale = this.#getScaleRatio(st);
-			const snapshot = { ...st.data };
-			const next = { ...st.data };
-			const side = st.side || "";
-			if (diffX) {
-				const dx = diffX / scale;
-				if (side.includes("left")) {
-					next.x += dx;
-					next.width -= dx;
-				} else if (side.includes("right")) next.width += dx;
+		if (t.diffX = r, t.diffY = i, t.left = a === void 0 ? void 0 : a - e.containerRectScaled.left, t.top = o === void 0 ? void 0 : o - e.containerRectScaled.top, this.#e.snap && (r || i)) {
+			let n = this.#n(e), a = { ...e.data }, o = { ...e.data }, s = e.side || "";
+			if (r) {
+				let e = r / n;
+				s.includes("left") ? (o.x += e, o.width -= e) : s.includes("right") && (o.width += e);
 			}
-			if (diffY) {
-				const dy = diffY / scale;
-				if (side.includes("top")) {
-					next.y += dy;
-					next.height -= dy;
-				} else if (side.includes("bottom")) next.height += dy;
+			if (i) {
+				let e = i / n;
+				s.includes("top") ? (o.y += e, o.height -= e) : s.includes("bottom") && (o.height += e);
 			}
-			let valid = next.width >= this.#opt.minWidth && next.height >= this.#opt.minHeight;
-			if (valid && this.#opt.maxWidth > 0 && next.width > this.#opt.maxWidth) valid = false;
-			if (valid && this.#opt.maxHeight > 0 && next.height > this.#opt.maxHeight) valid = false;
-			if (valid && !this.#clampResize(next, st.boundary)) valid = false;
-			if (valid) {
-				st.data = next;
-				st.lastValidData = { ...next };
-			} else {
-				st.data = snapshot;
-				mark.left = void 0;
-				mark.top = void 0;
-			}
-		}
-		st.mark = mark;
-	}
-	#commitMarkline(ctx, st) {
-		const { guideX, guideY } = st;
-		const mark = st.mark || {};
-		if (guideX) if (mark.left === void 0) ctx.frame?.setStyle?.(guideX, "display", "none");
-		else {
-			ctx.frame?.setStyle?.(guideX, "display", "block");
-			ctx.frame?.setStyle?.(guideX, "transform", `translate(${withUnit(mark.left)}, 0)`);
-		}
-		if (guideY) if (mark.top === void 0) ctx.frame?.setStyle?.(guideY, "display", "none");
-		else {
-			ctx.frame?.setStyle?.(guideY, "display", "block");
-			ctx.frame?.setStyle?.(guideY, "transform", `translate(0, ${withUnit(mark.top)})`);
+			let c = o.width >= this.#e.minWidth && o.height >= this.#e.minHeight;
+			c && this.#e.maxWidth > 0 && o.width > this.#e.maxWidth && (c = !1), c && this.#e.maxHeight > 0 && o.height > this.#e.maxHeight && (c = !1), c && !this.#m(o, e.boundary) && (c = !1), c ? (e.data = o, e.lastValidData = { ...o }) : (e.data = a, t.left = void 0, t.top = void 0);
 		}
+		e.mark = t;
 	}
-	#updateDotCursors(el, angle) {
-		const dots = findDots(el);
-		for (const dot of dots) {
-			const dir = dot?.dataset?.dir;
-			if (dir) dot.style.cursor = `${getCursor(angle, dir)}-resize`;
+	#l(e, t) {
+		let { guideX: n, guideY: r } = t, i = t.mark || {};
+		n && (i.left === void 0 ? e.frame?.setStyle?.(n, "display", "none") : (e.frame?.setStyle?.(n, "display", "block"), e.frame?.setStyle?.(n, "transform", `translate(${W(i.left)}, 0)`))), r && (i.top === void 0 ? e.frame?.setStyle?.(r, "display", "none") : (e.frame?.setStyle?.(r, "display", "block"), e.frame?.setStyle?.(r, "transform", `translate(0, ${W(i.top)})`)));
+	}
+	#u(e, t) {
+		let n = Te(e);
+		for (let e of n) {
+			let n = e?.dataset?.dir;
+			n && (e.style.cursor = `${xe(t, n)}-resize`);
 		}
 	}
-	#applyTransform(ctx, el, data) {
-		ctx.frame?.setStyle?.(el, "transform", `translate(${withUnit(data.x)}, ${withUnit(data.y)}) rotate(${data.angle}deg)`);
+	#d(e, t, n) {
+		e.frame?.setStyle?.(t, "transform", `translate(${W(n.x)}, ${W(n.y)}) rotate(${n.angle}deg)`);
 	}
-	#apply(ctx, el, st) {
-		const d = st.data;
-		if (st.lastAppliedW !== d.width) {
-			ctx.frame?.setStyle?.(el, "width", withUnit(d.width));
-			st.lastAppliedW = d.width;
-		}
-		if (st.lastAppliedH !== d.height) {
-			ctx.frame?.setStyle?.(el, "height", withUnit(d.height));
-			st.lastAppliedH = d.height;
-		}
-		if (st.lastAppliedX !== d.x || st.lastAppliedY !== d.y || st.lastAppliedAngle !== d.angle) {
-			this.#applyTransform(ctx, el, d);
-			st.lastAppliedX = d.x;
-			st.lastAppliedY = d.y;
-			st.lastAppliedAngle = d.angle;
-		}
+	#f(e, t, n) {
+		let r = n.data;
+		n.lastAppliedW !== r.width && (e.frame?.setStyle?.(t, "width", W(r.width)), n.lastAppliedW = r.width), n.lastAppliedH !== r.height && (e.frame?.setStyle?.(t, "height", W(r.height)), n.lastAppliedH = r.height), (n.lastAppliedX !== r.x || n.lastAppliedY !== r.y || n.lastAppliedAngle !== r.angle) && (this.#d(e, t, r), n.lastAppliedX = r.x, n.lastAppliedY = r.y, n.lastAppliedAngle = r.angle);
+	}
+	#p(e, t) {
+		if (!t) return;
+		let n = G(e.angle || 0), r = Math.abs(Math.cos(n)), i = Math.abs(Math.sin(n)), a = e.width * r + e.height * i, o = e.width * i + e.height * r, s = (a - e.width) / 2, c = t.w - a / 2 - e.width / 2, l = (o - e.height) / 2, u = t.h - o / 2 - e.height / 2;
+		e.x = Math.max(Math.min(s, c), Math.min(e.x, Math.max(s, c))), e.y = Math.max(Math.min(l, u), Math.min(e.y, Math.max(l, u)));
+	}
+	#m(e, t) {
+		if (!t) return !0;
+		let n = G(e.angle || 0), r = Math.abs(Math.cos(n)), i = Math.abs(Math.sin(n)), a = e.width * r + e.height * i, o = e.width * i + e.height * r, s = e.x + e.width / 2, l = e.y + e.height / 2, u = s - a / 2, d = s + a / 2, f = l - o / 2, p = l + o / 2, m = c;
+		return !(u < -m || f < -m || d > t.w + m || p > t.h + m);
 	}
-	#clampMove(d, boundary) {
-		if (!boundary) return;
-		const rad = toRad(d.angle || 0);
-		const cos = Math.abs(Math.cos(rad));
-		const sin = Math.abs(Math.sin(rad));
-		const aabbW = d.width * cos + d.height * sin;
-		const aabbH = d.width * sin + d.height * cos;
-		const minX = (aabbW - d.width) / 2;
-		const maxX = boundary.w - aabbW / 2 - d.width / 2;
-		const minY = (aabbH - d.height) / 2;
-		const maxY = boundary.h - aabbH / 2 - d.height / 2;
-		d.x = Math.max(Math.min(minX, maxX), Math.min(d.x, Math.max(minX, maxX)));
-		d.y = Math.max(Math.min(minY, maxY), Math.min(d.y, Math.max(minY, maxY)));
-	}
-	#clampResize(d, boundary) {
-		if (!boundary) return true;
-		const rad = toRad(d.angle || 0);
-		const cos = Math.abs(Math.cos(rad));
-		const sin = Math.abs(Math.sin(rad));
-		const aabbW = d.width * cos + d.height * sin;
-		const aabbH = d.width * sin + d.height * cos;
-		const cx = d.x + d.width / 2;
-		const cy = d.y + d.height / 2;
-		const left = cx - aabbW / 2;
-		const right = cx + aabbW / 2;
-		const top = cy - aabbH / 2;
-		const bottom = cy + aabbH / 2;
-		const t = CLAMP_TOLERANCE;
-		if (left < -t || top < -t || right > boundary.w + t || bottom > boundary.h + t) return false;
-		return true;
-	}
-	#disableMirrorNow(m) {
-		if (m?.mirrorEl) {
+	#h(e) {
+		if (e?.mirrorEl) {
 			try {
-				m.mirrorEl.parentNode?.removeChild?.(m.mirrorEl);
+				e.mirrorEl.parentNode?.removeChild?.(e.mirrorEl);
 			} catch {}
-			m.mirrorEl = void 0;
+			e.mirrorEl = void 0;
 		}
-		if (isHTMLElement(m?.sourceEl)) try {
-			m.sourceEl.style.visibility = "";
+		if (g(e?.sourceEl)) try {
+			e.sourceEl.style.visibility = "";
 		} catch {}
 	}
-	#disableIndicatorNow(m) {
-		if (m?.indicatorEl) {
+	#g(e) {
+		if (e?.indicatorEl) {
 			try {
-				m.indicatorEl.parentNode?.removeChild?.(m.indicatorEl);
+				e.indicatorEl.parentNode?.removeChild?.(e.indicatorEl);
 			} catch {}
-			m.indicatorEl = void 0;
-			m.indicatorRegion = void 0;
+			e.indicatorEl = void 0, e.indicatorRegion = void 0;
 		}
-		m.currentDrop = void 0;
-		m.currentDropRect = void 0;
-		m.currentAllowed = false;
+		e.currentDrop = void 0, e.currentDropRect = void 0, e.currentAllowed = !1;
 	}
-};
-//#endregion
-//#region src/version.js
-var DndVersion = {
+}, Ae = {
 	name: "@ptahjs/dnd",
-	version: "0.1.2"
+	version: "0.1.3"
 };
 //#endregion
-export { ACTIVE_WRAP_CLASS, ActiveSelectionService, AutoScrollService, DOT_CLASS, Dnd, DndVersion, DropIndicatorService, DropService, MarqueeSelectionService, MirrorService, ROTATE_CLASS, TransformControllerService, clearAll, setMultipleActive };
+export { P as ACTIVE_WRAP_CLASS, U as ActiveSelectionService, ie as AutoScrollService, F as DOT_CLASS, w as Dnd, Ae as DndVersion, le as DropIndicatorService, T as DropService, pe as MarqueeSelectionService, E as MirrorService, I as ROTATE_CLASS, ke as TransformControllerService, H as clearAll, V as setMultipleActive };