@unicom-cloud/ui 0.8.167 → 0.8.169

package/draw/libs/math/index.js

@@ -0,0 +1,105 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { __exportAll as e } from "../../../.virtual/_rolldown/runtime.js";
+import { PRECISION as t, average as n, clamp as r, isCloseTo as i, isFiniteNumber as a, round as o, roundToStep as s } from "./utils.js";
+import { cartesian2Polar as c, degreesToRadians as l, isRightAngleRads as u, normalizeRadians as d, radiansBetweenAngles as f, radiansDifference as p, radiansToDegrees as m } from "./angle.js";
+import { isVector as h, vector as g, vectorAdd as _, vectorCross as v, vectorDot as y, vectorFromPoint as b, vectorMagnitude as x, vectorMagnitudeSq as S, vectorNormal as C, vectorNormalize as w, vectorScale as T, vectorSubtract as E } from "./vector.js";
+import { isPoint as D, isPointWithinBounds as O, pointCenter as k, pointDistance as A, pointDistanceSq as j, pointFrom as M, pointFromArray as N, pointFromPair as P, pointFromVector as F, pointRotateDegs as I, pointRotateRads as L, pointScaleFromOrigin as R, pointTranslate as z, pointsEqual as B } from "./point.js";
+import { bezierEquation as V, curve as H, curveCatmullRomCubicApproxPoints as U, curveCatmullRomQuadraticApproxPoints as W, curveClosestPoint as G, curveIntersectLineSegment as K, curveLength as q, curveLengthAtParameter as J, curveOffsetPoints as Y, curvePointAtLength as X, curvePointDistance as Z, curveTangent as Q, isCurve as $, offsetPointsForQuadraticBezier as ee } from "./curve.js";
+import { ellipse as te, ellipseDistanceFromPoint as ne, ellipseIncludesPoint as re, ellipseLineIntersectionPoints as ie, ellipseSegmentInterceptPoints as ae, ellipseTouchesPoint as oe } from "./ellipse.js";
+import { line as se, linesIntersectAt as ce } from "./line.js";
+import { distanceToLineSegment as le, isLineSegment as ue, lineSegment as de, lineSegmentIntersectionPoints as fe, lineSegmentRotate as pe, lineSegmentsDistance as me, pointOnLineSegment as he, segmentsIntersectAt as ge } from "./segment.js";
+import { pointOnPolygon as _e, polygon as ve, polygonFromPoints as ye, polygonIncludesPoint as be, polygonIncludesPointNonZero as xe } from "./polygon.js";
+import { rangeIncludesValue as Se, rangeInclusive as Ce, rangeInclusiveFromPair as we, rangeIntersection as Te, rangesOverlap as Ee } from "./range.js";
+import { rectangle as De, rectangleFromNumberSequence as Oe, rectangleIntersectLineSegment as ke, rectangleIntersectRectangle as Ae } from "./rectangle.js";
+import { triangleIncludesPoint as je } from "./triangle.js";
+//#region components/pc/draw/libs/math/index.ts
+var Me = /* @__PURE__ */ e({
+	PRECISION: () => t,
+	average: () => n,
+	bezierEquation: () => V,
+	cartesian2Polar: () => c,
+	clamp: () => r,
+	curve: () => H,
+	curveCatmullRomCubicApproxPoints: () => U,
+	curveCatmullRomQuadraticApproxPoints: () => W,
+	curveClosestPoint: () => G,
+	curveIntersectLineSegment: () => K,
+	curveLength: () => q,
+	curveLengthAtParameter: () => J,
+	curveOffsetPoints: () => Y,
+	curvePointAtLength: () => X,
+	curvePointDistance: () => Z,
+	curveTangent: () => Q,
+	degreesToRadians: () => l,
+	distanceToLineSegment: () => le,
+	ellipse: () => te,
+	ellipseDistanceFromPoint: () => ne,
+	ellipseIncludesPoint: () => re,
+	ellipseLineIntersectionPoints: () => ie,
+	ellipseSegmentInterceptPoints: () => ae,
+	ellipseTouchesPoint: () => oe,
+	isCloseTo: () => i,
+	isCurve: () => $,
+	isFiniteNumber: () => a,
+	isLineSegment: () => ue,
+	isPoint: () => D,
+	isPointWithinBounds: () => O,
+	isRightAngleRads: () => u,
+	isVector: () => h,
+	line: () => se,
+	lineSegment: () => de,
+	lineSegmentIntersectionPoints: () => fe,
+	lineSegmentRotate: () => pe,
+	lineSegmentsDistance: () => me,
+	linesIntersectAt: () => ce,
+	normalizeRadians: () => d,
+	offsetPointsForQuadraticBezier: () => ee,
+	pointCenter: () => k,
+	pointDistance: () => A,
+	pointDistanceSq: () => j,
+	pointFrom: () => M,
+	pointFromArray: () => N,
+	pointFromPair: () => P,
+	pointFromVector: () => F,
+	pointOnLineSegment: () => he,
+	pointOnPolygon: () => _e,
+	pointRotateDegs: () => I,
+	pointRotateRads: () => L,
+	pointScaleFromOrigin: () => R,
+	pointTranslate: () => z,
+	pointsEqual: () => B,
+	polygon: () => ve,
+	polygonFromPoints: () => ye,
+	polygonIncludesPoint: () => be,
+	polygonIncludesPointNonZero: () => xe,
+	radiansBetweenAngles: () => f,
+	radiansDifference: () => p,
+	radiansToDegrees: () => m,
+	rangeIncludesValue: () => Se,
+	rangeInclusive: () => Ce,
+	rangeInclusiveFromPair: () => we,
+	rangeIntersection: () => Te,
+	rangesOverlap: () => Ee,
+	rectangle: () => De,
+	rectangleFromNumberSequence: () => Oe,
+	rectangleIntersectLineSegment: () => ke,
+	rectangleIntersectRectangle: () => Ae,
+	round: () => o,
+	roundToStep: () => s,
+	segmentsIntersectAt: () => ge,
+	triangleIncludesPoint: () => je,
+	vector: () => g,
+	vectorAdd: () => _,
+	vectorCross: () => v,
+	vectorDot: () => y,
+	vectorFromPoint: () => b,
+	vectorMagnitude: () => x,
+	vectorMagnitudeSq: () => S,
+	vectorNormal: () => C,
+	vectorNormalize: () => w,
+	vectorScale: () => T,
+	vectorSubtract: () => E
+});
+//#endregion
+export { Me as math_exports };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,17 @@
+import type { GlobalPoint, Line, LocalPoint } from './types';
+/**
+ * Create a line from two points.
+ *
+ * @param points The two points lying on the line
+ * @returns The line on which the points lie
+ */
+export declare function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P>;
+/**
+ * Determines the intersection point (unless the lines are parallel) of two
+ * lines
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>): Point | null;

package/draw/libs/math/line.js

@@ -0,0 +1,17 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { pointFrom as e } from "./point.js";
+//#region components/pc/draw/libs/math/line.ts
+function t(e, t) {
+	return [e, t];
+}
+function n(t, n) {
+	let r = t[1][1] - t[0][1], i = t[0][0] - t[1][0], a = n[1][1] - n[0][1], o = n[0][0] - n[1][0], s = r * o - a * i;
+	if (s !== 0) {
+		let c = r * t[0][0] + i * t[0][1], l = a * n[0][0] + o * n[0][1];
+		return e((c * o - l * i) / s, (r * l - a * c) / s);
+	}
+	return null;
+}
+//#endregion
+export { t as line, n as linesIntersectAt };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,122 @@
+import type { Degrees, GlobalPoint, LocalPoint, Radians, Vector } from './types';
+/**
+ * Create a properly typed Point instance from the X and Y coordinates.
+ *
+ * @param x The X coordinate
+ * @param y The Y coordinate
+ * @returns The branded and created point
+ */
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+/**
+ * Converts and remaps an array containing a pair of numbers to Point.
+ *
+ * @param numberArray The number array to check and to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromArray<Point extends GlobalPoint | LocalPoint>(numberArray: number[]): Point | undefined;
+/**
+ * Converts and remaps a pair of numbers to Point.
+ *
+ * @param pair A number pair to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pair: [number, number]): Point;
+/**
+ * Convert a vector to a point.
+ *
+ * @param v The vector to convert
+ * @returns The point the vector points at with origin 0,0
+ */
+export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector, offset?: P): P;
+/**
+ * Checks if the provided value has the shape of a Point.
+ *
+ * @param p The value to attempt verification on
+ * @returns TRUE if the provided value has the shape of a local or global point
+ */
+export declare function isPoint(p: unknown): p is LocalPoint | GlobalPoint;
+/**
+ * Compare two points coordinate-by-coordinate and if
+ * they are closer than INVERSE_PRECISION it returns TRUE.
+ *
+ * @param a Point The first point to compare
+ * @param b Point The second point to compare
+ * @returns TRUE if the points are sufficiently close to each other
+ */
+export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, tolerance?: number): boolean;
+/**
+ * Rotate a point by [angle] radians.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The radians to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
+/**
+ * Rotate a point by [angle] degree.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The degree to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Degrees): Point;
+/**
+ * Translate a point by a vector.
+ *
+ * WARNING: This is not for translating Draw element points!
+ *          You need to account for rotation on base coordinates
+ *          on your own.
+ *          CONSIDER USING AN APPROPRIATE ELEMENT-AWARE TRANSLATE!
+ *
+ * @param p The point to apply the translation on
+ * @param v The vector to translate by
+ * @returns
+ */
+export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To extends GlobalPoint | LocalPoint>(p: From, v?: Vector): To;
+/**
+ * Find the center point at equal distance from both points.
+ *
+ * @param a One of the points to create the middle point for
+ * @param b The other point to create the middle point for
+ * @returns The middle point
+ */
+export declare function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P;
+/**
+ * Calculate the distance between two points.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistance<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Calculate the squared distance between two points.
+ *
+ * Note: Use this if you only compare distances, it saves a square root.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Scale a point from a given origin by the multiplier.
+ *
+ * @param p The point to scale
+ * @param mid The origin to scale from
+ * @param multiplier The scaling factor
+ * @returns
+ */
+export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
+/**
+ * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
+ * This is an approximation to "does `q` lie on a segment `pr`" check.
+ *
+ * @param p The first point to compare against
+ * @param q The actual point this function checks whether is in between
+ * @param r The other point to compare against
+ * @returns TRUE if q is indeed between p and r
+ */
+export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;

