@unicom-cloud/ui 0.8.168 → 0.8.170

package/draw/element/bounds.js

@@ -0,0 +1,492 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { degreesToRadians as e } from "../libs/math/angle.js";
+import { pointDistance as t, pointFrom as n, pointFromArray as r, pointRotateRads as i } from "../libs/math/point.js";
+import { lineSegment as a } from "../libs/math/segment.js";
+import "../libs/math/index.js";
+import { rescalePoints as o } from "../common/points.js";
+import { arrayToMap as s, invariant as c, sizeOf as l } from "../common/utils.js";
+import "../common/index.js";
+import { pointsOnBezierCurves as u } from "../libs/points-on-curve/index.js";
+import d from "../libs/roughjs/rough.js";
+import { getCurvePathOps as f } from "../utils/shape.js";
+import { isArrowElement as p, isBoundToContainer as m, isFreeDrawElement as h, isLineElement as g, isLinearElement as _, isTextElement as v } from "./typeChecks.js";
+import { getBoundTextElement as y, getContainerElement as b } from "./textElement.js";
+import { ShapeCache as x, generateRoughOptions as S, getElementShape as C } from "./shape.js";
+import { deconstructDiamondElement as w, deconstructRectanguloidElement as T } from "./utils.js";
+import { LinearElementEditor as E } from "./linearElementEditor.js";
+//#region components/pc/draw/element/bounds.ts
+var D = class e {
+	static #e = /* @__PURE__ */ new WeakMap();
+	static #t = /* @__PURE__ */ new WeakMap();
+	static getBounds(t, n, r = !1) {
+		let i = r && t.angle !== 0 ? e.#t.get(t) : e.#e.get(t);
+		if (i?.version && i.version === t.version && !m(t)) return i.bounds;
+		if (r && t.angle !== 0) {
+			let r = e.#n({
+				...t,
+				angle: 0
+			}, n);
+			return e.#t.set(t, {
+				version: t.version,
+				bounds: r
+			}), r;
+		}
+		let a = e.#n(t, n);
+		return e.#e.set(t, {
+			version: t.version,
+			bounds: a
+		}), a;
+	}
+	static #n(e, t) {
+		let r, [a, o, s, c, l, u] = O(e, t);
+		if (h(e)) {
+			let [t, r, a, o] = z(e.points.map(([t, r]) => i(n(t, r), n(l - e.x, u - e.y), e.angle)));
+			return [
+				t + e.x,
+				r + e.y,
+				a + e.x,
+				o + e.y
+			];
+		} else if (_(e)) r = G(e, l, u, t);
+		else if (e.type === "diamond") {
+			let [t, d] = i(n(l, o), n(l, u), e.angle), [f, p] = i(n(l, c), n(l, u), e.angle), [m, h] = i(n(a, u), n(l, u), e.angle), [g, _] = i(n(s, u), n(l, u), e.angle);
+			r = [
+				Math.min(t, f, m, g),
+				Math.min(d, p, h, _),
+				Math.max(t, f, m, g),
+				Math.max(d, p, h, _)
+			];
+		} else if (e.type === "ellipse") {
+			let t = (s - a) / 2, n = (c - o) / 2, i = Math.cos(e.angle), d = Math.sin(e.angle), f = Math.hypot(t * i, n * d), p = Math.hypot(n * i, t * d);
+			r = [
+				l - f,
+				u - p,
+				l + f,
+				u + p
+			];
+		} else {
+			let [t, d] = i(n(a, o), n(l, u), e.angle), [f, p] = i(n(a, c), n(l, u), e.angle), [m, h] = i(n(s, c), n(l, u), e.angle), [g, _] = i(n(s, o), n(l, u), e.angle);
+			r = [
+				Math.min(t, f, m, g),
+				Math.min(d, p, h, _),
+				Math.max(t, f, m, g),
+				Math.max(d, p, h, _)
+			];
+		}
+		return r;
+	}
+}, O = (e, t, n = !1) => {
+	if (h(e)) return B(e);
+	if (_(e)) return E.getElementAbsoluteCoords(e, t, n);
+	if (v(e)) {
+		let n = t ? b(e, t) : null;
+		if (p(n)) {
+			let { x: r, y: i } = E.getBoundTextElementPosition(n, e, t);
+			return [
+				r,
+				i,
+				r + e.width,
+				i + e.height,
+				r + e.width / 2,
+				i + e.height / 2
+			];
+		}
+	}
+	return [
+		e.x,
+		e.y,
+		e.x + e.width,
+		e.y + e.height,
+		e.x + e.width / 2,
+		e.y + e.height / 2
+	];
+}, k = (e, t) => {
+	let r = C(e, t), [o, s, c, l, d, f] = O(e, t), m = n(d, f);
+	if (r.type === "polycurve") {
+		let t = r.data.map((e) => u(e, 10)), i = [];
+		if (g(e) && !e.polygon || p(e)) for (let e of t) {
+			let t = 0;
+			for (; t < e.length - 1;) i.push(a(n(e[t][0], e[t][1]), n(e[t + 1][0], e[t + 1][1]))), t++;
+		}
+		else {
+			let e = t.flat(), r = 0;
+			for (; r < e.length - 1;) i.push(a(n(e[r][0], e[r][1]), n(e[r + 1][0], e[r + 1][1]))), r++;
+		}
+		return i;
+	} else if (r.type === "polyline") return r.data;
+	else if (A(e)) {
+		let [t, n] = T(e), r = n.map((t) => M(t, m, e.angle)).flat();
+		return [...j(t, m, e.angle), ...r];
+	} else if (e.type === "diamond") {
+		let [t, n] = w(e), r = n.map((t) => M(t, m, e.angle)).flat();
+		return [...j(t, m, e.angle), ...r];
+	} else if (r.type === "polygon") {
+		if (v(e)) {
+			let r = b(e, t);
+			if (r && _(r)) return [
+				a(n(o, s), n(c, s)),
+				a(n(c, s), n(c, l)),
+				a(n(c, l), n(o, l)),
+				a(n(o, l), n(o, s))
+			];
+		}
+		let i = r.data, u = [];
+		for (let e = 0; e < i.length - 1; e++) u.push(a(i[e], i[e + 1]));
+		return u;
+	} else if (r.type === "ellipse") return N(e);
+	let [h, y, x, S, , , E, D] = [
+		[o, s],
+		[c, s],
+		[o, l],
+		[c, l],
+		[d, s],
+		[d, l],
+		[o, f],
+		[c, f]
+	].map((t) => i(t, m, e.angle));
+	return [
+		a(h, y),
+		a(x, S),
+		a(h, x),
+		a(y, S),
+		a(h, D),
+		a(x, D),
+		a(y, E),
+		a(S, E)
+	];
+}, A = (e) => e != null && (e.type === "rectangle" || e.type === "image" || e.type === "iframe" || e.type === "embeddable" || e.type === "frame" || e.type === "magicframe" || e.type === "text" && !e.containerId), j = (e, t, n) => e.map((e) => a(i(e[0], t, n), i(e[1], t, n))), M = (e, t, r) => {
+	let o = u(e, 10), s = 0, c = [];
+	for (; s < o.length - 1;) c.push(a(i(n(o[s][0], o[s][1]), t, r), i(n(o[s + 1][0], o[s + 1][1]), t, r))), s++;
+	return c;
+}, N = (e) => {
+	let t = n(e.x + e.width / 2, e.y + e.height / 2), r = e.width / 2, o = e.height / 2, s = [], c = [], l = Math.PI * 2 / 90;
+	for (let a = 0; a < 90; a++) {
+		let s = a * l, u = t[0] + r * Math.cos(s), d = t[1] + o * Math.sin(s);
+		c.push(i(n(u, d), t, e.angle));
+	}
+	for (let e = 0; e < c.length - 1; e++) s.push(a(c[e], c[e + 1]));
+	return s.push(a(c[c.length - 1], c[0])), s;
+}, P = (e) => {
+	let t = Math.floor(e.width / 2) + 1, n = e.width, r = Math.floor(e.height / 2) + 1;
+	return [
+		t,
+		0,
+		n,
+		r,
+		t,
+		e.height,
+		0,
+		r
+	];
+}, F = (e, t, n, r, i) => {
+	let a = 1 - e;
+	return a ** 3 * t + 3 * a ** 2 * e * n + 3 * a * e ** 2 * r + e ** 3 * i;
+}, I = (e, t, n, r) => {
+	let i = t - e, a = n - t, o = r - n, s = 3 * i - 6 * a + 3 * o, c = 6 * a - 6 * i, l = 3 * i, u = c * c - 4 * s * l;
+	if (!(u >= 0)) return !1;
+	let d = null, f = null, p = Infinity, m = Infinity;
+	return s === 0 ? p = m = -l / c : (p = (-c + Math.sqrt(u)) / (2 * s), m = (-c - Math.sqrt(u)) / (2 * s)), p >= 0 && p <= 1 && (d = F(p, e, t, n, r)), m >= 0 && m <= 1 && (f = F(m, e, t, n, r)), [d, f];
+}, L = (e, t, n, r) => {
+	let i = I(e[0], t[0], n[0], r[0]), a = I(e[1], t[1], n[1], r[1]), o = Math.min(e[0], r[0]), s = Math.max(e[0], r[0]);
+	if (i) {
+		let e = i.filter((e) => e !== null);
+		o = Math.min(o, ...e), s = Math.max(s, ...e);
+	}
+	let c = Math.min(e[1], r[1]), l = Math.max(e[1], r[1]);
+	if (a) {
+		let e = a.filter((e) => e !== null);
+		c = Math.min(c, ...e), l = Math.max(l, ...e);
+	}
+	return [
+		o,
+		c,
+		s,
+		l
+	];
+}, R = (e, t) => {
+	let i = n(0, 0), { minX: a, minY: o, maxX: s, maxY: l } = e.reduce((e, { op: a, data: o }) => {
+		if (a === "move") {
+			let e = r(o);
+			c(e != null, "Op data is not a point"), i = e;
+		} else if (a === "bcurveTo") {
+			let r = n(o[0], o[1]), a = n(o[2], o[3]), s = n(o[4], o[5]), c = t ? t(r) : r, l = t ? t(a) : a, u = t ? t(s) : s, d = t ? t(i) : i;
+			i = s;
+			let [f, p, m, h] = L(d, c, l, u);
+			e.minX = Math.min(e.minX, f), e.minY = Math.min(e.minY, p), e.maxX = Math.max(e.maxX, m), e.maxY = Math.max(e.maxY, h);
+		}
+		return e;
+	}, {
+		minX: Infinity,
+		minY: Infinity,
+		maxX: -Infinity,
+		maxY: -Infinity
+	});
+	return [
+		a,
+		o,
+		s,
+		l
+	];
+}, z = (e) => {
+	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity;
+	for (let [a, o] of e) t = Math.min(t, a), n = Math.min(n, o), r = Math.max(r, a), i = Math.max(i, o);
+	return [
+		t,
+		n,
+		r,
+		i
+	];
+}, B = (e) => {
+	let [t, n, r, i] = z(e.points), a = t + e.x, o = n + e.y, s = r + e.x, c = i + e.y;
+	return [
+		a,
+		o,
+		s,
+		c,
+		(a + s) / 2,
+		(o + c) / 2
+	];
+}, V = (e) => {
+	switch (e) {
+		case "arrow": return 25;
+		case "diamond":
+		case "diamond_outline": return 12;
+		case "crowfoot_many":
+		case "crowfoot_one":
+		case "crowfoot_one_or_many": return 20;
+		default: return 15;
+	}
+}, H = (e) => {
+	switch (e) {
+		case "bar": return 90;
+		case "arrow": return 20;
+		default: return 25;
+	}
+}, U = (t, a, o, s) => {
+	if (a.length < 1) return null;
+	let l = f(a[0]);
+	if (l.length < 1) return null;
+	let u = o === "start" ? 1 : l.length - 1, d = l[u].data;
+	c(d.length === 6, "Op data length is not 6");
+	let p = n(d[4], d[5]), m = n(d[2], d[3]), h = n(d[0], d[1]), g = l[u - 1], _ = n(0, 0);
+	if (g.op === "move") {
+		let e = r(g.data);
+		c(e != null, "Op data is not a point"), _ = e;
+	} else g.op === "bcurveTo" && (_ = n(g.data[4], g.data[5]));
+	let v = (e, t) => (1 - e) ** 3 * p[t] + 3 * e * (1 - e) ** 2 * m[t] + 3 * e ** 2 * (1 - e) * h[t] + _[t] * e ** 3, [y, b] = o === "start" ? _ : p, [x, S] = [v(.3, 0), v(.3, 1)], C = Math.hypot(y - x, b - S), w = (y - x) / C, T = (b - S) / C, E = V(s), D = 0;
+	{
+		let [e, n] = o === "end" ? t.points[t.points.length - 1] : t.points[0], [r, i] = t.points.length > 1 ? o === "end" ? t.points[t.points.length - 2] : t.points[1] : [0, 0];
+		D = Math.hypot(e - r, n - i);
+	}
+	let O = Math.min(E, D * (s === "diamond" || s === "diamond_outline" ? .25 : .5)), k = y - w * O, A = b - T * O;
+	if (s === "dot" || s === "circle" || s === "circle_outline") return [
+		y,
+		b,
+		Math.hypot(A - b, k - y) + t.strokeWidth - 2
+	];
+	let j = H(s);
+	if (s === "crowfoot_many" || s === "crowfoot_one_or_many") {
+		let [t, r] = i(n(y, b), n(k, A), e(-j)), [a, o] = i(n(y, b), n(k, A), e(j));
+		return [
+			k,
+			A,
+			t,
+			r,
+			a,
+			o
+		];
+	}
+	let [M, N] = i(n(k, A), n(y, b), -j * Math.PI / 180), [P, F] = i(n(k, A), n(y, b), e(j));
+	if (s === "diamond" || s === "diamond_outline") {
+		let e, r;
+		if (o === "start") {
+			let [a, o] = t.points.length > 1 ? t.points[1] : [0, 0];
+			[e, r] = i(n(y + O * 2, b), n(y, b), Math.atan2(o - b, a - y));
+		} else {
+			let [a, o] = t.points.length > 1 ? t.points[t.points.length - 2] : [0, 0];
+			[e, r] = i(n(y - O * 2, b), n(y, b), Math.atan2(b - o, y - a));
+		}
+		return [
+			y,
+			b,
+			M,
+			N,
+			e,
+			r,
+			P,
+			F
+		];
+	}
+	return [
+		y,
+		b,
+		M,
+		N,
+		P,
+		F
+	];
+}, W = (e) => {
+	let t = d.generator(), n = S(e);
+	return t[e.roundness ? "curve" : n.fill ? "polygon" : "linearPath"](e.points, n);
+}, G = (e, t, r, a) => {
+	let o = y(e, a);
+	if (e.points.length < 2) {
+		let [s, c] = e.points[0], [l, u] = i(n(e.x + s, e.y + c), n(t, r), e.angle), d = [
+			l,
+			u,
+			l,
+			u
+		];
+		if (o) {
+			let t = E.getMinMaxXYWithBoundText(e, a, [
+				l,
+				u,
+				l,
+				u
+			], o);
+			d = [
+				t[0],
+				t[1],
+				t[2],
+				t[3]
+			];
+		}
+		return d;
+	}
+	let s = R(f(x.get(e, null)?.[0] ?? W(e)), ([a, o]) => i(n(e.x + a, e.y + o), n(t, r), e.angle)), c = [
+		s[0],
+		s[1],
+		s[2],
+		s[3]
+	];
+	if (o) {
+		let t = E.getMinMaxXYWithBoundText(e, a, c, o);
+		c = [
+			t[0],
+			t[1],
+			t[2],
+			t[3]
+		];
+	}
+	return c;
+}, K = (e, t, n = !1) => D.getBounds(e, t, n), q = (e, t) => {
+	if (!l(e)) return [
+		0,
+		0,
+		0,
+		0
+	];
+	let n = Infinity, r = -Infinity, i = Infinity, a = -Infinity, o = t || s(e);
+	return e.forEach((e) => {
+		let [t, s, c, l] = K(e, o);
+		n = Math.min(n, t), i = Math.min(i, s), r = Math.max(r, c), a = Math.max(a, l);
+	}), [
+		n,
+		i,
+		r,
+		a
+	];
+}, J = (e, t) => {
+	let [n, r, i, a] = q(e);
+	return [
+		n + t.x,
+		r + t.y,
+		i + t.x,
+		a + t.y
+	];
+}, Y = (e, t, n, r) => {
+	if (!(_(e) || h(e))) return [
+		e.x,
+		e.y,
+		e.x + t,
+		e.y + n
+	];
+	let i = o(0, t, o(1, n, e.points, r), r), a;
+	if (h(e)) a = z(i);
+	else {
+		let t = d.generator();
+		a = R(f(e.roundness ? t.curve(i, S(e)) : t.linearPath(i, S(e))));
+	}
+	let [s, c, l, u] = a;
+	return [
+		s + e.x,
+		c + e.y,
+		l + e.x,
+		u + e.y
+	];
+}, X = (e, t) => {
+	let n = d.generator(), [r, i, a, o] = R(f(e.roundness == null ? n.linearPath(t, S(e)) : n.curve(t, S(e))));
+	return [
+		r + e.x,
+		i + e.y,
+		a + e.x,
+		o + e.y
+	];
+}, Z = (e, r) => {
+	if (!e.length) return [
+		0,
+		0,
+		0,
+		0
+	];
+	let i = Infinity, a = e[0], o = s(e);
+	return e.forEach((e) => {
+		let [s, c, l, u] = K(e, o), d = t(n((s + l) / 2, (c + u) / 2), n(r.x, r.y));
+		d < i && (i = d, a = e);
+	}), K(a, o);
+}, ee = (e) => {
+	let [t, n, r, i] = q(e);
+	return {
+		minX: t,
+		minY: n,
+		maxX: r,
+		maxY: i,
+		width: r - t,
+		height: i - n,
+		midX: (t + r) / 2,
+		midY: (n + i) / 2
+	};
+}, te = ({ scrollX: e, scrollY: t, width: n, height: r, zoom: i }) => [
+	-e,
+	-t,
+	-e + n / i.value,
+	-t + r / i.value
+], Q = (e) => n(e[0] + (e[2] - e[0]) / 2, e[1] + (e[3] - e[1]) / 2), ne = (e, t, r) => {
+	let a = {
+		minX: e.x,
+		minY: e.y,
+		maxX: e.x + e.width,
+		maxY: e.y + e.height,
+		midX: e.x + e.width / 2,
+		midY: e.y + e.height / 2
+	}, o = $(e, t), [s, c] = i(n(a.minX, a.minY), o, e.angle), [l, u] = i(n(a.maxX, a.minY), o, e.angle), [d, f] = i(n(a.maxX, a.maxY), o, e.angle), [p, m] = i(n(a.minX, a.maxY), o, e.angle), h = [
+		Math.min(s, l, d, p),
+		Math.min(c, u, f, m),
+		Math.max(s, l, d, p),
+		Math.max(c, u, f, m)
+	];
+	if (r) {
+		let [e, t, n, i] = r;
+		return [
+			h[0] - i,
+			h[1] - e,
+			h[2] + t,
+			h[3] + n
+		];
+	}
+	return h;
+}, re = (e, t) => e[0] > t[0] && e[0] < t[2] && e[1] > t[1] && e[1] < t[3], ie = (e, t) => {
+	if (e == null || t == null) return !1;
+	let [n, r, i, a] = e, [o, s, c, l] = t;
+	return n < c && i > o && r < l && a > s;
+}, $ = (e, t, r = 0, i = 0) => {
+	if (_(e)) {
+		let [a, o, s, c] = O(e, t), [l, u] = n((a + s) / 2, (o + c) / 2);
+		return n(l + r, u + i);
+	}
+	let [a, o] = Q(K(e, t));
+	return n(a + r, o + i);
+};
+//#endregion
+export { D as ElementBounds, ne as aabbForElement, ie as doBoundsIntersect, $ as elementCenterPoint, H as getArrowheadAngle, U as getArrowheadPoints, V as getArrowheadSize, z as getBoundsFromPoints, Q as getCenterForBounds, Z as getClosestElementBounds, ee as getCommonBoundingBox, q as getCommonBounds, L as getCubicBezierCurveBound, P as getDiamondPoints, J as getDraggedElementsBounds, O as getElementAbsoluteCoords, K as getElementBounds, k as getElementLineSegments, X as getElementPointsCoords, R as getMinMaxXYFromCurvePathOps, Y as getResizedElementAbsoluteCoords, te as getVisibleSceneBounds, re as pointInsideBounds };
+/* 独立思考，明辨是非 */

