@unicom-cloud/ui 0.8.168 → 0.8.170

package/draw/libs/laser-pointer/state.js

@@ -0,0 +1,155 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { add as e, angle as t, dist as n, mag as r, norm as i, normAngle as a, plerp as o, rot as s, runLength as c, smul as l, sub as u } from "./math.js";
+import { douglasPeucker as d } from "./simplify.js";
+//#region components/pc/draw/libs/laser-pointer/state.ts
+var f = class f {
+	static {
+		this.defaults = {
+			size: 2,
+			streamline: .45,
+			simplify: .1,
+			simplifyPhase: "output",
+			keepHead: !1,
+			sizeMapping: () => 1
+		};
+	}
+	static {
+		this.constants = {
+			cornerDetectionMaxAngle: 75,
+			cornerDetectionVariance: (e) => e > 35 ? .5 : 1,
+			maxTailLength: 50
+		};
+	}
+	constructor(e) {
+		this.originalPoints = [], this.#e = [], this.#t = [], this.#n = !0, this.options = Object.assign({}, f.defaults, e);
+	}
+	#e;
+	#t;
+	#n;
+	get #r() {
+		return this.#t[this.#t.length - 1] ?? this.#e[this.#e.length - 1];
+	}
+	addPoint(e) {
+		let t = this.originalPoints[this.originalPoints.length - 1];
+		if (!(t && t[0] === e[0] && t[1] === e[1])) {
+			if (this.originalPoints.push(e), this.#n) {
+				this.#n = !1, this.#e.push(e);
+				return;
+			}
+			this.options.streamline > 0 && (e = o(this.#r, e, 1 - this.options.streamline)), this.#t.push(e), c(this.#t) > f.constants.maxTailLength && this.stabilizeTail();
+		}
+	}
+	close() {
+		this.stabilizeTail();
+	}
+	stabilizeTail() {
+		if (this.options.simplify > 0 && this.options.simplifyPhase == "tail") throw Error("Not implemented yet");
+		this.#e.push(...this.#t), this.#t = [];
+	}
+	#i(e, t, n, r, i) {
+		return (e ?? this.options.size) * this.options.sizeMapping({
+			pressure: t,
+			runningLength: i,
+			currentIndex: n,
+			totalLength: r
+		});
+	}
+	getStrokeOutline(o) {
+		if (this.#n) return [];
+		let c = [...this.#e, ...this.#t];
+		this.options.simplify > 0 && this.options.simplifyPhase === "input" && (c = d(c, this.options.simplify));
+		let p = c.length;
+		if (p === 0) return [];
+		if (p === 1) {
+			let t = c[0], n = this.#i(o, t[2], 0, p, 0);
+			if (n < .5) return [];
+			let r = [];
+			for (let i = 0; i <= Math.PI * 2; i += Math.PI / 16) r.push(e(t, l(s([
+				1,
+				0,
+				0
+			], i), n)));
+			return r.push(e(t, l([
+				1,
+				0,
+				0
+			], this.#i(o, t[2], 0, p, 0)))), r;
+		}
+		if (p === 2) {
+			let n = c[0], r = c[1], i = this.#i(o, n[2], 0, p, 0), a = this.#i(o, r[2], 0, p, 0);
+			if (i < .5 || a < .5) return [];
+			let u = [], d = t(n, [
+				n[0],
+				n[1] - 100,
+				n[2]
+			], r);
+			for (let t = d; t <= Math.PI + d; t += Math.PI / 16) u.push(e(n, l(s([
+				1,
+				0,
+				0
+			], t), i)));
+			for (let t = Math.PI + d; t <= Math.PI * 2 + d; t += Math.PI / 16) u.push(e(r, l(s([
+				1,
+				0,
+				0
+			], t), a)));
+			return u.push(u[0]), u;
+		}
+		let m = [], h = [], g = 0, _ = 0, v = 0, y = 0;
+		for (let d = 1; d < p - 1; d++) {
+			let b = c[d - 1], x = c[d], S = c[d + 1], C = x[2], w = n(b, x);
+			y += w, g = _ + (w - _) * .2;
+			let T = this.#i(o, C, d, p, y);
+			if (T === 0) {
+				v = d + 1;
+				continue;
+			}
+			let E = i(u(b, x)), D = i(u(S, x)), O = s(E, Math.PI / 2), k = s(E, -Math.PI / 2), A = s(D, Math.PI / 2), j = s(D, -Math.PI / 2), M = e(x, l(O, T)), N = e(x, l(k, T)), P = e(x, l(A, T)), F = e(x, l(j, T)), I = e(O, j), L = e(k, A), R = e(x, l(r(I) === 0 ? E : i(I), T)), z = e(x, l(r(L) === 0 ? D : i(L), T)), B = a(t(x, b, S)), V = f.constants.cornerDetectionMaxAngle / 180 * Math.PI * f.constants.cornerDetectionVariance(g);
+			if (Math.abs(B) < V) {
+				let t = Math.abs(a(Math.PI - B));
+				if (t === 0) continue;
+				if (B < 0) {
+					h.push(N, z);
+					for (let n = 0; n <= t; n += t / 4) m.push(e(x, s(l(O, T), n)));
+					for (let n = t; n >= 0; n -= t / 4) h.push(e(x, s(l(O, T), n)));
+					h.push(z, P);
+				} else {
+					m.push(M, R);
+					for (let n = 0; n <= t; n += t / 4) h.push(e(x, s(l(O, -T), -n)));
+					for (let n = t; n >= 0; n -= t / 4) m.push(e(x, s(l(O, -T), -n)));
+					m.push(R, F);
+				}
+			} else m.push(R), h.push(z);
+			_ = g;
+		}
+		if (v >= p - 2) if (this.options.keepHead) {
+			let t = c[p - 1], n = [];
+			for (let r = 0; r <= Math.PI * 2; r += Math.PI / 16) n.push(e(t, l(s([
+				1,
+				0,
+				0
+			], r), this.options.size)));
+			return n.push(e(t, l([
+				1,
+				0,
+				0
+			], this.options.size))), n;
+		} else return [];
+		let b = c[v], x = c[v + 1], S = c[p - 2], C = c[p - 1], w = i(u(x, b)), T = i(u(S, C)), E = s(w, -Math.PI / 2), D = s(T, Math.PI / 2), O = this.#i(o, b[2], 0, p, 0), k = [], A = this.options.keepHead ? this.options.size : this.#i(o, S[2], p - 2, p, y), j = [];
+		if (O > 1) {
+			for (let t = 0; t <= Math.PI; t += Math.PI / 16) k.unshift(e(b, s(l(E, O), -t)));
+			k.unshift(e(b, l(E, -O)));
+		} else k.push(b);
+		for (let t = 0; t <= Math.PI * 3; t += Math.PI / 16) j.push(e(C, s(l(D, -A), -t)));
+		let M = [
+			...k,
+			...m,
+			...j.reverse(),
+			...h.reverse()
+		];
+		return k.length > 0 && M.push(k[0]), this.options.simplify > 0 && this.options.simplifyPhase === "output" ? d(M, this.options.simplify) : M;
+	}
+};
+//#endregion
+export { f as LaserPointer };
+/* 独立思考，明辨是非 */

package/draw/libs/markdown-to-text/index.d.ts

@@ -0,0 +1,20 @@
+type Options = {
+    stripListLeaders?: boolean;
+    listUnicodeChar: string | boolean;
+    gfm?: boolean;
+    useImgAltText?: boolean;
+    preserveLinks?: boolean;
+};
+/**
+ * @function removeMarkdown
+ *
+ * @description
+ * Parse the markdown and returns a string
+ *
+ * @param markdown - The markdown string to parse
+ * @param options - The options for the function
+ *
+ * @returns The parsed plain text
+ */
+declare const removeMarkdown: (markdown: string, options?: Options) => string;
+export { removeMarkdown };

package/draw/libs/markdown-to-text/index.js

@@ -0,0 +1,17 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { __exportAll as e } from "../../../.virtual/_rolldown/runtime.js";
+//#region components/pc/draw/libs/markdown-to-text/index.ts
+var t = /* @__PURE__ */ e({ removeMarkdown: () => n }), n = (e, t = { listUnicodeChar: "" }) => {
+	t ||= {}, t.listUnicodeChar = Object.prototype.hasOwnProperty.call(t, "listUnicodeChar") ? t.listUnicodeChar : !1, t.stripListLeaders = Object.prototype.hasOwnProperty.call(t, "stripListLeaders") ? t.stripListLeaders : !0, t.gfm = Object.prototype.hasOwnProperty.call(t, "gfm") ? t.gfm : !0, t.useImgAltText = Object.prototype.hasOwnProperty.call(t, "useImgAltText") ? t.useImgAltText : !0, t.preserveLinks = Object.prototype.hasOwnProperty.call(t, "preserveLinks") ? t.preserveLinks : !1;
+	let n = e || "";
+	n = n.replace(/^(-\s*?|\*\s*?|_\s*?){3,}\s*$/gm, "");
+	try {
+		t.stripListLeaders && (n = t.listUnicodeChar ? n.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, t.listUnicodeChar + " $1") : n.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, "$1")), t.gfm && (n = n.replace(/\n={2,}/g, "\n").replace(/~{3}.*\n/g, "").replace(/~~/g, "").replace(/`{3}.*\n/g, "")), t.preserveLinks && (n = n.replace(/\[(.*?)\][\[\(](.*?)[\]\)]/g, "$1 ($2)")), n = n.replace(/<[^>]*>/g, "").replace(/^[=\-]{2,}\s*$/g, "").replace(/\[\^.+?\](\: .*?$)?/g, "").replace(/\s{0,2}\[.*?\]: .*?$/g, "").replace(/\!\[(.*?)\][\[\(].*?[\]\)]/g, t.useImgAltText ? "$1" : "").replace(/\[(.*?)\][\[\(].*?[\]\)]/g, "$1").replace(/^\s{0,3}>\s?/g, "").replace(/(^|\n)\s{0,3}>\s?/g, "\n\n").replace(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/g, "").replace(/^(\n)?\s{0,}#{1,6}\s+| {0,}(\n)?\s{0,}#{0,} {0,}(\n)?\s{0,}$/gm, "$1$2$3").replace(/([\*_]{1,3})(\S.*?\S{0,1})\1/g, "$2").replace(/([\*_]{1,3})(\S.*?\S{0,1})\1/g, "$2").replace(/(`{3,})(.*?)\1/gm, "$2").replace(/`(.+?)`/g, "$1").replace(/\n{2,}/g, "\n\n");
+	} catch (t) {
+		return console.error(t), e;
+	}
+	return n;
+};
+//#endregion
+export { t as markdown_to_text_exports };
+/* 独立思考，明辨是非 */

package/draw/libs/math/angle.d.ts

@@ -0,0 +1,19 @@
+import type { Degrees, GlobalPoint, LocalPoint, PolarCoords, Radians } from './types';
+export declare const normalizeRadians: (angle: Radians) => Radians;
+/**
+ * Return the polar coordinates for the given cartesian point represented by
+ * (x, y) for the center point 0,0 where the first number returned is the radius,
+ * the second is the angle in radians.
+ */
+export declare const cartesian2Polar: <P extends GlobalPoint | LocalPoint>([x, y,]: P) => PolarCoords;
+export declare function degreesToRadians(degrees: Degrees): Radians;
+export declare function radiansToDegrees(degrees: Radians): Degrees;
+/**
+ * Determines if the provided angle is a right angle.
+ *
+ * @param rads The angle to measure
+ * @returns TRUE if the provided angle is a right angle
+ */
+export declare function isRightAngleRads(rads: Radians): boolean;
+export declare function radiansBetweenAngles(a: Radians, min: Radians, max: Radians): boolean;
+export declare function radiansDifference(a: Radians, b: Radians): Radians;

package/draw/libs/math/angle.js

@@ -0,0 +1,24 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { PRECISION as e } from "./utils.js";
+//#region components/pc/draw/libs/math/angle.ts
+var t = (e) => e < 0 ? e % (2 * Math.PI) + 2 * Math.PI : e % (2 * Math.PI), n = ([e, n]) => [Math.hypot(e, n), t(Math.atan2(n, e))];
+function r(e) {
+	return e * Math.PI / 180;
+}
+function i(e) {
+	return e * 180 / Math.PI;
+}
+function a(t) {
+	return Math.abs(Math.sin(2 * t)) < e;
+}
+function o(e, n, r) {
+	return e = t(e), n = t(n), r = t(r), n < r ? e >= n && e <= r : e >= n || e <= r;
+}
+function s(e, n) {
+	e = t(e), n = t(n);
+	let r = e - n;
+	return r < -Math.PI ? r += 2 * Math.PI : r > Math.PI && (r -= 2 * Math.PI), Math.abs(r);
+}
+//#endregion
+export { n as cartesian2Polar, r as degreesToRadians, a as isRightAngleRads, t as normalizeRadians, o as radiansBetweenAngles, s as radiansDifference, i as radiansToDegrees };
+/* 独立思考，明辨是非 */

package/draw/libs/math/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PRECISION = 0.0001;
+export declare const LegendreGaussN24TValues: number[];
+export declare const LegendreGaussN24CValues: number[];

package/draw/libs/math/constants.js

@@ -0,0 +1,56 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+//#region components/pc/draw/libs/math/constants.ts
+var e = [
+	-.06405689286260563,
+	.06405689286260563,
+	-.1911188674736163,
+	.1911188674736163,
+	-.3150426796961634,
+	.3150426796961634,
+	-.4337935076260451,
+	.4337935076260451,
+	-.5454214713888396,
+	.5454214713888396,
+	-.6480936519369755,
+	.6480936519369755,
+	-.7401241915785544,
+	.7401241915785544,
+	-.820001985973903,
+	.820001985973903,
+	-.8864155270044011,
+	.8864155270044011,
+	-.9382745520027328,
+	.9382745520027328,
+	-.9747285559713095,
+	.9747285559713095,
+	-.9951872199970213,
+	.9951872199970213
+], t = [
+	.12793819534675216,
+	.12793819534675216,
+	.1258374563468283,
+	.1258374563468283,
+	.12167047292780339,
+	.12167047292780339,
+	.1155056680537256,
+	.1155056680537256,
+	.10744427011596563,
+	.10744427011596563,
+	.09761865210411388,
+	.09761865210411388,
+	.08619016153195327,
+	.08619016153195327,
+	.0733464814110803,
+	.0733464814110803,
+	.05929858491543678,
+	.05929858491543678,
+	.04427743881741981,
+	.04427743881741981,
+	.028531388628933663,
+	.028531388628933663,
+	.0123412297999872,
+	.0123412297999872
+];
+//#endregion
+export { t as LegendreGaussN24CValues, e as LegendreGaussN24TValues };
+/* 独立思考，明辨是非 */

package/draw/libs/math/curve.d.ts

@@ -0,0 +1,74 @@
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from './types';
+/**
+ *
+ * @param a
+ * @param b
+ * @param c
+ * @param d
+ * @returns
+ */
+export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
+export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, t: number) => Point;
+/**
+ * Computes the intersection between a cubic spline and a line segment.
+ */
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
+/**
+ * Finds the closest point on the Bezier curve from another point
+ *
+ * @param x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
+ * @returns
+ */
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
+/**
+ * Determines the distance between a point and the closest point on the
+ * Bezier curve.
+ *
+ * @param c The curve to test
+ * @param p The point to measure from
+ */
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+/**
+ * Determines if the parameter is a Curve
+ */
+export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;
+export declare function curveTangent<Point extends GlobalPoint | LocalPoint>([p0, p1, p2, p3]: Curve<Point>, t: number): import("./types").Vector;
+export declare function curveCatmullRomQuadraticApproxPoints(points: GlobalPoint[], tension?: number): [GlobalPoint, GlobalPoint][] | undefined;
+export declare function curveCatmullRomCubicApproxPoints<Point extends GlobalPoint | LocalPoint>(points: Point[], tension?: number): Curve<Point>[] | undefined;
+export declare function curveOffsetPoints([p0, p1, p2, p3]: Curve<GlobalPoint>, offset: number, steps?: number): GlobalPoint[];
+export declare function offsetPointsForQuadraticBezier(p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, offsetDist: number, steps?: number): GlobalPoint[];
+/**
+ * Implementation based on Legendre-Gauss quadrature for more accurate arc
+ * length calculation.
+ *
+ * Reference: https://pomax.github.io/bezierinfo/#arclength
+ *
+ * @param c The curve to calculate the length of
+ * @returns The approximated length of the curve
+ */
+export declare function curveLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>): number;
+/**
+ * Calculates the curve length from t=0 to t=parameter using the same
+ * Legendre-Gauss quadrature method used in curveLength
+ *
+ * @param c The curve to calculate the partial length for
+ * @param t The parameter value (0 to 1) to calculate length up to
+ * @returns The length of the curve from beginning to parameter t
+ */
+export declare function curveLengthAtParameter<P extends GlobalPoint | LocalPoint>(c: Curve<P>, t: number): number;
+/**
+ * Calculates the point at a specific percentage of a curve's total length
+ * using binary search for improved efficiency and accuracy.
+ *
+ * @param c The curve to calculate point on
+ * @param percent A value between 0 and 1 representing the percentage of the curve's length
+ * @returns The point at the specified percentage of curve length
+ */
+export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number): P;