package/draw/libs/math/point.js

@@ -0,0 +1,48 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { PRECISION as e } from "./utils.js";
+import { degreesToRadians as t } from "./angle.js";
+import { vectorFromPoint as n, vectorScale as r } from "./vector.js";
+import { isArray as i } from "@unicom-cloud/utils/is";
+//#region components/pc/draw/libs/math/point.ts
+function a(e, t) {
+	return [e, t];
+}
+function o(e) {
+	return e.length === 2 ? a(e[0], e[1]) : void 0;
+}
+function s(e) {
+	return e;
+}
+function c(e, t = a(0, 0)) {
+	return a(t[0] + e[0], t[1] + e[1]);
+}
+function l(e) {
+	return i(e) && e.length === 2 && typeof e[0] == "number" && !isNaN(e[0]) && typeof e[1] == "number" && !isNaN(e[1]);
+}
+function u(t, n, r = e) {
+	let i = Math.abs;
+	return i(t[0] - n[0]) < r && i(t[1] - n[1]) < r;
+}
+function d([e, t], [n, r], i) {
+	return a((e - n) * Math.cos(i) - (t - r) * Math.sin(i) + n, (e - n) * Math.sin(i) + (t - r) * Math.cos(i) + r);
+}
+function f(e, n, r) {
+	return d(e, n, t(r));
+}
+function p(e, t = [0, 0]) {
+	return a(e[0] + t[0], e[1] + t[1]);
+}
+function m(e, t) {
+	return a((e[0] + t[0]) / 2, (e[1] + t[1]) / 2);
+}
+function h(e, t) {
+	return Math.hypot(t[0] - e[0], t[1] - e[1]);
+}
+function g(e, t) {
+	let n = t[0] - e[0], r = t[1] - e[1];
+	return n * n + r * r;
+}
+var _ = (e, t, i) => p(t, r(n(e, t), i)), v = (e, t, n) => t[0] <= Math.max(e[0], n[0]) && t[0] >= Math.min(e[0], n[0]) && t[1] <= Math.max(e[1], n[1]) && t[1] >= Math.min(e[1], n[1]);
+//#endregion
+export { l as isPoint, v as isPointWithinBounds, m as pointCenter, h as pointDistance, g as pointDistanceSq, a as pointFrom, o as pointFromArray, s as pointFromPair, c as pointFromVector, f as pointRotateDegs, d as pointRotateRads, _ as pointScaleFromOrigin, p as pointTranslate, u as pointsEqual };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,6 @@
+import type { GlobalPoint, LocalPoint, Polygon } from './types';
+export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
+export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
+export declare const polygonIncludesPoint: <Point extends LocalPoint | GlobalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
+export declare const polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
+export declare const pointOnPolygon: <Point extends LocalPoint | GlobalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/draw/libs/math/polygon.js