package/draw/element/collision.d.ts

@@ -0,0 +1,37 @@
+import type { FrameNameBounds } from '../interface';
+import type { GlobalPoint, LineSegment } from '../libs/math';
+import type { DrawArrowElement, DrawBindableElement, DrawElement, ElementsMap, NonDeleted, NonDeletedDrawElement, NonDeletedSceneElementsMap, Ordered } from './types';
+export declare const shouldTestInside: (element: DrawElement) => boolean;
+export type HitTestArgs = {
+    point: GlobalPoint;
+    element: DrawElement;
+    threshold: number;
+    elementsMap: ElementsMap;
+    frameNameBound?: FrameNameBounds | null;
+    overrideShouldTestInside?: boolean;
+};
+export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, overrideShouldTestInside, }: HitTestArgs) => boolean;
+export declare const hitElementBoundingBox: (point: GlobalPoint, element: DrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
+export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
+export declare const hitElementBoundText: (point: GlobalPoint, element: DrawElement, elementsMap: ElementsMap) => boolean;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedDrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<DrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedDrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<DrawBindableElement> | null;
+export declare const getHoveredElementForFocusPoint: (point: GlobalPoint, arrow: DrawArrowElement, elements: readonly Ordered<NonDeletedDrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => DrawBindableElement | null;
+/**
+ * Intersect a line with an element for binding test
+ *
+ * @param element
+ * @param line
+ * @param offset
+ * @returns
+ */
+export declare const intersectElementWithLineSegment: (element: DrawElement, elementsMap: ElementsMap, line: LineSegment<GlobalPoint>, offset?: number, onlyFirst?: boolean) => GlobalPoint[];
+/**
+ * Check if the given point is considered inside the element's border
+ *
+ * @param point
+ * @param element
+ * @returns
+ */
+export declare const isPointInElement: (point: GlobalPoint, element: DrawElement, elementsMap: ElementsMap) => boolean;
+export declare const isBindableElementInsideOtherBindable: (innerElement: DrawBindableElement, outerElement: DrawBindableElement, elementsMap: ElementsMap) => boolean;

package/draw/element/collision.js

@@ -0,0 +1,179 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { isTransparent as e } from "../common/colors.js";
+import { vectorFromPoint as t, vectorNormalize as n, vectorScale as r } from "../libs/math/vector.js";
+import { isPointWithinBounds as i, pointFrom as a, pointFromVector as o, pointRotateRads as s, pointsEqual as c } from "../libs/math/point.js";
+import { curveIntersectLineSegment as l } from "../libs/math/curve.js";
+import { ellipse as u, ellipseSegmentInterceptPoints as d } from "../libs/math/ellipse.js";
+import { lineSegment as f, lineSegmentIntersectionPoints as p } from "../libs/math/segment.js";
+import "../libs/math/index.js";
+import { invariant as m } from "../common/utils.js";
+import "../common/index.js";
+import { hasBoundTextElement as h, isBindableElement as g, isFrameLikeElement as _, isFreeDrawElement as ee, isIframeLikeElement as v, isImageElement as te, isLinearElement as y, isTextElement as b } from "./typeChecks.js";
+import { getBoundTextElement as x } from "./textElement.js";
+import { deconstructDiamondElement as S, deconstructLinearOrFreeDrawElement as C, deconstructRectanguloidElement as w, isPathALoop as T } from "./utils.js";
+import { distanceToElement as E } from "./distance.js";
+import { getBindingGap as D } from "./binding.js";
+import { LinearElementEditor as O } from "./linearElementEditor.js";
+import { doBoundsIntersect as k, elementCenterPoint as A, getCenterForBounds as j, getCubicBezierCurveBound as M, getDiamondPoints as N, getElementBounds as P, pointInsideBounds as F } from "./bounds.js";
+//#region components/pc/draw/element/collision.ts
+var I = (t) => {
+	if (t.type === "arrow") return !1;
+	let n = !e(t.backgroundColor) || h(t) || v(t) || b(t);
+	return t.type === "line" || t.type === "freedraw" ? n && T(t.points) : n || te(t);
+}, L = null, R = null, z = Infinity, B = !1, V = !1, H = ({ point: e, element: t, threshold: n, elementsMap: r, frameNameBound: o = null, overrideShouldTestInside: l = !1 }) => {
+	if (L && c(e, L) && z <= n && l === V) {
+		let e = R?.deref?.();
+		if (e && e.id === t.id && e.version === t.version && e.versionNonce === t.versionNonce) return B;
+	}
+	let u = o ? i(a(o.x - n, o.y - n), e, a(o.x + o.width + n, o.y + o.height + n)) : !1, d = P(t, r, !0);
+	if (!i(a(d[0] - n, d[1] - n), s(e, j(d), -t.angle), a(d[2] + n, d[3] + n)) && !u) return !1;
+	let f = (l || I(t)) && $(e, t, r) || oe(e, t, r, n) || u;
+	return L = e, R = new WeakRef(t), z = n, V = l, B = f, f;
+}, U = (e, t, n, r = 0) => {
+	let [o, s, c, l] = P(t, n);
+	return o -= r, s -= r, c += r, l += r, i(a(o, s), e, a(c, l));
+}, W = (e, t) => !H(e) && !G(e.point, e.element, t) && U(e.point, e.element, t), G = (e, t, n) => {
+	let r = x(t, n);
+	return r ? $(e, y(t) ? {
+		...r,
+		...O.getBoundTextElementPosition(t, r, n)
+	} : r, n) : !1;
+}, K = (e, [t, n], r, i = 0) => {
+	let o = a(t, n), s = !_(e), c = Math.max(1, i);
+	if (!k([
+		t - c,
+		n - c,
+		t + c,
+		n + c
+	], P(e, r))) return !1;
+	if (e.frameId) {
+		let t = r.get(e.frameId);
+		if (t && _(t) && !F(o, P(t, r))) return !1;
+	}
+	let l = X(e, r, f(A(e, r), o)), u = E(e, r, o);
+	return s ? l.length === 0 || u <= i : l.length > 0 && u <= c;
+}, q = (t, n, r, i) => {
+	let a = [];
+	for (let o = n.length - 1; o >= 0; --o) {
+		let s = n[o];
+		if (m(!s.isDeleted, "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements"), g(s, !1) && K(s, t, r, i) && (a.push(s), !e(s.backgroundColor))) break;
+	}
+	return a;
+}, J = (e, t, n, r) => {
+	let i = q(e, t, n, r);
+	return !i || i.length === 0 ? null : i.length === 1 ? i[0] : i.sort((e, t) => t.width ** 2 + t.height ** 2 - (e.width ** 2 + e.height ** 2)).pop();
+}, Y = (e, t, n, r, i) => {
+	let a = [];
+	for (let t = n.length - 1; t >= 0; --t) {
+		let o = n[t];
+		m(!o.isDeleted, "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements"), g(o, !1) && K(o, e, r, i) && a.push(o);
+	}
+	if (!a || a.length === 0) return null;
+	if (a.length === 1) return a[0];
+	let o = a.filter((n) => E(n, r, e) <= D(n, t) || $(e, n, r));
+	return o.length === 0 ? null : o[0];
+}, X = (e, t, n, r = 0, i = !1) => {
+	if (!k([
+		Math.min(n[0][0] - r, n[1][0] - r),
+		Math.min(n[0][1] - r, n[1][1] - r),
+		Math.max(n[0][0] + r, n[1][0] + r),
+		Math.max(n[0][1] + r, n[1][1] + r)
+	], P(e, t))) return [];
+	switch (e.type) {
+		case "rectangle":
+		case "image":
+		case "text":
+		case "iframe":
+		case "embeddable":
+		case "frame":
+		case "selection":
+		case "magicframe": return re(e, t, n, r, i);
+		case "diamond": return ie(e, t, n, r, i);
+		case "ellipse": return ae(e, t, n, r);
+		case "line":
+		case "freedraw":
+		case "arrow": return ne(e, n, i);
+	}
+}, Z = (e, t, n, r, i, a = !1) => {
+	for (let o of e) {
+		if (!k(M(o[0], o[1], o[2], o[3]), [
+			Math.min(t[0][0], t[1][0]),
+			Math.min(t[0][1], t[1][1]),
+			Math.max(t[0][0], t[1][0]),
+			Math.max(t[0][1], t[1][1])
+		])) continue;
+		let e = l(o, t);
+		if (e.length > 0) {
+			for (let t of e) n.push(s(t, r, i));
+			if (a) return n;
+		}
+	}
+	return n;
+}, Q = (e, t, n, r, i, a = !1) => {
+	for (let o of e) {
+		let e = p(o, t);
+		if (e && (n.push(s(e, r, i)), a)) return n;
+	}
+	return n;
+}, ne = (e, t, n = !1) => {
+	let [r, i] = C(e), a = [];
+	for (let e of r) {
+		let r = p(e, t);
+		if (r && (a.push(r), n)) return a;
+	}
+	for (let e of i) {
+		if (!k(M(e[0], e[1], e[2], e[3]), [
+			Math.min(t[0][0], t[1][0]),
+			Math.min(t[0][1], t[1][1]),
+			Math.max(t[0][0], t[1][0]),
+			Math.max(t[0][1], t[1][1])
+		])) continue;
+		let r = l(e, t);
+		if (r.length > 0 && (a.push(...r), n)) return a;
+	}
+	return a;
+}, re = (e, t, n, r = 0, i = !1) => {
+	let a = A(e, t), o = f(s(n[0], a, -e.angle), s(n[1], a, -e.angle)), [c, l] = w(e, r), u = [];
+	return Q(c, o, u, a, e.angle, i), i && u.length > 0 || Z(l, o, u, a, e.angle, i), u;
+}, ie = (e, t, n, r = 0, i = !1) => {
+	let a = A(e, t), o = f(s(n[0], a, -e.angle), s(n[1], a, -e.angle)), [c, l] = S(e, r), u = [];
+	return Q(c, o, u, a, e.angle, i), i && u.length > 0 || Z(l, o, u, a, e.angle, i), u;
+}, ae = (e, t, n, r = 0) => {
+	let i = A(e, t), a = s(n[0], i, -e.angle), o = s(n[1], i, -e.angle);
+	return d(u(i, e.width / 2 + r, e.height / 2 + r), f(a, o)).map((t) => s(t, i, e.angle));
+}, oe = (e, t, n, r = 1) => E(t, n, e) <= r, $ = (e, s, l) => {
+	if ((y(s) || ee(s)) && !T(s.points)) return !1;
+	let [u, d, p, m] = P(s, l);
+	if (!i(a(u, d), e, a(p, m))) return !1;
+	let h = a((u + p) / 2, (d + m) / 2);
+	return X(s, l, f(e, o(r(n(t(e, h, .1)), Math.max(s.width, s.height) * 2), h))).filter((e, t, n) => n.findIndex((t) => c(t, e)) === t).length % 2 == 1;
+}, se = (e, t, n) => ((e, t) => {
+	let { x: r, y: i, width: o, height: c, angle: l } = e, u = A(e, n);
+	if (e.type === "diamond") {
+		let [n, o, c, d, f, p, m, h] = N(e);
+		return [
+			a(r + n, i + o - t),
+			a(r + c + t, i + d),
+			a(r + f, i + p + t),
+			a(r + m - t, i + h)
+		].map((e) => s(e, u, l));
+	}
+	if (e.type === "ellipse") {
+		let e = r + o / 2, n = i + c / 2, d = o / 2, f = c / 2;
+		return [
+			a(e, n - f - t),
+			a(e + d + t, n),
+			a(e, n + f + t),
+			a(e - d - t, n)
+		].map((e) => s(e, u, l));
+	}
+	return [
+		a(r - t, i - t),
+		a(r + o + t, i - t),
+		a(r + o + t, i + c + t),
+		a(r - t, i + c + t)
+	].map((e) => s(e, u, l));
+})(e, -1 * Math.max(e.width, e.height) / 20).every((e) => $(e, t, n));
+//#endregion
+export { q as getAllHoveredElementAtPoint, J as getHoveredElementForBinding, Y as getHoveredElementForFocusPoint, G as hitElementBoundText, U as hitElementBoundingBox, W as hitElementBoundingBoxOnly, H as hitElementItself, X as intersectElementWithLineSegment, se as isBindableElementInsideOtherBindable, $ as isPointInElement, I as shouldTestInside };
+/* 独立思考，明辨是非 */