package/draw/libs/math/curve.js

@@ -0,0 +1,126 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { LegendreGaussN24CValues as e, LegendreGaussN24TValues as t } from "./constants.js";
+import { vector as n, vectorNormal as r, vectorNormalize as i, vectorScale as a } from "./vector.js";
+import { isPoint as o, pointDistance as s, pointFrom as c, pointFromVector as l } from "./point.js";
+import { isArray as u } from "@unicom-cloud/utils/is";
+//#region components/pc/draw/libs/math/curve.ts
+function d(e, t, n, r) {
+	return [
+		e,
+		t,
+		n,
+		r
+	];
+}
+function f(e, t, n, r, i = .001, a = 10) {
+	let o = Infinity, s = 0;
+	for (; o >= i;) {
+		if (s >= a) return null;
+		let c = 1 - n, l = c * c, u = l * c, d = n * n, f = d * n, p = u * e[0][0] + 3 * l * n * e[1][0] + 3 * c * d * e[2][0] + f * e[3][0], m = u * e[0][1] + 3 * l * n * e[1][1] + 3 * c * d * e[2][1] + f * e[3][1], h = t[0][0] + r * (t[1][0] - t[0][0]), g = t[0][1] + r * (t[1][1] - t[0][1]), _ = p - h, v = m - g;
+		if (o = Math.abs(_) + Math.abs(v), o < i) break;
+		let y = -3 * l * e[0][0] + 3 * l * e[1][0] - 6 * c * n * e[1][0] - 3 * d * e[2][0] + 6 * c * n * e[2][0] + 3 * d * e[3][0], b = -3 * l * e[0][1] + 3 * l * e[1][1] - 6 * c * n * e[1][1] - 3 * d * e[2][1] + 6 * c * n * e[2][1] + 3 * d * e[3][1], x = -(t[1][0] - t[0][0]), S = -(t[1][1] - t[0][1]), C = y * S - x * b;
+		if (Math.abs(C) < 1e-12) return null;
+		let w = 1 / C, T = w * (S * -_ - x * -v), E = w * (-b * -_ + y * -v);
+		n += T, r += E, s += 1;
+	}
+	return [n, r];
+}
+var p = (e, t) => c((1 - t) ** 3 * e[0][0] + 3 * (1 - t) ** 2 * t * e[1][0] + 3 * (1 - t) * t ** 2 * e[2][0] + t ** 3 * e[3][0], (1 - t) ** 3 * e[0][1] + 3 * (1 - t) ** 2 * t * e[1][1] + 3 * (1 - t) * t ** 2 * e[2][1] + t ** 3 * e[3][1]), m = [
+	[.5, 0],
+	[.2, 0],
+	[.8, 0]
+], h = ([e, t], n, r) => {
+	let i = f(r, n, e, t, .01, 4);
+	if (!i) return null;
+	let [a, o] = i;
+	return a < 0 || a > 1 || o < 0 || o > 1 ? null : p(r, a);
+};
+function g(e, t) {
+	let n = h(m[0], t, e);
+	return n || (n = h(m[1], t, e), n) || (n = h(m[2], t, e), n) ? [n] : [];
+}
+function _(e, t, n = .001) {
+	let r = (e, t, r, i = n) => {
+		let a = e, o = t, s;
+		for (; o - a > i;) s = (o + a) / 2, r(s - i) < r(s + i) ? o = s : a = s;
+		return s;
+	}, i = 0;
+	for (let n = Infinity, r = 0; r < 30; r++) {
+		let a = s(t, p(e, r / 30));
+		a < n && (n = a, i = r);
+	}
+	let a = r(Math.max((i - 1) / 30, 0), Math.min((i + 1) / 30, 1), (n) => s(t, p(e, n)));
+	return a ? p(e, a) : null;
+}
+function v(e, t) {
+	let n = _(e, t);
+	return n ? s(t, n) : 0;
+}
+function y(e) {
+	return u(e) && e.length === 4 && o(e[0]) && o(e[1]) && o(e[2]) && o(e[3]);
+}
+function b([e, t, r, i], a) {
+	return n(-3 * (1 - a) * (1 - a) * e[0] + 3 * (1 - a) * (1 - a) * t[0] - 6 * a * (1 - a) * t[0] - 3 * a * a * r[0] + 6 * a * (1 - a) * r[0] + 3 * a * a * i[0], -3 * (1 - a) * (1 - a) * e[1] + 3 * (1 - a) * (1 - a) * t[1] - 6 * a * (1 - a) * t[1] - 3 * a * a * r[1] + 6 * a * (1 - a) * r[1] + 3 * a * a * i[1]);
+}
+function x(e, t = .5) {
+	if (e.length < 2) return;
+	let n = [];
+	for (let r = 0; r < e.length - 1; r++) {
+		let i = e[r - 1 < 0 ? 0 : r - 1], a = e[r], o = e[r + 1 >= e.length ? e.length - 1 : r + 1], s = a[0] + (o[0] - i[0]) * t / 2, l = a[1] + (o[1] - i[1]) * t / 2;
+		n.push([c(s, l), c(o[0], o[1])]);
+	}
+	return n;
+}
+function S(e, t = .5) {
+	if (e.length < 2) return;
+	let n = [];
+	for (let r = 0; r < e.length - 1; r++) {
+		let i = e[r - 1 < 0 ? 0 : r - 1], a = e[r], o = e[r + 1 >= e.length ? e.length - 1 : r + 1], s = e[r + 2 >= e.length ? e.length - 1 : r + 2], l = [(o[0] - i[0]) * t, (o[1] - i[1]) * t], u = [(s[0] - a[0]) * t, (s[1] - a[1]) * t], f = a[0] + l[0] / 3, p = a[1] + l[1] / 3, m = o[0] - u[0] / 3, h = o[1] - u[1] / 3;
+		n.push(d(c(a[0], a[1]), c(f, p), c(m, h), c(o[0], o[1])));
+	}
+	return n;
+}
+function C([e, t, n, o], s, c = 50) {
+	let u = [];
+	for (let f = 0; f <= c; f++) {
+		let m = f / c, h = d(e, t, n, o), g = p(h, m), _ = r(i(b(h, m)));
+		u.push(l(a(_, s), g));
+	}
+	return u;
+}
+function w(e, t, o, s, u = 50) {
+	let d = [];
+	for (let f = 0; f <= u; f++) {
+		let p = f / u, m = 1 - p, h = c(m * m * e[0] + 2 * m * p * t[0] + p * p * o[0], m * m * e[1] + 2 * m * p * t[1] + p * p * o[1]), g = r(i(n(2 * (1 - p) * (t[0] - e[0]) + 2 * p * (o[0] - t[0]), 2 * (1 - p) * (t[1] - e[1]) + 2 * p * (o[1] - t[1]))));
+		d.push(l(a(g, s), h));
+	}
+	return d;
+}
+function T(n) {
+	let r = .5, i = 0;
+	for (let a = 0; a < 24; a++) {
+		let o = b(n, r * t[a] + r), s = Math.sqrt(o[0] * o[0] + o[1] * o[1]);
+		i += e[a] * s;
+	}
+	return r * i;
+}
+function E(n, r) {
+	if (r <= 0) return 0;
+	if (r >= 1) return T(n);
+	let i = r / 2, a = r / 2, o = 0;
+	for (let r = 0; r < 24; r++) {
+		let s = b(n, i * t[r] + a), c = Math.sqrt(s[0] * s[0] + s[1] * s[1]);
+		o += e[r] * c;
+	}
+	return i * o;
+}
+function D(e, t) {
+	if (t <= 0) return p(e, 0);
+	if (t >= 1) return p(e, 1);
+	let n = T(e), r = n * t, i = 0, a = 1, o = t, s = 0, c = n * 1e-4;
+	for (let t = 0; t < 20 && (s = E(e, o), !(Math.abs(s - r) < c)); t++) s < r ? i = o : a = o, o = (i + a) / 2;
+	return p(e, o);
+}
+//#endregion
+export { p as bezierEquation, d as curve, S as curveCatmullRomCubicApproxPoints, x as curveCatmullRomQuadraticApproxPoints, _ as curveClosestPoint, g as curveIntersectLineSegment, T as curveLength, E as curveLengthAtParameter, C as curveOffsetPoints, D as curvePointAtLength, v as curvePointDistance, b as curveTangent, y as isCurve, w as offsetPointsForQuadraticBezier };
+/* 独立思考，明辨是非 */