@@ -0,0 +1,42 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { PRECISION as e } from "./utils.js";
+import { pointsEqual as t } from "./point.js";
+import { lineSegment as n, pointOnLineSegment as r } from "./segment.js";
+//#region components/pc/draw/libs/math/polygon.ts
+function i(...e) {
+	return l(e);
+}
+function a(e) {
+	return l(e);
+}
+var o = (e, t) => {
+	let n = e[0], r = e[1], i = !1;
+	for (let e = 0, a = t.length - 1; e < t.length; a = e++) {
+		let o = t[e][0], s = t[e][1], c = t[a][0], l = t[a][1];
+		(s > r && l <= r || s <= r && l > r) && n < (c - o) * (r - s) / (l - s) + o && (i = !i);
+	}
+	return i;
+}, s = (e, t) => {
+	let [n, r] = e, i = 0;
+	for (let e = 0; e < t.length; e++) {
+		let a = (e + 1) % t.length, [o, s] = t[e], [c, l] = t[a];
+		s <= r ? l > r && (c - o) * (r - s) - (n - o) * (l - s) > 0 && i++ : l <= r && (c - o) * (r - s) - (n - o) * (l - s) < 0 && i--;
+	}
+	return i !== 0;
+}, c = (t, i, a = e) => {
+	let o = !1;
+	for (let e = 0, s = i.length - 1; e < s; e++) if (r(t, n(i[e], i[e + 1]), a)) {
+		o = !0;
+		break;
+	}
+	return o;
+};
+function l(e) {
+	return u(e) ? e : [...e, e[0]];
+}
+function u(e) {
+	return t(e[0], e[e.length - 1]);
+}
+//#endregion
+export { c as pointOnPolygon, i as polygon, a as polygonFromPoints, o as polygonIncludesPoint, s as polygonIncludesPointNonZero };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,42 @@
+import type { InclusiveRange } from './types';
+/**
+ * Create an inclusive range from the two numbers provided.
+ *
+ * @param start Start of the range
+ * @param end End of the range
+ * @returns
+ */
+export declare function rangeInclusive(start: number, end: number): InclusiveRange;
+/**
+ * Turn a number pair into an inclusive range.
+ *
+ * @param pair The number pair to convert to an inclusive range
+ * @returns The new inclusive range
+ */
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): InclusiveRange;
+/**
+ * Given two ranges, return if the two ranges overlap with each other e.g.
+ * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].
+ *
+ * @param param0 One of the ranges to compare
+ * @param param1 The other range to compare against
+ * @returns TRUE if the ranges overlap
+ */
+export declare const rangesOverlap: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => boolean;
+/**
+ * Given two ranges,return ther intersection of the two ranges if any e.g. the
+ * intersection of [1, 3] and [2, 4] is [2, 3].
+ *
+ * @param param0 The first range to compare
+ * @param param1 The second range to compare
+ * @returns The inclusive range intersection or NULL if no intersection
+ */
+export declare const rangeIntersection: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => InclusiveRange | null;
+/**
+ * Determine if a value is inside a range.
+ *
+ * @param value The value to check
+ * @param range The range
+ * @returns
+ */
+export declare const rangeIncludesValue: (value: number, [min, max]: InclusiveRange) => boolean;

