@retikz/core 0.1.0-alpha.4 → 0.1.0-beta.1

package/dist/lib/geometry/diamond.d.ts

@@ -1,43 +1,27 @@
 import { Position } from './point';
-/**
- * 菱形：几何中心 (x, y) + 半轴长 halfA（水平）/ halfB（垂直）+ 可选旋转。
- * 4 个顶点位于 (±halfA, 0) 与 (0, ±halfB)，4 条边界线把这些顶点两两相连。
- */
+import { RectAnchor } from './rect';
+/** 菱形：中心 + halfA/halfB 半轴长 + 可选旋转；顶点在 (±halfA,0) 与 (0,±halfB) */
 export type Diamond = {
-    /** 中心横坐标 */
     x: number;
-    /** 中心纵坐标 */
     y: number;
-    /** 水平半轴长（中心到 east/west 顶点的距离） */
+    /** 中心到 east/west 顶点距离 */
     halfA: number;
-    /** 垂直半轴长（中心到 north/south 顶点的距离） */
+    /** 中心到 north/south 顶点距离 */
     halfB: number;
-    /** 绕几何中心旋转弧度；省略或 0 表示不旋转 */
+    /** 绕中心旋转弧度 */
     rotate?: number;
 };
-/** 菱形 9 个标准 anchor 名（4 顶点 + 4 边中点 + 中心） */
-export type DiamondAnchor = 'center' | 'north' | 'south' | 'east' | 'west' | 'north-east' | 'north-west' | 'south-east' | 'south-west';
 /** 菱形相关基础工具 */
 export declare const diamond: {
     /** 中心 */
     center: (d: Diamond) => Position;
-    /**
-     * 判断点是否在菱形内（含边界，考虑旋转）。
-     * 菱形方程：|x|/halfA + |y|/halfB ≤ 1。
-     */
+    /** 点是否在菱形内（含边界，含旋转）；方程 |x|/halfA + |y|/halfB ≤ 1 */
     contains: (d: Diamond, p: Position) => boolean;
+    /** 9 个 anchor：N/S/E/W=顶点，NE/NW/SE/SW=边中点，center=中心 */
+    anchor: (d: Diamond, name: RectAnchor) => Position;
     /**
-     * 9 个标准 anchor 的世界坐标。
-     * - N/S/E/W：四个顶点
-     * - NE/NW/SE/SW：四条边的中点
-     * - center：几何中心
-     */
-    anchor: (d: Diamond, name: DiamondAnchor) => Position;
-    /**
-     * 从中心向 toward 方向画射线，求与菱形 4 条边之一的交点。
-     * 菱形方程：|x|/halfA + |y|/halfB = 1。
-     * 沿方向 (lx, ly) 缩放 t 倍命中：t × (|lx|/halfA + |ly|/halfB) = 1
-     * → t = 1 / (|lx|/halfA + |ly|/halfB)。
+     * 从中心向 toward 方向射线与菱形 4 边的交点
+     * @description 菱形方程 |x|/halfA + |y|/halfB = 1；沿方向 (lx,ly) 缩放 t 倍命中：t = 1 / (|lx|/halfA + |ly|/halfB)
      */
     boundaryPoint: (d: Diamond, toward: Position) => Position;
 };