package/draw/libs/math/ellipse.d.ts

@@ -0,0 +1,44 @@
+import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from './types';
+/**
+ * Construct an Ellipse object from the parameters
+ *
+ * @param center The center of the ellipse
+ * @param angle The slanting of the ellipse in radians
+ * @param halfWidth Half of the width of a non-slanted version of the ellipse
+ * @param halfHeight Half of the height of a non-slanted version of the ellipse
+ * @returns The constructed Ellipse object
+ */
+export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
+/**
+ * Determines if a point is inside or on the ellipse outline
+ *
+ * @param p The point to test
+ * @param ellipse The ellipse to compare against
+ * @returns TRUE if the point is inside or on the outline of the ellipse
+ */
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+/**
+ * Tests whether a point lies on the outline of the ellipse within a given
+ * tolerance
+ *
+ * @param point The point to test
+ * @param ellipse The ellipse to compare against
+ * @param threshold The distance to consider a point close enough to be "on" the outline
+ * @returns TRUE if the point is on the ellise outline
+ */
+export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+/**
+ * Determine the shortest euclidean distance from a point to the
+ * outline of the ellipse
+ *
+ * @param p The point to consider
+ * @param ellipse The ellipse to calculate the distance to
+ * @returns The eucledian distance
+ */
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+/**
+ * Calculate a maximum of two intercept points for a line going throug an
+ * ellipse.
+ */
+export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
+export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];