package/draw/libs/math/range.js

@@ -0,0 +1,17 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { toBrandedType as e } from "../../common/utils.js";
+import "../../common/index.js";
+//#region components/pc/draw/libs/math/range.ts
+function t(t, n) {
+	return e([t, n]);
+}
+function n(t) {
+	return e(t);
+}
+var r = ([e, t], [n, r]) => e <= n ? t >= n : e >= n ? r >= e : !1, i = ([t, n], [r, i]) => {
+	let a = Math.max(t, r), o = Math.min(n, i);
+	return a <= o ? e([a, o]) : null;
+}, a = (e, [t, n]) => e >= t && e <= n;
+//#endregion
+export { a as rangeIncludesValue, t as rangeInclusive, n as rangeInclusiveFromPair, i as rangeIntersection, r as rangesOverlap };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,5 @@
+import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from './types';
+export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
+export declare function rectangleFromNumberSequence<Point extends LocalPoint | GlobalPoint>(minX: number, minY: number, maxX: number, maxY: number): Rectangle<Point>;
+export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];
+export declare function rectangleIntersectRectangle<Point extends LocalPoint | GlobalPoint>(rectangle1: Rectangle<Point>, rectangle2: Rectangle<Point>): boolean;

package/draw/libs/math/rectangle.js

