@ptahjs/dnd 0.1.0 → 0.1.2

package/dist/dnd.es.js

@@ -0,0 +1,3114 @@
+(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";
+//#region src/constant.js
+var ATTR = {
+	dataAttr: "data",
+	copyAttr: "copy",
+	dragAttr: "drag",
+	dragScopeAttr: "drag-scope",
+	dragdropAttr: "dragdrop",
+	dropAttr: "drop",
+	handleAttr: "drag-handle",
+	handleResizeAttr: "drag-handle-resize",
+	handleRotateAttr: "drag-handle-rotate",
+	namespaceAttr: "namespace",
+	dropIndicatorAttr: "drop-indicator",
+	ignoreClickAttr: "ignore-click",
+	ignoreMirrorAttr: "ignore-mirror",
+	resizableAttr: "resizable",
+	rotatableAttr: "rotatable",
+	scaleRatioAttr: "scale-ratio"
+};
+var CLASS_NAMES = {
+	canDrop: "dnd-canDrop",
+	noDrop: "dnd-noDrop",
+	dragging: "dnd-dragging",
+	mirror: "dnd-mirror",
+	active: "dnd-active",
+	dropIndicator: "dnd-indicator",
+	dropIndicatorActive: "dnd-indicator-active",
+	indicatorTop: "dnd-indicator--top",
+	indicatorRight: "dnd-indicator--right",
+	indicatorBottom: "dnd-indicator--bottom",
+	indicatorLeft: "dnd-indicator--left",
+	marquee: "dnd-marquee"
+};
+var VERT_SPLIT = .5;
+var HORIZ_SPLIT = 1 / 3;
+var THRESHOLDS = {
+	MARQUEE_MOVE: 5,
+	DRAG_START: 3
+};
+var AUTO_SCROLL = {
+	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;
+//#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
+	};
+	if (monitor?.cache) monitor.cache[fullCacheKey] = fns;
+	return fns;
+}
+//#endregion
+//#region src/utils/parseData.js
+/** 解析 data 属性内容（支持 JSON） */
+function parseData(raw) {
+	if (raw === void 0) return;
+	const s = String(raw).trim();
+	if (!s) return "";
+	try {
+		return JSON.parse(s);
+	} catch {
+		return s;
+	}
+}
+//#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);
+		return {
+			x: localPx / scale,
+			y: localPy / scale,
+			scale,
+			px: localPx,
+			py: localPy
+		};
+	};
+	const getDropData = () => {
+		const drop = monitor.currentDrop;
+		const cache = monitor.cache;
+		if (!drop) {
+			cache.dropDataEl = void 0;
+			cache.dropDataRaw = void 0;
+			cache.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;
+	};
+	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;
+		};
+	}
+	return {
+		type,
+		namespace: monitor.namespace,
+		data: monitor.data,
+		get dropData() {
+			return getDropData();
+		},
+		get dropPoint() {
+			return getDropWorldPoint();
+		},
+		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)
+	};
+}
+//#endregion
+//#region src/utils/createSession.js
+/**
+* 拖拽 session 状态（一次拖拽过程的运行时容器）
+*
+* 说明：
+* - session 是”短生命周期”：通常在一次 drag 开始创建/复用，结束后 reset。
+* - 为了兼容旧插件，这里保留了一些 legacy 字段（mirror/indicator/cache 等），
+*   同时新的运行时鼓励按 Measure / Compute / Commit 三阶段去组织逻辑。
+*/
+function createSession(store) {
+	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 用于区分指针 */
+		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 等逻辑） */
+		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,
+		/** 上一帧坐标（用于计算本帧是否移动、速度等） */
+		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,
+			/** 自动滚动计划（例如方向/速度/目标容器） */
+			autoScrollPlan: void 0,
+			/** 自动滚动上次执行时间（用于节流） */
+			autoScrollLastTs: 0
+		},
+		/** indicator 元素（用于显示插入线/高亮等） */
+		indicatorEl: void 0,
+		/** indicator 当前所在区域/位置描述（用于渲染插入位置等） */
+		indicatorRegion: void 0,
+		lastIndicatorRegion: void 0,
+		/**
+		* 持久化选中集（按 namespace 分组）
+		* 注意：这里不是复制数据，而是引用 store 里的 Map，
+		* 让多次拖拽 session 之间共享选中状态。
+		*/
+		selectedByNs: store?.selectedByNs,
+		/** 最近一次 drag 的时间戳（可用于双击抑制、节流等） */
+		lastDragTs: 0,
+		/** 是否抑制下一次 click（防止拖拽结束触发误点击） */
+		suppressNextClick: false
+	};
+}
+//#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;
+	};
+	return {
+		dnd,
+		session,
+		store,
+		frame,
+		adapter,
+		payload,
+		resetPayloadCache() {
+			payloadCache.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";
+}
+//#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;
+}
+//#endregion
+//#region src/utils/isHTMLElement.js
+function isHTMLElement(el) {
+	return el && typeof el === "object" && el.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));
+}
+//#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();
+	get frameId() {
+		return this.#frameId;
+	}
+	beginFrame() {
+		this.#frameId++;
+	}
+	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;
+			}
+			p = p.parentElement;
+		}
+	}
+	/**
+	* 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，则取消之
+	*/
+	cancel() {
+		if (!this.#running) return;
+		this.#running = false;
+		this.#pending = false;
+		if (this.#rafId) {
+			cancelAnimationFrame(this.#rafId);
+			this.#rafId = 0;
+		}
+	}
+	/**
+	* 每帧执行的 tick：
+	* - 消耗本帧的 pending
+	* - 执行 frameCb，并根据返回值决定是否继续下一帧
+	* - 若本帧执行期间又有人 request()，也会继续下一帧
+	*/
+	#tick = () => {
+		if (!this.#running) return;
+		this.#pending = false;
+		let keepGoing = false;
+		try {
+			keepGoing = Boolean(this.#frameCb(performance.now()));
+		} catch (err) {
+			keepGoing = false;
+			console.error("[RafScheduler] frame callback error:", err);
+		}
+		if (!this.#running) return;
+		if (keepGoing || this.#pending) {
+			this.#rafId = requestAnimationFrame(this.#tick);
+			return;
+		}
+		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
+		});
+	}
+	/**
+	* 销毁：
+	* - 解绑 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);
+	};
+	/**
+	* 绑定会话期的全局监听：
+	* - 这些监听使用 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
+		});
+	}
+	/**
+	* 清理当前会话状态（不负责解绑全局监听：由 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();
+			return;
+		}
+		this.#lastX = x;
+		this.#lastY = y;
+		this.#onMoveCb({
+			pointerId: event.pointerId,
+			x,
+			y,
+			event,
+			now
+		});
+		event.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?.();
+	};
+};
+//#endregion
+//#region src/core/FrameContext.js
+/**
+* FrameContext（帧上下文）
+*
+* 用于在每一帧中在各个插件之间共享的上下文数据。
+*
+* 插件约定：
+* - 只在 onMeasure 阶段读取 DOM（避免读写交错导致强制回流）
+* - 在 onCompute 阶段做纯计算（不触碰 DOM）
+* - 在 onCommit 阶段把 DOM 写操作通过 frame 入队（集中提交）
+*/
+var FrameContext = class {
+	scrolled = false;
+	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);
+	}
+	/**
+	* 提交本帧所有操作（按固定顺序执行，尽量避免冲突）
+	*/
+	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?.();
+	}
+};
+//#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;
+		}
+		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() 末尾调用。
+	*/
+	dispose() {
+		this.#plugins.length = 0;
+	}
+};
+//#endregion
+//#region src/core/State.js
+var State = class {
+	#store;
+	#session;
+	constructor({ store, session } = {}) {
+		this.#store = store;
+		this.#session = session;
+	}
+	get session() {
+		return this.#session;
+	}
+	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) {
+			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,
+					dx: 0,
+					dy: 0,
+					namespace: action.namespace,
+					data: action.data,
+					sourceEl: action.sourceEl,
+					handleEl: action.handleEl,
+					originDrop: action.originDrop,
+					currentDrop: void 0,
+					currentDropRect: void 0,
+					isDragScope: Boolean(action.isDragScope),
+					isCopy: Boolean(action.isCopy),
+					mirrorOffsetX: action.mirrorOffsetX ?? 0,
+					mirrorOffsetY: action.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
+				};
+			}
+			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
+				};
+				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
+				};
+			}
+			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
+				};
+			}
+			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;
+	renderMirror = void 0;
+	/** 当前 root */
+	get root() {
+		return this.#root;
+	}
+	/** 对外暴露 monitor（当前 session），用于观察拖拽状态 */
+	get monitor() {
+		if (this.#destroyed) return void 0;
+		return this.#state?.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
+		});
+	}
+	/**
+	* 销毁：
+	* - 解绑 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?.();
+	};
+	/**
+	* 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({
+			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({
+			dnd: this,
+			session: monitor,
+			store: this.#store,
+			frame: this.#frame,
+			adapter: this.#adapter
+		});
+		this.#runtime.onDown(ctx, event);
+		this.#frame.commit();
+		this.#adapter.endFrame();
+		return {
+			accepted: true,
+			pointerId: event.pointerId,
+			signal: monitor.dragAbort.signal
+		};
+	};
+	/**
+	* pointermove：
+	* - dispatch MOVE 到状态机（更新坐标、started/dirty 等）
+	* - startedNow：触发 onStart + emit dragstart
+	* - started：请求 rAF 进入 per-frame 驱动
+	*/
+	#onPointerMove = ({ pointerId, x, y }) => {
+		const effects = this.#state.dispatch({
+			type: "MOVE",
+			pointerId,
+			x,
+			y
+		});
+		if (!effects?.handled) return;
+		const monitor = this.#state.session;
+		if (effects.startedNow) {
+			const ctx = createContext({
+				dnd: this,
+				session: monitor,
+				store: this.#store,
+				frame: this.#frame,
+				adapter: this.#adapter
+			});
+			this.#runtime.onStart(ctx);
+			this.emit("dragstart", createPayload("dragstart", monitor));
+		}
+		if (effects.started) this.#scheduler.request();
+	};
+	/**
+	* pointerup / pointercancel / blur：
+	* - dispatch END 到状态机
+	* - 确保 drop 命中信息是最新的（避免最后一帧没跑）
+	* - 插件 onEnd 清理
+	* - 发出 drop/cancel 事件
+	* - abort 会话信号 & 重置 session
+	*/
+	#onPointerUp = ({ event, pointerId, reason }) => {
+		const effects = this.#state.dispatch({
+			type: "END",
+			pointerId,
+			reason
+		});
+		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({
+			dnd: this,
+			session: monitor,
+			store: this.#store,
+			frame: this.#frame,
+			adapter: this.#adapter
+		});
+		this.#runtime.onEnd(ctx, {
+			ended,
+			reason: reason || "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?.();
+	};
+	/**
+	* 单帧 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({
+			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;
+	};
+};
+//#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 {
+	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;
+			return;
+		}
+		if (m.cache?.dropRectDirty || !m.currentDropRect) {
+			m.currentDropRect = ctx.adapter.measureRect(drop);
+			m.cache.dropRectDirty = false;
+		}
+	}
+	/**
+	* 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;
+			return;
+		}
+		const fn = ctx.dnd?.canDrop;
+		if (typeof fn !== "function") {
+			m.currentAllowed = true;
+			return;
+		}
+		try {
+			m.currentAllowed = !!fn(ctx.payload("drag"));
+		} catch {
+			m.currentAllowed = false;
+		}
+	}
+	/**
+	* 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;
+	}
+	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;
+	}
+	onDestroy(_dnd, session) {
+		this.onEnd({ session });
+	}
+};
+//#endregion
+//#region src/services/MirrorService.js
+var MirrorService = 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`,
+			position: "fixed"
+		});
+		(ctx.dnd?.root || document.body).appendChild(m);
+		s.mirrorEl = m;
+	};
+	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)`);
+		}
+	};
+	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);
+	};
+	onDestroy = (_dnd, session) => {
+		this.onEnd({ session });
+	};
+};
+//#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;
+}
+function findScrollTarget(fromEl) {
+	let el = fromEl;
+	while (el) {
+		if (isScrollable(el)) return el;
+		el = el.parentElement;
+	}
+}
+function edgePlan(p, start, end, edge) {
+	if (p < start + edge) return {
+		dir: -1,
+		k: (start + edge - p) / edge
+	};
+	if (p > end - edge) return {
+		dir: 1,
+		k: (p - (end - edge)) / edge
+	};
+	return {
+		dir: 0,
+		k: 0
+	};
+}
+var AutoScrollService = 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 ? {
+			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,
+			behavior: "auto"
+		});
+		const scrolled = beforeTop !== targetEl.scrollTop || beforeLeft !== targetEl.scrollLeft;
+		if (scrolled && ctx.frame) ctx.frame.scrolled = true;
+		return scrolled;
+	};
+	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;
+		}
+	};
+};
+//#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([
+	"top",
+	"right",
+	"bottom",
+	"left"
+]);
+function toggle(ctx, el, cls, on) {
+	if (!isHTMLElement(el)) return;
+	ctx.frame.toggleClass(el, cls, !!on);
+}
+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);
+	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;
+}
+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 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 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";
+}
+/**
+* 获取当前 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;
+}
+var DropIndicatorService = 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);
+			}
+			m.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 });
+	}
+};
+//#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 [
+		["nw", "tl"],
+		["n", "tm"],
+		["ne", "tr"],
+		["e", "rm"],
+		["se", "br"],
+		["s", "bm"],
+		["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;
+}
+function removeWrap(el) {
+	if (!isHTMLElement(el)) return;
+	el.querySelector?.(`.${ACTIVE_WRAP_CLASS}`)?.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);
+		return;
+	}
+	if (!needWrap) {
+		if (hasWrap) removeWrap(el);
+		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
+		}));
+	}
+}
+/**
+* 清理一个选中值（可能是数组[多选]或单个元素）：移除 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 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 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 clearAll(map, namespace) {
+	if (namespace !== void 0) {
+		const val = map.get(namespace);
+		if (val) {
+			clearSelectionValue(val);
+			map.delete(namespace);
+		}
+		return;
+	}
+	for (const val of map.values()) clearSelectionValue(val);
+	map.clear();
+}
+var ActiveSelectionService = 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);
+				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);
+		}, {
+			capture: true,
+			signal
+		});
+	}
+	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);
+	}
+};
+//#endregion
+//#region src/services/MarqueeSelectionService.js
+function normalizeRect(x1, y1, x2, y2) {
+	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)
+	};
+}
+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;
+}
+var MarqueeSelectionService = 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);
+		}, {
+			capture: true,
+			signal
+		});
+	}
+	#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;
+			}
+			rootSignal?.removeEventListener?.("abort", onRootAbort);
+			try {
+				marquee.remove();
+			} catch (_) {}
+			sessionAbort.abort();
+		};
+		const processMove = () => {
+			rafId = 0;
+			const e = lastEvent;
+			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);
+			}
+			cleanup();
+		};
+		if (rootSignal?.aborted) {
+			cleanup();
+			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);
+		}
+		return selected;
+	}
+};
+//#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 toRad(deg) {
+	return deg * Math.PI / 180;
+}
+/**
+* 计算向量长度
+*/
+function getLength(x, y) {
+	return Math.sqrt(x * x + y * y);
+}
+/**
+* 网格吸附计算
+*/
+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 getRectByScale(el, scale = 1, adapter) {
+	const r = adapter.measureRect(el);
+	const s = Number(scale) || 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
+	};
+}
+/**
+* 计算指针相对中心点的角度
+*/
+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 formatData(data, cx, cy) {
+	const { width, height } = data;
+	return {
+		height: Math.abs(height),
+		width: Math.abs(width),
+		x: cx - Math.abs(width) / 2,
+		y: cy - Math.abs(height) / 2
+	};
+}
+/**
+* 中心点坐标转左上角坐标
+*/
+function centerToTL({ centerX, centerY, width, height, angle }) {
+	return {
+		angle,
+		height,
+		width,
+		x: centerX - width / 2,
+		y: centerY - height / 2
+	};
+}
+/**
+* 获取元素的 transform 信息
+*/
+function getElementTransformInfo(el) {
+	const style = getComputedStyle(el);
+	let matrix = {};
+	try {
+		matrix = new DOMMatrixReadOnly(style.transform);
+	} catch {
+		matrix = 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;
+	}
+	return {
+		angle: -Math.atan2(matrix.m21, matrix.m11) * (180 / Math.PI),
+		height,
+		width,
+		x,
+		y
+	};
+}
+//#endregion
+//#region src/services/transform/utils/cursor.js
+/**
+* 光标映射工具
+*/
+var resizableMap = {
+	e: "right",
+	n: "top",
+	ne: "top-right",
+	nw: "top-left",
+	s: "bottom",
+	se: "bottom-right",
+	sw: "bottom-left",
+	w: "left"
+};
+var cursorDir = [
+	"n",
+	"ne",
+	"e",
+	"se",
+	"s",
+	"sw",
+	"w",
+	"nw"
+];
+var cursorMap = {
+	0: 0,
+	1: 1,
+	2: 1,
+	3: 2,
+	4: 3,
+	5: 3,
+	6: 4,
+	7: 5,
+	8: 5,
+	9: 6,
+	10: 7,
+	11: 7
+};
+var cursorStartMap = {
+	e: 2,
+	n: 0,
+	ne: 1,
+	nw: 7,
+	s: 4,
+	se: 3,
+	sw: 5,
+	w: 6
+};
+/**
+* 根据旋转角度和方向获取光标样式
+*/
+function getCursor(angle, d) {
+	const inc = cursorMap[Math.floor((angle % 360 + 360) % 360 / 30)];
+	return cursorDir[(cursorStartMap[d] + inc) % 8];
+}
+//#endregion
+//#region src/services/transform/utils/markline.js
+/**
+* Markline（对齐辅助线）工具
+*/
+/**
+* 计算对齐线
+* @param {Array} list - 其他元素的位置信息列表
+* @param {Object} current - 当前元素的位置信息
+* @returns {Object} 对齐线信息
+*/
+function calcLines(list, current) {
+	const lines = {
+		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
+		});
+		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;
+}
+/**
+* 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 = {
+		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 = [
+				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;
+				break;
+			}
+			if (hit !== void 0) {
+				result.diffX = hit - edge;
+				result.guideLeft = hit;
+				break;
+			}
+		}
+	}
+	if (movesTop || movesBottom) {
+		const edge = movesTop ? source.top : source.bottom;
+		for (const t of targetRects) {
+			const candidates = [
+				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;
+				break;
+			}
+			if (hit !== void 0) {
+				result.diffY = hit - edge;
+				result.guideTop = hit;
+				break;
+			}
+		}
+	}
+	return result;
+}
+/**
+* 创建临时对齐线容器
+*/
+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 hideMarkline(el) {
+	if (!el) return;
+	el.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 setHeightAndDeltaH(height, deltaH, minHeight) {
+	const expected = height + deltaH;
+	if (expected > minHeight) height = expected;
+	else {
+		deltaH = minHeight - height;
+		height = minHeight;
+	}
+	return {
+		deltaH,
+		height
+	};
+}
+/**
+* 根据 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 ([
+		"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) {
+		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;
+			}
+			break;
+		case "top-right":
+			centerX += deltaW / 2 * cos + deltaH / 2 * sin;
+			centerY += deltaW / 2 * sin - deltaH / 2 * cos;
+			break;
+		case "bottom-right":
+			centerX += deltaW / 2 * cos - deltaH / 2 * sin;
+			centerY += deltaW / 2 * sin + deltaH / 2 * cos;
+			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;
+			}
+			break;
+		case "bottom-left":
+			centerX -= deltaW / 2 * cos + deltaH / 2 * sin;
+			centerY -= deltaW / 2 * sin - deltaH / 2 * cos;
+			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;
+			}
+			break;
+		case "top-left":
+			centerX -= deltaW / 2 * cos - deltaH / 2 * sin;
+			centerY -= deltaW / 2 * sin + deltaH / 2 * cos;
+			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;
+			}
+			break;
+		default: break;
+	}
+	return {
+		position: {
+			centerX,
+			centerY
+		},
+		size: {
+			height: height * hf,
+			width: width * wf
+		}
+	};
+}
+//#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`) || []] : [];
+}
+/**
+* 从 handle 元素获取 resize 方向
+*/
+function getResizeSideFromHandle(handleEl) {
+	const dir = handleEl?.dataset?.dir;
+	return dir && resizableMap[dir] || "right";
+}
+/**
+* 判断是否为 rotate handle
+*/
+function isRotateHandle(handleEl) {
+	return Boolean(handleEl?.hasAttribute?.(ATTR.handleRotateAttr));
+}
+/**
+* 判断是否为 resize handle
+*/
+function isResizeHandle(handleEl) {
+	return Boolean(handleEl?.hasAttribute?.(ATTR.handleResizeAttr));
+}
+//#endregion
+//#region src/services/TransformControllerService.js
+var TransformControllerService = class {
+	order = 25;
+	#opt;
+	constructor(options = {}) {
+		this.#opt = {
+			resizable: true,
+			rotatable: true,
+			/** 是否限制在 drag-scope 容器内 */
+			boundary: true,
+			/** 外层缩放比例（画布缩放） */
+			scaleRatio: 1,
+			/** 吸附到网格 */
+			snapToGrid: false,
+			gridX: 10,
+			gridY: 10,
+			/** resize 约束 */
+			aspectRatio: void 0,
+			minWidth: 10,
+			minHeight: 10,
+			maxWidth: 0,
+			maxHeight: 0,
+			/** rotate 吸附 */
+			rotateSnap: false,
+			rotateStep: 15,
+			/** markline + snap */
+			snap: true,
+			snapThreshold: 10,
+			markline: true,
+			/** 在 drag-scope 内默认关闭镜像与 drop 指示器 */
+			disableMirrorInScope: true,
+			disableDropIndicatorInScope: true,
+			/** 是否允许 transform（业务可覆写） */
+			canTransform: () => true,
+			...options
+		};
+	}
+	/**
+	* 获取当前 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 = {
+			phase: 0,
+			type,
+			side,
+			scaleRatio: void 0,
+			container: void 0,
+			containerRect: void 0,
+			containerRectScaled: void 0,
+			boundary: void 0,
+			start: void 0,
+			data: void 0,
+			center: void 0,
+			rotateOffset: 0,
+			startRect: void 0,
+			viewportCenterOffset: void 0,
+			lines: void 0,
+			guideX: void 0,
+			guideY: void 0,
+			mark: {
+				diffX: 0,
+				diffY: 0,
+				left: void 0,
+				top: void 0
+			},
+			didCompute: false,
+			lastValidData: void 0,
+			lastAppliedX: void 0,
+			lastAppliedY: void 0,
+			lastAppliedW: void 0,
+			lastAppliedH: void 0,
+			lastAppliedAngle: void 0,
+			multiSelection: {
+				enabled: isMultiSelect,
+				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;
+			return;
+		}
+		const container = ctx.adapter.closestDragScope(m.sourceEl);
+		if (!isHTMLElement(container)) {
+			m.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
+		};
+		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
+			};
+			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;
+			}
+		}
+		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
+				};
+				this.#applyTransform(ctx, el, newData);
+			}
+		}
+		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];
+					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))
+					};
+				})];
+				ctx.dnd?.emit?.("draggable:multi-drop", elements);
+			}
+		}
+		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
+		};
+	}
+	#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
+		};
+		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;
+		}
+		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;
+		return {
+			bottom: top + aabbH,
+			height: aabbH,
+			left,
+			right: left + aabbW,
+			top,
+			width: aabbW
+		};
+	}
+	#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 || {
+			x: [],
+			y: []
+		};
+		const mark = {
+			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;
+				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;
+				break;
+			}
+		}
+		if (this.#opt.snap) {
+			if (mark.diffX) st.data.x += mark.diffX;
+			if (mark.diffY) st.data.y += mark.diffY;
+		}
+		st.mark = mark;
+	}
+	#marklineResize(st) {
+		if (!this.#opt.snap && !this.#opt.markline) return;
+		if (!st?.targetRects || !st.containerRectScaled) return;
+		const mark = {
+			diffX: 0,
+			diffY: 0,
+			left: void 0,
+			top: void 0
+		};
+		if ((st.data.angle || 0) !== 0 || this.#opt.aspectRatio) {
+			st.mark = mark;
+			return;
+		}
+		const source = this.#calcViewportRect(st);
+		const { diffX, diffY, guideLeft, guideTop } = resolveResizeSnap({
+			side: st.side,
+			source,
+			targetRects: st.targetRects,
+			threshold: this.#opt.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 (diffY) {
+				const dy = diffY / scale;
+				if (side.includes("top")) {
+					next.y += dy;
+					next.height -= dy;
+				} else if (side.includes("bottom")) next.height += dy;
+			}
+			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)})`);
+		}
+	}
+	#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`;
+		}
+	}
+	#applyTransform(ctx, el, data) {
+		ctx.frame?.setStyle?.(el, "transform", `translate(${withUnit(data.x)}, ${withUnit(data.y)}) rotate(${data.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;
+		}
+	}
+	#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) {
+			try {
+				m.mirrorEl.parentNode?.removeChild?.(m.mirrorEl);
+			} catch {}
+			m.mirrorEl = void 0;
+		}
+		if (isHTMLElement(m?.sourceEl)) try {
+			m.sourceEl.style.visibility = "";
+		} catch {}
+	}
+	#disableIndicatorNow(m) {
+		if (m?.indicatorEl) {
+			try {
+				m.indicatorEl.parentNode?.removeChild?.(m.indicatorEl);
+			} catch {}
+			m.indicatorEl = void 0;
+			m.indicatorRegion = void 0;
+		}
+		m.currentDrop = void 0;
+		m.currentDropRect = void 0;
+		m.currentAllowed = false;
+	}
+};
+//#endregion
+//#region src/version.js
+var DndVersion = {
+	name: "@ptahjs/dnd",
+	version: "0.1.2"
+};
+//#endregion
+export { ACTIVE_WRAP_CLASS, ActiveSelectionService, AutoScrollService, DOT_CLASS, Dnd, DndVersion, DropIndicatorService, DropService, MarqueeSelectionService, MirrorService, ROTATE_CLASS, TransformControllerService, clearAll, setMultipleActive };