package/draw/libs/math/ellipse.js

@@ -0,0 +1,44 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { PRECISION as e } from "./utils.js";
+import { vector as t, vectorAdd as n, vectorDot as r, vectorFromPoint as i, vectorScale as a } from "./vector.js";
+import { pointDistance as o, pointFrom as s, pointFromVector as c, pointsEqual as l } from "./point.js";
+//#region components/pc/draw/libs/math/ellipse.ts
+function u(e, t, n) {
+	return {
+		center: e,
+		halfWidth: t,
+		halfHeight: n
+	};
+}
+var d = (e, t) => {
+	let { center: n, halfWidth: r, halfHeight: i } = t, a = (e[0] - n[0]) / r, o = (e[1] - n[1]) / i;
+	return a * a + o * o <= 1;
+}, f = (t, n, r = e) => p(t, n) <= r, p = (e, t) => {
+	let { halfWidth: r, halfHeight: l, center: u } = t, d = r, f = l, p = n(i(e), a(i(u), -1)), m = Math.abs(p[0]), h = Math.abs(p[1]), g = .707, _ = .707;
+	for (let e = 0; e < 3; e++) {
+		let e = d * g, t = f * _, n = (d * d - f * f) * g ** 3 / d, r = (f * f - d * d) * _ ** 3 / f, i = e - n, a = t - r, o = m - n, s = h - r, c = Math.hypot(a, i), l = Math.hypot(s, o);
+		g = Math.min(1, Math.max(0, (o * c / l + n) / d)), _ = Math.min(1, Math.max(0, (s * c / l + r) / f));
+		let u = Math.hypot(_, g);
+		g /= u, _ /= u;
+	}
+	let [v, y] = [d * g * Math.sign(p[0]), f * _ * Math.sign(p[1])];
+	return o(c(p), s(v, y));
+};
+function m(e, n) {
+	let a = e.halfWidth, o = e.halfHeight, c = i(n[1], n[0]), l = t(n[0][0] - e.center[0], n[0][1] - e.center[1]), u = t(c[0] / (a * a), c[1] / (o * o)), d = t(l[0] / (a * a), l[1] / (o * o)), f = r(c, u), p = r(c, d), m = r(l, d) - 1, h = p * p - f * m, g = [];
+	if (h > 0) {
+		let e = (-p - Math.sqrt(h)) / f, t = (-p + Math.sqrt(h)) / f;
+		0 <= e && e <= 1 && g.push(s(n[0][0] + (n[1][0] - n[0][0]) * e, n[0][1] + (n[1][1] - n[0][1]) * e)), 0 <= t && t <= 1 && g.push(s(n[0][0] + (n[1][0] - n[0][0]) * t, n[0][1] + (n[1][1] - n[0][1]) * t));
+	} else if (h === 0) {
+		let e = -p / f;
+		0 <= e && e <= 1 && g.push(s(n[0][0] + (n[1][0] - n[0][0]) * e, n[0][1] + (n[1][1] - n[0][1]) * e));
+	}
+	return g;
+}
+function h({ center: e, halfWidth: t, halfHeight: n }, [r, i]) {
+	let [a, o] = e, c = r[0] - a, u = r[1] - o, d = i[0] - a, f = i[1] - o, p = (d - c) ** 2 / t ** 2 + (f - u) ** 2 / n ** 2, m = 2 * (c * (d - c) / t ** 2 + u * (f - u) / n ** 2), h = c ** 2 / t ** 2 + u ** 2 / n ** 2 - 1, g = (-m + Math.sqrt(m ** 2 - 4 * p * h)) / (2 * p), _ = (-m - Math.sqrt(m ** 2 - 4 * p * h)) / (2 * p), v = [s(c + g * (d - c) + a, u + g * (f - u) + o), s(c + _ * (d - c) + a, u + _ * (f - u) + o)].filter((e) => !isNaN(e[0]) && !isNaN(e[1]));
+	return v.length === 2 && l(v[0], v[1]) ? [v[0]] : v;
+}
+//#endregion
+export { u as ellipse, p as ellipseDistanceFromPoint, d as ellipseIncludesPoint, h as ellipseLineIntersectionPoints, m as ellipseSegmentInterceptPoints, f as ellipseTouchesPoint };
+/* 独立思考，明辨是非 */

package/draw/libs/math/index.d.ts

@@ -0,0 +1,13 @@
+export * from './angle';
+export * from './curve';
+export * from './ellipse';
+export * from './line';
+export * from './point';
+export * from './polygon';
+export * from './range';
+export * from './rectangle';
+export * from './segment';
+export * from './triangle';
+export * from './types';
+export * from './vector';
+export * from './utils';