@@ -0,0 +1,25 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { pointFrom as e } from "./point.js";
+import { lineSegment as t, lineSegmentIntersectionPoints as n } from "./segment.js";
+//#region components/pc/draw/libs/math/rectangle.ts
+function r(e, t) {
+	return [e, t];
+}
+function i(t, n, i, a) {
+	return r(e(t, n), e(i, a));
+}
+function a(r, i) {
+	return [
+		t(r[0], e(r[1][0], r[0][1])),
+		t(e(r[1][0], r[0][1]), r[1]),
+		t(r[1], e(r[0][0], r[1][1])),
+		t(e(r[0][0], r[1][1]), r[0])
+	].map((e) => n(i, e)).filter((e) => !!e);
+}
+function o(e, t) {
+	let [[n, r], [i, a]] = e, [[o, s], [c, l]] = t;
+	return n < c && i > o && r < l && a > s;
+}
+//#endregion
+export { r as rectangle, i as rectangleFromNumberSequence, a as rectangleIntersectLineSegment, o as rectangleIntersectRectangle };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,40 @@
+import type { GlobalPoint, LineSegment, LocalPoint, Radians } from './types';
+/**
+ * Create a line segment from two points.
+ *
+ * @param points The two points delimiting the line segment on each end
+ * @returns The line segment delineated by the points
+ */
+export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
+/**
+ *
+ * @param segment
+ * @returns
+ */
+export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
+/**
+ * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
+ * note that when the origin is not given, the midpoint of the given line is used as the origin.
+ *
+ * @param l
+ * @param angle
+ * @param origin
+ * @returns
+ */
+export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point) => LineSegment<Point>;
+/**
+ * Calculates the point two line segments with a definite start and end point
+ * intersect at.
+ */
+export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
+export declare const pointOnLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>) => number;
+/**
+ * Returns the intersection point of a segment and a line
+ *
+ * @param l
+ * @param s
+ * @returns
+ */
+export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;
+export declare function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(s1: LineSegment<Point>, s2: LineSegment<Point>): number;

package/draw/libs/math/segment.js

@@ -0,0 +1,38 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { PRECISION as e } from "./utils.js";
+import { vectorAdd as t, vectorCross as n, vectorFromPoint as r, vectorScale as i, vectorSubtract as a } from "./vector.js";
+import { isPoint as o, pointCenter as s, pointFromVector as c, pointRotateRads as l } from "./point.js";
+import { line as u, linesIntersectAt as d } from "./line.js";
+import { isArray as f } from "@unicom-cloud/utils/is";
+//#region components/pc/draw/libs/math/segment.ts
+function p(e, t) {
+	return [e, t];
+}
+var m = (e) => f(e) && e.length === 2 && o(e[0]) && o(e[0]), h = (e, t, n) => p(l(e[0], n || s(e[0], e[1]), t), l(e[1], n || s(e[0], e[1]), t)), g = (e, o) => {
+	let s = r(e[0]), l = r(e[1]), u = r(o[0]), d = r(o[1]), f = a(l, s), p = a(d, u), m = n(f, p);
+	if (m === 0) return null;
+	let h = a(r(o[0]), r(e[0])), g = n(h, f) / m, _ = n(h, p) / m;
+	if (g === 0) return null;
+	let v = t(s, i(f, _));
+	return _ >= 0 && _ < 1 && g >= 0 && g < 1 ? c(v) : null;
+}, _ = (t, n, r = e) => {
+	let i = v(t, n);
+	return i === 0 ? !0 : i < r;
+}, v = (e, t) => {
+	let [n, r] = e, [[i, a], [o, s]] = t, c = n - i, l = r - a, u = o - i, d = s - a, f = c * u + l * d, p = u * u + d * d, m = -1;
+	p !== 0 && (m = f / p);
+	let h, g;
+	m < 0 ? (h = i, g = a) : m > 1 ? (h = o, g = s) : (h = i + m * u, g = a + m * d);
+	let _ = n - h, v = r - g;
+	return Math.sqrt(_ * _ + v * v);
+};
+function y(e, t, n) {
+	let r = d(u(e[0], e[1]), u(t[0], t[1]));
+	return !r || !_(r, t, n) || !_(r, e, n) ? null : r;
+}
+function b(e, t) {
+	return y(e, t) ? 0 : Math.min(v(e[0], t), v(e[1], t), v(t[0], e), v(t[1], e));
+}
+//#endregion
+export { v as distanceToLineSegment, m as isLineSegment, p as lineSegment, y as lineSegmentIntersectionPoints, h as lineSegmentRotate, b as lineSegmentsDistance, _ as pointOnLineSegment, g as segmentsIntersectAt };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,11 @@
+import type { GlobalPoint, LocalPoint, Triangle } from './types';
+/**
+ * Tests if a point lies inside a triangle. This function
+ * will return FALSE if the point lies exactly on the sides
+ * of the triangle.
+ *
+ * @param triangle The triangle to test the point for
+ * @param p The point to test whether is in the triangle
+ * @returns TRUE if the point is inside of the triangle
+ */
+export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;