package/dist/lib/geometry/diamond.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diamond.d.ts","sourceRoot":"","sources":["../../../src/geometry/diamond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,YAAY;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,YAAY;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,2CAA2C;AAC3C,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,OAAO,GACP,OAAO,GACP,MAAM,GACN,MAAM,GACN,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,CAAC;AAoBjB,eAAe;AACf,eAAO,MAAM,OAAO;IAClB,SAAS;gBACG,OAAO,KAAG,QAAQ;IAC9B;;;OAGG;kBACW,OAAO,KAAK,QAAQ,KAAG,OAAO;IAI5C;;;;;OAKG;gBACS,OAAO,QAAQ,aAAa,KAAG,QAAQ;IAqCnD;;;;;OAKG;uBACgB,OAAO,UAAU,QAAQ,KAAG,QAAQ;CAOxD,CAAC"}
+{"version":3,"file":"diamond.d.ts","sourceRoot":"","sources":["../../../src/geometry/diamond.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,iEAAiE;AACjE,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAe;AACf,eAAO,MAAM,OAAO;IAClB,SAAS;gBACG,OAAO,KAAG,QAAQ;IAC9B,oDAAoD;kBACtC,OAAO,KAAK,QAAQ,KAAG,OAAO;IAI5C,sDAAsD;gBAC1C,OAAO,QAAQ,UAAU,KAAG,QAAQ;IAqClD;;;OAGG;uBACkB,OAAO,UAAU,QAAQ,KAAG,QAAQ;CAOxD,CAAC"}

package/dist/lib/geometry/ellipse.cjs

@@ -1,35 +1,18 @@
+const require__transform = require("./_transform.cjs");
 //#region src/geometry/ellipse.ts
 var SQRT_HALF = Math.SQRT1_2;
-var localToWorld = (e, local) => {
-	const angle = e.rotate ?? 0;
-	if (angle === 0) return [e.x + local[0], e.y + local[1]];
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [e.x + local[0] * cos - local[1] * sin, e.y + local[0] * sin + local[1] * cos];
-};
-var worldToLocal = (e, world) => {
-	const tx = world[0] - e.x;
-	const ty = world[1] - e.y;
-	const angle = e.rotate ?? 0;
-	if (angle === 0) return [tx, ty];
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [tx * cos + ty * sin, -tx * sin + ty * cos];
-};
 /** 椭圆相关基础工具 */
 var ellipse = {
 	/** 中心 */
 	center: (e) => [e.x, e.y],
 	/** 判断点是否在椭圆内（含边界，考虑旋转） */
 	contains: (e, p) => {
-		const [lx, ly] = worldToLocal(e, p);
+		const [lx, ly] = require__transform.worldToLocal(e, p);
 		return lx * lx / (e.rx * e.rx) + ly * ly / (e.ry * e.ry) <= 1;
 	},
 	/**
-	* 9 个标准 anchor 的世界坐标。
-	* 对角 anchor（NE/NW/SE/SW）取参数曲线 t=π/4 处的点：
-	* (rx·cos(π/4), ry·sin(π/4)) = (rx/√2, ry/√2)。
-	* 这与 TikZ 椭圆对角 anchor 的"参数等分"约定一致。
+	* 9 个 anchor 的世界坐标
+	* @description 对角（NE/NW/SE/SW）取参数曲线 t=π/4 处 (rx/√2, ry/√2)，与 TikZ 椭圆 anchor 参数等分约定一致
 	*/
 	anchor: (e, name) => {
 		let lx = 0;
@@ -65,21 +48,19 @@ var ellipse = {
 				ly = e.ry * SQRT_HALF;
 				break;
 		}
-		return localToWorld(e, [lx, ly]);
+		return require__transform.localToWorld(e, [lx, ly]);
 	},
 	/**
-	* 从中心向 toward 方向画射线，求与椭圆的交点。
-	* 椭圆方程：(x/rx)² + (y/ry)² = 1。
-	* 沿方向 (lx, ly) 缩放 t 倍命中：t² × ((lx/rx)² + (ly/ry)²) = 1
-	* → t = 1 / √((lx/rx)² + (ly/ry)²)。
+	* 从中心向 toward 方向射线与椭圆交点
+	* @description 椭圆方程 (x/rx)² + (y/ry)² = 1；沿 (lx,ly) 缩放 t 倍命中 t = 1 / √((lx/rx)² + (ly/ry)²)
 	*/
 	boundaryPoint: (e, toward) => {
-		const [lx, ly] = worldToLocal(e, toward);
+		const [lx, ly] = require__transform.worldToLocal(e, toward);
 		if (lx === 0 && ly === 0) return [e.x, e.y];
 		const a = lx / e.rx;
 		const b = ly / e.ry;
 		const t = 1 / Math.sqrt(a * a + b * b);
-		return localToWorld(e, [lx * t, ly * t]);
+		return require__transform.localToWorld(e, [lx * t, ly * t]);
 	}
 };
 //#endregion

package/dist/lib/geometry/ellipse.d.ts

@@ -1,19 +1,16 @@
 import { Position } from './point';
-/** 椭圆：几何中心 (x, y) + 半长轴 rx / 半短轴 ry + 可选旋转（弧度） */
+import { RectAnchor } from './rect';
+/** 椭圆：中心 + 半长轴 rx / 半短轴 ry + 可选旋转 */
 export type Ellipse = {
-    /** 中心横坐标 */
     x: number;
-    /** 中心纵坐标 */
     y: number;
-    /** 半长轴（沿本地 +x 方向） */
+    /** 沿本地 +x */
     rx: number;
-    /** 半短轴（沿本地 +y 方向） */
+    /** 沿本地 +y */
     ry: number;
-    /** 绕几何中心旋转弧度；省略或 0 表示不旋转 */
+    /** 绕中心旋转弧度 */
     rotate?: number;
 };
-/** 椭圆 9 个标准 anchor 名（含义与 RECT_ANCHORS 一致） */
-export type EllipseAnchor = 'center' | 'north' | 'south' | 'east' | 'west' | 'north-east' | 'north-west' | 'south-east' | 'south-west';
 /** 椭圆相关基础工具 */
 export declare const ellipse: {
     /** 中心 */
@@ -21,17 +18,13 @@ export declare const ellipse: {
     /** 判断点是否在椭圆内（含边界，考虑旋转） */
     contains: (e: Ellipse, p: Position) => boolean;
     /**
-     * 9 个标准 anchor 的世界坐标。
-     * 对角 anchor（NE/NW/SE/SW）取参数曲线 t=π/4 处的点：
-     * (rx·cos(π/4), ry·sin(π/4)) = (rx/√2, ry/√2)。
-     * 这与 TikZ 椭圆对角 anchor 的"参数等分"约定一致。
+     * 9 个 anchor 的世界坐标
+     * @description 对角（NE/NW/SE/SW）取参数曲线 t=π/4 处 (rx/√2, ry/√2)，与 TikZ 椭圆 anchor 参数等分约定一致
      */
-    anchor: (e: Ellipse, name: EllipseAnchor) => Position;
+    anchor: (e: Ellipse, name: RectAnchor) => Position;
     /**
-     * 从中心向 toward 方向画射线，求与椭圆的交点。
-     * 椭圆方程：(x/rx)² + (y/ry)² = 1。
-     * 沿方向 (lx, ly) 缩放 t 倍命中：t² × ((lx/rx)² + (ly/ry)²) = 1
-     * → t = 1 / √((lx/rx)² + (ly/ry)²)。
+     * 从中心向 toward 方向射线与椭圆交点
+     * @description 椭圆方程 (x/rx)² + (y/ry)² = 1；沿 (lx,ly) 缩放 t 倍命中 t = 1 / √((lx/rx)² + (ly/ry)²)
      */
     boundaryPoint: (e: Ellipse, toward: Position) => Position;
 };

package/dist/lib/geometry/ellipse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ellipse.d.ts","sourceRoot":"","sources":["../../../src/geometry/ellipse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,kDAAkD;AAClD,MAAM,MAAM,OAAO,GAAG;IACpB,YAAY;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,YAAY;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,qBAAqB;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAIF,6CAA6C;AAC7C,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,OAAO,GACP,OAAO,GACP,MAAM,GACN,MAAM,GACN,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,CAAC;AAoBjB,eAAe;AACf,eAAO,MAAM,OAAO;IAClB,SAAS;gBACG,OAAO,KAAG,QAAQ;IAC9B,0BAA0B;kBACZ,OAAO,KAAK,QAAQ,KAAG,OAAO;IAI5C;;;;;OAKG;gBACS,OAAO,QAAQ,aAAa,KAAG,QAAQ;IAqCnD;;;;;OAKG;uBACgB,OAAO,UAAU,QAAQ,KAAG,QAAQ;CAQxD,CAAC"}
+{"version":3,"file":"ellipse.d.ts","sourceRoot":"","sources":["../../../src/geometry/ellipse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,qCAAqC;AACrC,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,aAAa;IACb,EAAE,EAAE,MAAM,CAAC;IACX,aAAa;IACb,EAAE,EAAE,MAAM,CAAC;IACX,cAAc;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAIF,eAAe;AACf,eAAO,MAAM,OAAO;IAClB,SAAS;gBACG,OAAO,KAAG,QAAQ;IAC9B,0BAA0B;kBACZ,OAAO,KAAK,QAAQ,KAAG,OAAO;IAI9C;;;OAGG;gBACW,OAAO,QAAQ,UAAU,KAAG,QAAQ;IAqClD;;;OAGG;uBACkB,OAAO,UAAU,QAAQ,KAAG,QAAQ;CAQxD,CAAC"}

package/dist/lib/geometry/point.cjs

@@ -3,25 +3,24 @@ const require_polar = require("./polar.cjs");
 var RAD_TO_DEG = 180 / Math.PI;
 /** 二维向量 / 坐标的基础运算工具集 */
 var point = {
-	/** 两点相加（向量加法）：a + b */
+	/** 向量加 a + b */
 	add: (a, b) => [a[0] + b[0], a[1] + b[1]],
-	/** 两点相减（向量减法）：a - b */
+	/** 向量减 a - b */
 	sub: (a, b) => [a[0] - b[0], a[1] - b[1]],
-	/** 等比缩放：a * k */
+	/** 等比缩放 a * k */
 	scale: (a, k) => [a[0] * k, a[1] * k],
-	/** 判断两点坐标是否完全相等（精确比较，不带容差） */
+	/** 两点精确相等（不带容差） */
 	equal: (a, b) => a[0] === b[0] && a[1] === b[1],
-	/** 笛卡尔点 → 极坐标（angle 落在 (-180, 180]，origin 取默认 [0, 0]） */
+	/** 笛卡尔 → 极坐标（angle ∈ (-180,180]，origin 默认 [0,0]） */
 	toPolar: (p) => ({
 		angle: Math.atan2(p[1], p[0]) * RAD_TO_DEG,
 		radius: Math.hypot(p[0], p[1])
 	}),
 	/**
-	* 判断两个点是否相同（跨坐标系）。每个参数可以是笛卡尔 [x, y] 或 PolarPosition；
-	* 极坐标先转为笛卡尔，再按 precision 指定的小数位数四舍五入比较。
-	* `polar.equal` 委托到本方法。
+	* 跨坐标系两点相同判断（笛卡尔或 PolarPosition）
+	* @description 极坐标先转笛卡尔再按 precision 四舍五入比较；polar.equal 委托到本方法
 	* @param precision 小数点后位数；默认 2
-	* @throws 当 PolarPosition 的 origin 是节点 id 字符串时——字符串解析需 Scene 上下文
+	* @throws 当 PolarPosition.origin 是节点 id 字符串时（需 Scene 上下文）
 	*/
 	equalPolar: (a, b, precision = 2) => {
 		const aCart = Array.isArray(a) ? a : require_polar.polar.toPosition(a);

package/dist/lib/geometry/point.d.ts

@@ -3,22 +3,21 @@ import { PolarPosition } from './polar';
 export type Position = [number, number];
 /** 二维向量 / 坐标的基础运算工具集 */
 export declare const point: {
-    /** 两点相加（向量加法）：a + b */
+    /** 向量加 a + b */
     add: (a: Position, b: Position) => Position;
-    /** 两点相减（向量减法）：a - b */
+    /** 向量减 a - b */
     sub: (a: Position, b: Position) => Position;
-    /** 等比缩放：a * k */
+    /** 等比缩放 a * k */
     scale: (a: Position, k: number) => Position;
-    /** 判断两点坐标是否完全相等（精确比较，不带容差） */
+    /** 两点精确相等（不带容差） */
     equal: (a: Position, b: Position) => boolean;
-    /** 笛卡尔点 → 极坐标（angle 落在 (-180, 180]，origin 取默认 [0, 0]） */
+    /** 笛卡尔 → 极坐标（angle ∈ (-180,180]，origin 默认 [0,0]） */
     toPolar: (p: Position) => PolarPosition;
     /**
-     * 判断两个点是否相同（跨坐标系）。每个参数可以是笛卡尔 [x, y] 或 PolarPosition；
-     * 极坐标先转为笛卡尔，再按 precision 指定的小数位数四舍五入比较。
-     * `polar.equal` 委托到本方法。
+     * 跨坐标系两点相同判断（笛卡尔或 PolarPosition）
+     * @description 极坐标先转笛卡尔再按 precision 四舍五入比较；polar.equal 委托到本方法
      * @param precision 小数点后位数；默认 2
-     * @throws 当 PolarPosition 的 origin 是节点 id 字符串时——字符串解析需 Scene 上下文
+     * @throws 当 PolarPosition.origin 是节点 id 字符串时（需 Scene 上下文）
      */
     equalPolar: (a: Position | PolarPosition, b: Position | PolarPosition, precision?: number) => boolean;
 };

package/dist/lib/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAS,MAAM,SAAS,CAAC;AAEpD,oBAAoB;AACpB,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAIxC,wBAAwB;AACxB,eAAO,MAAM,KAAK;IAChB,uBAAuB;aACd,QAAQ,KAAK,QAAQ,KAAG,QAAQ;IACzC,uBAAuB;aACd,QAAQ,KAAK,QAAQ,KAAG,QAAQ;IACzC,iBAAiB;eACN,QAAQ,KAAK,MAAM,KAAG,QAAQ;IACzC,8BAA8B;eACnB,QAAQ,KAAK,QAAQ,KAAG,OAAO;IAC1C,yDAAyD;iBAC5C,QAAQ,KAAG,aAAa;IAIrC;;;;;;OAMG;oBAEE,QAAQ,GAAG,aAAa,KACxB,QAAQ,GAAG,aAAa,yBAE1B,OAAO;CASX,CAAC"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAS,MAAM,SAAS,CAAC;AAEpD,oBAAoB;AACpB,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAIxC,wBAAwB;AACxB,eAAO,MAAM,KAAK;IAChB,gBAAgB;aACP,QAAQ,KAAK,QAAQ,KAAG,QAAQ;IACzC,gBAAgB;aACP,QAAQ,KAAK,QAAQ,KAAG,QAAQ;IACzC,iBAAiB;eACN,QAAQ,KAAK,MAAM,KAAG,QAAQ;IACzC,mBAAmB;eACR,QAAQ,KAAK,QAAQ,KAAG,OAAO;IAC1C,oDAAoD;iBACvC,QAAQ,KAAG,aAAa;IAIrC;;;;;OAKG;oBAEE,QAAQ,GAAG,aAAa,KACxB,QAAQ,GAAG,aAAa,yBAE1B,OAAO;CASX,CAAC"}

package/dist/lib/geometry/polar.cjs

@@ -1,18 +1,11 @@
 const require_point = require("./point.cjs");
 //#region src/geometry/polar.ts
 var DEG_TO_RAD = Math.PI / 180;
-var RAD_TO_DEG = 180 / Math.PI;
-/**
-* 极坐标 ↔ 笛卡尔坐标 转换工具集。
-*
-* 注意 polar 不参与几何计算——参与计算时一律先用 `polar.toPosition` 转成 Position。
-* 详见本文件顶部的整体说明。
-*/
+/** 极坐标 ↔ 笛卡尔转换工具集（polar 不参与几何计算，参与时先 toPosition） */
 var polar = {
 	/**
-	* 极坐标 → 笛卡尔位置（递归处理 origin）。
-	* **限制**：origin 为字符串（节点 id）时本方法无法解析，会抛错——
-	* 字符串解析依赖 Scene 编译器的 nodeIndex 上下文。
+	* 极坐标 → 笛卡尔位置（递归处理 origin）
+	* @description origin 为字符串（节点 id）时抛错——字符串解析依赖 Scene 编译器 nodeIndex
 	*/
 	toPosition: (p) => {
 		let origin;
@@ -23,20 +16,16 @@ var polar = {
 		const rad = p.angle * DEG_TO_RAD;
 		return [origin[0] + Math.cos(rad) * p.radius, origin[1] + Math.sin(rad) * p.radius];
 	},
-	/** 笛卡尔位置 → 极坐标（angle 落在 (-180, 180]，origin 取默认 [0, 0]） */
-	fromPosition: (p) => ({
-		angle: Math.atan2(p[1], p[0]) * RAD_TO_DEG,
-		radius: Math.hypot(p[0], p[1])
-	}),
-	/** 在某个原点附近按极坐标偏移；返回结果点的世界笛卡尔坐标 */
+	/** 笛卡尔 → 极坐标（point.toPolar 别名，angle ∈ (-180,180]，origin 默认 [0,0]） */
+	fromPosition: (p) => require_point.point.toPolar(p),
+	/** 在原点附近按极坐标偏移，返回结果点的世界笛卡尔坐标 */
 	offsetFrom: (origin, offset) => {
 		const rad = offset.angle * DEG_TO_RAD;
 		return [origin[0] + Math.cos(rad) * offset.radius, origin[1] + Math.sin(rad) * offset.radius];
 	},
 	/**
-	* 判断两个点是否相同（跨坐标系）。每个参数可以是笛卡尔 [x, y] 或 PolarPosition；
-	* 极坐标先转为笛卡尔，再按 precision 指定的小数位数四舍五入比较。
-	* 实际是 `point.equalPolar` 的别名（同一份实现，两处可发现）。
+	* 跨坐标系两点相同判断（point.equalPolar 别名）
+	* @description 极坐标先转笛卡尔再按 precision 四舍五入比较
 	* @param precision 小数点后位数；默认 2
 	*/
 	equal: (a, b, precision = 2) => require_point.point.equalPolar(a, b, precision)

package/dist/lib/geometry/polar.d.ts

@@ -1,42 +1,33 @@
 import { Position } from './point';
 /**
- * 极坐标点：相对 origin 的角度 + 半径偏移。
- * - 可进 IR；Scene 编译时统一解析为笛卡尔
- * - 不直接参与几何计算，参与时先转为 Position（见本文件顶部说明）
- * - origin 可嵌套（PolarPosition），可引用节点 id（string），可直接给坐标（Position），省略表示原点 [0, 0]
+ * 极坐标点：相对 origin 的角度 + 半径偏移
+ * @description IR 保留 polar 形态，Scene 编译时统一解析为笛卡尔；origin 可嵌套/节点 id/坐标，省略表示 [0,0]
  */
 export type PolarPosition = {
-    /** 极坐标原点：节点 id / 笛卡尔位置 / 嵌套极坐标；省略表示 [0, 0] */
+    /** 极坐标原点：节点 id / 笛卡尔 / 嵌套极坐标；省略表示 [0,0] */
     origin?: string | Position | PolarPosition;
-    /** 角度（度数，逆时针为正，与 TikZ / 数学习惯一致） */
+    /** 角度（度数）：从 +x 轴量起，90° 朝 +y（屏幕下方），与 ArcStep / Node label 角度约定一致 */
     angle: number;
-    /** 半径（user units，应为非负） */
+    /** 半径（非负） */
     radius: number;
 };
-/**
- * 极坐标 ↔ 笛卡尔坐标 转换工具集。
- *
- * 注意 polar 不参与几何计算——参与计算时一律先用 `polar.toPosition` 转成 Position。
- * 详见本文件顶部的整体说明。
- */
+/** 极坐标 ↔ 笛卡尔转换工具集（polar 不参与几何计算，参与时先 toPosition） */
 export declare const polar: {
     /**
-     * 极坐标 → 笛卡尔位置（递归处理 origin）。
-     * **限制**：origin 为字符串（节点 id）时本方法无法解析，会抛错——
-     * 字符串解析依赖 Scene 编译器的 nodeIndex 上下文。
+     * 极坐标 → 笛卡尔位置（递归处理 origin）
+     * @description origin 为字符串（节点 id）时抛错——字符串解析依赖 Scene 编译器 nodeIndex
      */
     toPosition: (p: PolarPosition) => Position;
-    /** 笛卡尔位置 → 极坐标（angle 落在 (-180, 180]，origin 取默认 [0, 0]） */
+    /** 笛卡尔 → 极坐标（point.toPolar 别名，angle ∈ (-180,180]，origin 默认 [0,0]） */
     fromPosition: (p: Position) => PolarPosition;
-    /** 在某个原点附近按极坐标偏移；返回结果点的世界笛卡尔坐标 */
+    /** 在原点附近按极坐标偏移，返回结果点的世界笛卡尔坐标 */
     offsetFrom: (origin: Position, offset: {
         angle: number;
         radius: number;
     }) => Position;
     /**
-     * 判断两个点是否相同（跨坐标系）。每个参数可以是笛卡尔 [x, y] 或 PolarPosition；
-     * 极坐标先转为笛卡尔，再按 precision 指定的小数位数四舍五入比较。
-     * 实际是 `point.equalPolar` 的别名（同一份实现，两处可发现）。
+     * 跨坐标系两点相同判断（point.equalPolar 别名）
+     * @description 极坐标先转笛卡尔再按 precision 四舍五入比较
      * @param precision 小数点后位数；默认 2
      */
     equal: (a: Position | PolarPosition, b: Position | PolarPosition, precision?: number) => boolean;

package/dist/lib/geometry/polar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polar.d.ts","sourceRoot":"","sources":["../../../src/geometry/polar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,SAAS,CAAC;AAkB/C;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,aAAa,CAAC;IAC3C,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAKF;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;oBACa,aAAa,KAAG,QAAQ;IAmBxC,0DAA0D;sBACxC,QAAQ,KAAG,aAAa;IAI1C,kCAAkC;yBAExB,QAAQ,UACR;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KACxC,QAAQ;IAOX;;;;;OAKG;eAEE,QAAQ,GAAG,aAAa,KACxB,QAAQ,GAAG,aAAa,yBAE1B,OAAO;CACX,CAAC"}
+{"version":3,"file":"polar.d.ts","sourceRoot":"","sources":["../../../src/geometry/polar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,SAAS,CAAC;AAS/C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,aAAa,CAAC;IAC3C,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,aAAa;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAIF,oDAAoD;AACpD,eAAO,MAAM,KAAK;IAChB;;;OAGG;oBACa,aAAa,KAAG,QAAQ;IAmBxC,qEAAqE;sBACnD,QAAQ,KAAG,aAAa;IAC1C,gCAAgC;yBAEtB,QAAQ,UACR;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KACxC,QAAQ;IAOb;;;;OAIG;eAEI,QAAQ,GAAG,aAAa,KACxB,QAAQ,GAAG,aAAa,yBAE1B,OAAO;CACX,CAAC"}

package/dist/lib/geometry/rect.cjs

@@ -1,68 +1,28 @@
+const require__transform = require("./_transform.cjs");
 //#region src/geometry/rect.ts
-/**
-* 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
-* 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
-* 类型位置用 `RectAnchor`。
-*/
+/** 矩形 9 个标准 anchor 名常量（与 RectAnchor 配对，用 RECT_ANCHORS.NORTH 避免拼错） */
 var RECT_ANCHORS = {
-	/** 几何中心 */
 	CENTER: "center",
-	/** 上边中点 */
 	NORTH: "north",
-	/** 下边中点 */
 	SOUTH: "south",
-	/** 右边中点 */
 	EAST: "east",
-	/** 左边中点 */
 	WEST: "west",
-	/** 右上角 */
 	NORTH_EAST: "north-east",
-	/** 左上角 */
 	NORTH_WEST: "north-west",
-	/** 右下角 */
 	SOUTH_EAST: "south-east",
-	/** 左下角 */
 	SOUTH_WEST: "south-west"
 };
-/**
-* 把"以矩形中心为原点的本地坐标"转换为世界坐标。
-* 考虑 rect.rotate（弧度）的旋转。
-*/
-var localToWorld = (r, local) => {
-	const angle = r.rotate ?? 0;
-	if (angle === 0) return [r.x + local[0], r.y + local[1]];
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [r.x + local[0] * cos - local[1] * sin, r.y + local[0] * sin + local[1] * cos];
-};
-/**
-* 把世界坐标转换为"以矩形中心为原点的本地坐标"。
-* 与 localToWorld 互为逆变换。
-*/
-var worldToLocal = (r, world) => {
-	const tx = world[0] - r.x;
-	const ty = world[1] - r.y;
-	const angle = r.rotate ?? 0;
-	if (angle === 0) return [tx, ty];
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	return [tx * cos + ty * sin, -tx * sin + ty * cos];
-};
-/** 矩形相关基础工具 */
 var rect = {
-	/** 矩形几何中心点 */
+	/** 几何中心 */
 	center: (r) => [r.x, r.y],
-	/** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+	/** 点是否在矩形内（含边界，含旋转） */
 	contains: (r, p) => {
-		const [lx, ly] = worldToLocal(r, p);
+		const [lx, ly] = require__transform.worldToLocal(r, p);
 		const halfW = r.width / 2;
 		const halfH = r.height / 2;
 		return lx >= -halfW && lx <= halfW && ly >= -halfH && ly <= halfH;
 	},
-	/**
-	* 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
-	* 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
-	*/
+	/** 9 个 anchor 之一的世界坐标（含旋转），TikZ 命名 */
 	anchor: (r, name) => {
 		const halfW = r.width / 2;
 		const halfH = r.height / 2;
@@ -99,21 +59,18 @@ var rect = {
 				ly = halfH;
 				break;
 		}
-		return localToWorld(r, [lx, ly]);
+		return require__transform.localToWorld(r, [lx, ly]);
 	},
-	/**
-	* 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
-	* 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
-	*/
+	/** 从中心向 toward 方向射线与矩形边界交点（含旋转），Path 端点贴 Node 边界用 */
 	boundaryPoint: (r, toward) => {
-		const [localX, localY] = worldToLocal(r, toward);
+		const [localX, localY] = require__transform.worldToLocal(r, toward);
 		if (localX === 0 && localY === 0) return [r.x, r.y];
 		const halfW = r.width / 2;
 		const halfH = r.height / 2;
 		const tx = localX === 0 ? Infinity : halfW / Math.abs(localX);
 		const ty = localY === 0 ? Infinity : halfH / Math.abs(localY);
 		const t = Math.min(tx, ty);
-		return localToWorld(r, [localX * t, localY * t]);
+		return require__transform.localToWorld(r, [localX * t, localY * t]);
 	}
 };
 //#endregion

package/dist/lib/geometry/rect.d.ts

@@ -1,59 +1,35 @@
 import { Position } from './point';
-/** 轴对齐矩形：几何中心 (x, y) + 宽高 + 可选绕中心旋转 */
+/** 轴对齐矩形：几何中心 + 宽高 + 可选绕中心旋转 */
 export type Rect = {
-    /** 矩形几何中心横坐标 */
     x: number;
-    /** 矩形几何中心纵坐标 */
     y: number;
-    /** 矩形宽度（user units） */
     width: number;
-    /** 矩形高度（user units） */
     height: number;
-    /** 绕几何中心的旋转角（弧度）；省略或 0 表示不旋转 */
+    /** 绕中心旋转弧度 */
     rotate?: number;
 };
-/**
- * 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
- * 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
- * 类型位置用 `RectAnchor`。
- */
+/** 矩形 9 个标准 anchor 名常量（与 RectAnchor 配对，用 RECT_ANCHORS.NORTH 避免拼错） */
 export declare const RECT_ANCHORS: {
-    /** 几何中心 */
     readonly CENTER: "center";
-    /** 上边中点 */
     readonly NORTH: "north";
-    /** 下边中点 */
     readonly SOUTH: "south";
-    /** 右边中点 */
     readonly EAST: "east";
-    /** 左边中点 */
     readonly WEST: "west";
-    /** 右上角 */
     readonly NORTH_EAST: "north-east";
-    /** 左上角 */
     readonly NORTH_WEST: "north-west";
-    /** 右下角 */
     readonly SOUTH_EAST: "south-east";
-    /** 左下角 */
     readonly SOUTH_WEST: "south-west";
 };
-/** 矩形 anchor 名（与 TikZ 命名约定一致），由 `RECT_ANCHORS` 常量集合派生 */
+/** 矩形 anchor 名（与 TikZ 命名一致） */
 export type RectAnchor = (typeof RECT_ANCHORS)[keyof typeof RECT_ANCHORS];
-/** 矩形相关基础工具 */
 export declare const rect: {
-    /** 矩形几何中心点 */
+    /** 几何中心 */
     center: (r: Rect) => Position;
-    /** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+    /** 点是否在矩形内（含边界，含旋转） */
     contains: (r: Rect, p: Position) => boolean;
-    /**
-     * 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
-     * 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
-     */
+    /** 9 个 anchor 之一的世界坐标（含旋转），TikZ 命名 */
     anchor: (r: Rect, name: RectAnchor) => Position;
-    /**
-     * 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
-     * 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
-     */
+    /** 从中心向 toward 方向射线与矩形边界交点（含旋转），Path 端点贴 Node 边界用 */
     boundaryPoint: (r: Rect, toward: Position) => Position;
 };
 //# sourceMappingURL=rect.d.ts.map

package/dist/lib/geometry/rect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/geometry/rect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,uCAAuC;AACvC,MAAM,MAAM,IAAI,GAAG;IACjB,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,UAAU;;IAEV,UAAU;;IAEV,UAAU;;IAEV,UAAU;;CAEF,CAAC;AAEX,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAgC1E,eAAe;AACf,eAAO,MAAM,IAAI;IACf,cAAc;gBACF,IAAI,KAAG,QAAQ;IAC3B,6BAA6B;kBACf,IAAI,KAAK,QAAQ,KAAG,OAAO;IAMzC;;;OAGG;gBACS,IAAI,QAAQ,UAAU,KAAG,QAAQ;IAuC7C;;;OAGG;uBACgB,IAAI,UAAU,QAAQ,KAAG,QAAQ;CAUrD,CAAC"}
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/geometry/rect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,gCAAgC;AAChC,MAAM,MAAM,IAAI,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,cAAc;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,YAAY;;;;;;;;;;CAUf,CAAC;AAEX,+BAA+B;AAC/B,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE1E,eAAO,MAAM,IAAI;IACf,WAAW;gBACC,IAAI,KAAG,QAAQ;IAC3B,uBAAuB;kBACT,IAAI,KAAK,QAAQ,KAAG,OAAO;IAMzC,sCAAsC;gBAC1B,IAAI,QAAQ,UAAU,KAAG,QAAQ;IAuC7C,qDAAqD;uBAClC,IAAI,UAAU,QAAQ,KAAG,QAAQ;CAUrD,CAAC"}

package/dist/lib/geometry/segment.cjs

@@ -11,9 +11,8 @@ var lineSegmentSample = (from, to, t) => ({
 	tangent: normalize([to[0] - from[0], to[1] - from[1]])
 });
 /**
-* 二次贝塞尔 from → control → to。
-* P(t)  = (1-t)²·P0 + 2(1-t)t·P1 + t²·P2
-* P'(t) = 2(1-t)(P1-P0) + 2t(P2-P1)
+* 二次贝塞尔 from → control → to
+* @description P(t) = (1-t)²P0 + 2(1-t)t·P1 + t²P2；P'(t) = 2(1-t)(P1-P0) + 2t(P2-P1)
 */
 var quadSegmentSample = (from, control, to, t) => {
 	const u = 1 - t;
@@ -23,8 +22,8 @@ var quadSegmentSample = (from, control, to, t) => {
 	};
 };
 /**
-* 三次贝塞尔 from → c1 → c2 → to。
-* P'(t) = 3(1-t)²(P1-P0) + 6(1-t)t(P2-P1) + 3t²(P3-P2)
+* 三次贝塞尔 from → c1 → c2 → to
+* @description P'(t) = 3(1-t)²(P1-P0) + 6(1-t)t(P2-P1) + 3t²(P3-P2)
 */
 var cubicSegmentSample = (from, c1, c2, to, t) => {
 	const u = 1 - t;
@@ -34,18 +33,14 @@ var cubicSegmentSample = (from, c1, c2, to, t) => {
 	};
 };
 /**
-* 折角段 from → corner → to。
-* t∈[0, 0.5] 走第一段（参数 2t）；t∈(0.5, 1] 走第二段（参数 2t-1）。
-* t=0.5 落在 corner，切线取第一段方向（与"靠近 prev 一侧"一致）。
+* 折角段 from → corner → to
+* @description t∈[0,0.5] 走第一段（参数 2t）；t∈(0.5,1] 走第二段（参数 2t-1）；t=0.5 落 corner 切线取第一段方向
 */
 var foldSegmentSample = (from, corner, to, t) => {
 	if (t <= .5) return lineSegmentSample(from, corner, t * 2);
 	return lineSegmentSample(corner, to, t * 2 - 1);
 };
-/**
-* 弧段（与 ir/path arc 同约定，角度单位为度）。
-* 切线沿"扫描方向"——endAngle ≥ startAngle 时为 (-sin, cos)，否则反向。
-*/
+/** 弧段（角度度数，与 ir/path arc 同约定）；切线沿扫描方向：endAngle ≥ start 取 (-sin,cos)，否则反向 */
 var arcSegmentSample = (center, radius, startAngleDeg, endAngleDeg, t) => {
 	const rad = (startAngleDeg + t * (endAngleDeg - startAngleDeg)) * DEG_TO_RAD;
 	const cos = Math.cos(rad);
@@ -56,9 +51,7 @@ var arcSegmentSample = (center, radius, startAngleDeg, endAngleDeg, t) => {
 		tangent: normalize([-sin * sweepSign, cos * sweepSign])
 	};
 };
-/**
-* 整圆——从 0°（east）开始，与 compile/path circlePath 输出方向（右→左→右，sweep=1）一致。
-*/
+/** 整圆，从 0°(east) 开始，与 compile/path circlePath 输出方向（右→左→右，sweep=1）一致 */
 var circleSegmentSample = (center, radius, t) => {
 	const rad = t * 360 * DEG_TO_RAD;
 	const cos = Math.cos(rad);
@@ -68,7 +61,7 @@ var circleSegmentSample = (center, radius, t) => {
 		tangent: normalize([-sin, cos])
 	};
 };
-/** 整椭圆——参数化 (rx·cos(2πt), ry·sin(2πt)) */
+/** 整椭圆，参数化 (rx·cos(2πt), ry·sin(2πt)) */
 var ellipseSegmentSample = (center, rx, ry, t) => {
 	const rad = t * 360 * DEG_TO_RAD;
 	const cos = Math.cos(rad);