package/draw/libs/math/triangle.js

@@ -0,0 +1,9 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+//#region components/pc/draw/libs/math/triangle.ts
+function e([e, t, n], r) {
+	let i = (e, t, n) => (e[0] - n[0]) * (t[1] - n[1]) - (t[0] - n[0]) * (e[1] - n[1]), a = i(r, e, t), o = i(r, t, n), s = i(r, n, e);
+	return !((a < 0 || o < 0 || s < 0) && (a > 0 || o > 0 || s > 0));
+}
+//#endregion
+export { e as triangleIncludesPoint };
+/* 独立思考，明辨是非 */

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

@@ -0,0 +1,106 @@
+/**
+ * By definition one radian is the angle subtended at the centre
+ * of a circle by an arc that is equal in length to the radius.
+ */
+export type Radians = number & {
+    _brand: 'math__radian';
+};
+/**
+ * An angle measurement of a plane angle in which one full
+ * rotation is 360 degrees.
+ */
+export type Degrees = number & {
+    _brand: 'math_degree';
+};
+/**
+ * A number range which includes the start and end numbers in the range.
+ */
+export type InclusiveRange = [number, number] & {
+    _brand: 'math_degree';
+};
+/**
+ * Represents a 2D position in world or canvas space. A
+ * global coordinate.
+ */
+export type GlobalPoint = [x: number, y: number] & {
+    _brand: 'math__globalpoint';
+};
+/**
+ * Represents a 2D position in whatever local space it's
+ * needed. A local coordinate.
+ */
+export type LocalPoint = [x: number, y: number] & {
+    _brand: 'math__localpoint';
+};
+/**
+ * A line is an infinitely long object with no width, depth, or curvature.
+ */
+export type Line<P extends GlobalPoint | LocalPoint> = [p: P, q: P] & {
+    _brand: 'math_line';
+};
+/**
+ * In geometry, a line segment is a part of a straight
+ * line that is bounded by two distinct end points, and
+ * contains every point on the line that is between its endpoints.
+ */
+export type LineSegment<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: 'math_linesegment';
+};
+/**
+ * Represents a 2D vector
+ */
+export type Vector = [u: number, v: number] & {
+    _brand: 'math__vector';
+};
+/**
+ * A triangle represented by 3 points
+ */
+export type Triangle<P extends GlobalPoint | LocalPoint> = [
+    a: P,
+    b: P,
+    c: P
+] & {
+    _brand: 'math__triangle';
+};
+/**
+ * A rectangular shape represented by 4 points at its corners
+ */
+export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: 'math__rectangle';
+};
+/**
+ * A polygon is a closed shape by connecting the given points
+ * rectangles and diamonds are modelled by polygons
+ */
+export type Polygon<Point extends GlobalPoint | LocalPoint> = Point[] & {
+    _brand: 'math_polygon';
+};
+/**
+ * Cubic bezier curve with four control points
+ */
+export type Curve<Point extends GlobalPoint | LocalPoint> = [
+    Point,
+    Point,
+    Point,
+    Point
+] & {
+    _brand: 'math_curve';
+};
+export type PolarCoords = [
+    radius: number,
+    /** angle in radians */
+    angle: number
+];
+/**
+  An ellipse is specified by its center, angle, and its major and minor axes
+  but for the sake of simplicity, we've used halfWidth and halfHeight instead
+  in replace of semi major and semi minor axes
+ */
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+    center: Point;
+    halfWidth: number;
+    halfHeight: number;
+} & {
+    _brand: 'math_ellipse';
+};
+export type ElementsSegmentsMap = Map<string, LineSegment<GlobalPoint>[]>;