@antv/g-math - npm Package Compare versions

Comparing version 3.0.0 to 3.0.1

types/arc.d.ts

+import type { BBox, Point } from './types';
+export declare function box(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number): BBox;
+export declare function nearestPoint(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, x0: number, y0: number): {
+    x: number;
+    y: number;
+};
+export declare function pointDistance(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, x0: number, y0: number): number;
+export declare function pointAt(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, t: number): Point;
+export declare function tangentAngle(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, t: number): number;
+//# sourceMappingURL=arc.d.ts.map

types/arc.d.ts.map

+{"version":3,"file":"arc.d.ts","sourceRoot":"","sources":["../src/arc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAqG3C,wBAAgB,GAAG,CACjB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,IAAI,CAyDN;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM;;;EAuBX;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,UAcX;AAED,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,CAAC,EAAE,MAAM,GACR,KAAK,CAMP;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,CAAC,EAAE,MAAM,UAwBV"}

types/bezier.d.ts

+import type { Point } from './types';
+/**
+ * 使用牛顿切割法求最近的点
+ * @param {number[]} xArr      点的 x 数组
+ * @param {number[]} yArr      点的 y 数组
+ * @param {number}   x         指定的点 x
+ * @param {number}   y         指定的点 y
+ * @param {Function} tCallback 差值函数
+ */
+export declare function nearestPoint(xArr: number[], yArr: number[], x: number, y: number, tCallback: (...arr: number[]) => number, length?: number): Point;
+export declare function snapLength(xArr: number[], yArr: number[]): number;
+//# sourceMappingURL=bezier.d.ts.map

types/bezier.d.ts.map

+{"version":3,"file":"bezier.d.ts","sourceRoot":"","sources":["../src/bezier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,SAAS,CAAC;AAGjD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,MAAM,EAAE,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,KAAK,MAAM,EACvC,MAAM,CAAC,EAAE,MAAM,GACd,KAAK,CA8EP;AAGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,UAWxD"}

types/cubic.d.ts

+import type { Point } from './types';
+export declare function box(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): import("./types").BBox;
+export declare function length(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): number;
+export declare function nearestPoint(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, x0: number, y0: number, length?: number): Point;
+export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, x0: number, y0: number, length?: number): number;
+export declare function pointAt(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): Point;
+export declare function divide(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): [number, number, number, number, number, number, number, number][];
+export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): number;
+//# sourceMappingURL=cubic.d.ts.map

types/cubic.d.ts.map

+{"version":3,"file":"cubic.d.ts","sourceRoot":"","sources":["../src/cubic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAiIrC,wBAAgB,GAAG,CACjB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,0BAaX;AAED,wBAAgB,MAAM,CACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,UAIX;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,SAUhB;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,UAIhB;AAED,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,GACR,KAAK,CAKP;AAED,wBAAgB,MAAM,CACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,sEAGV;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,UAKV"}

types/ellipse.d.ts

+import type { BBox, Point } from './types';
+export declare function box(x: number, y: number, rx: number, ry: number): BBox;
+export declare function length(x: number, y: number, rx: number, ry: number): number;
+export declare function nearestPoint(x: number, y: number, rx: number, ry: number, x0: number, y0: number): {
+    x: number;
+    y: number;
+};
+export declare function pointDistance(x: number, y: number, rx: number, ry: number, x0: number, y0: number): number;
+export declare function pointAt(x: number, y: number, rx: number, ry: number, t: number): Point;
+export declare function tangentAngle(x: number, y: number, rx: number, ry: number, t: number): number;
+//# sourceMappingURL=ellipse.d.ts.map

types/ellipse.d.ts.map

+{"version":3,"file":"ellipse.d.ts","sourceRoot":"","sources":["../src/ellipse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAQ3C,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAOtE;AACD,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAElE;AACD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM;;;EAkDX;AACD,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,UAIX;AACD,wBAAgB,OAAO,CACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,GACR,KAAK,CAMP;AACD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,UAaV"}

types/index.d.ts

+import { box as arcBox, nearestPoint as arcNearestPoint, tangentAngle as arcTangentAngle } from './arc';
+import { box as cubicBox, length as cubicLength, nearestPoint as cubicNearestPoint, pointAt as cubicPointAt, pointDistance as cubicPointDistance, tangentAngle as cubicTangentAngle } from './cubic';
+import { box as lineBox, length as lineLength, pointAt as linePointAt, pointDistance as linePointDistance, pointToLine as linePointToLine, tangentAngle as lineTangentAngle } from './line';
+import { box as polygonBox, length as polygonLength, pointAt as polygonPointAt, pointDistance as polygonPointDistance, tangentAngle as polygonTangentAngle } from './polygon';
+import { box as polylineBox, length as polylineLength, pointAt as polylinePointAt, pointDistance as polylinePointDistance, tangentAngle as polylineTangentAngle } from './polyline';
+import { box as quadBox, length as quadLength, nearestPoint as quadNearestPoint, pointDistance as quadPointDistance } from './quadratic';
+import { distance } from './util';
+export { distance, quadBox, quadLength, quadPointDistance, quadNearestPoint, cubicBox, cubicLength, cubicNearestPoint, cubicPointDistance, cubicPointAt, cubicTangentAngle, polygonBox, polygonLength, polygonPointDistance, polygonPointAt, polygonTangentAngle, polylineBox, polylineLength, polylinePointDistance, polylinePointAt, polylineTangentAngle, lineBox, lineLength, linePointDistance, linePointAt, linePointToLine, lineTangentAngle, arcBox, arcTangentAngle, arcNearestPoint, };
+//# sourceMappingURL=index.d.ts.map

types/index.d.ts.map

+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,IAAI,MAAM,EACb,YAAY,IAAI,eAAe,EAC/B,YAAY,IAAI,eAAe,EAChC,MAAM,OAAO,CAAC;AACf,OAAO,EACL,GAAG,IAAI,QAAQ,EACf,MAAM,IAAI,WAAW,EACrB,YAAY,IAAI,iBAAiB,EACjC,OAAO,IAAI,YAAY,EACvB,aAAa,IAAI,kBAAkB,EACnC,YAAY,IAAI,iBAAiB,EAClC,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,GAAG,IAAI,OAAO,EACd,MAAM,IAAI,UAAU,EACpB,OAAO,IAAI,WAAW,EACtB,aAAa,IAAI,iBAAiB,EAClC,WAAW,IAAI,eAAe,EAC9B,YAAY,IAAI,gBAAgB,EACjC,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,GAAG,IAAI,UAAU,EACjB,MAAM,IAAI,aAAa,EACvB,OAAO,IAAI,cAAc,EACzB,aAAa,IAAI,oBAAoB,EACrC,YAAY,IAAI,mBAAmB,EACpC,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,GAAG,IAAI,WAAW,EAClB,MAAM,IAAI,cAAc,EACxB,OAAO,IAAI,eAAe,EAC1B,aAAa,IAAI,qBAAqB,EACtC,YAAY,IAAI,oBAAoB,EACrC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,GAAG,IAAI,OAAO,EACd,MAAM,IAAI,UAAU,EACpB,YAAY,IAAI,gBAAgB,EAChC,aAAa,IAAI,iBAAiB,EACnC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,OAAO,EACL,QAAQ,EACR,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAChB,QAAQ,EACR,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,MAAM,EACN,eAAe,EACf,eAAe,GAChB,CAAC"}

types/line.d.ts

+import type { BBox, Point } from './types';
+export declare function box(x1: number, y1: number, x2: number, y2: number): BBox;
+export declare function length(x1: number, y1: number, x2: number, y2: number): number;
+export declare function pointAt(x1: number, y1: number, x2: number, y2: number, t: number): Point;
+export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x: number, y: number): number;
+export declare function pointToLine(x1: number, y1: number, x2: number, y2: number, x: number, y: number): number;
+export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number): number;
+//# sourceMappingURL=line.d.ts.map

types/line.d.ts.map

+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../src/line.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAG3C,wBAAgB,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAExE;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAEpE;AAED,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,GACR,KAAK,CAKP;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAYR;AAED,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,UAWV;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAE1E"}

types/polygon.d.ts

+import type { PointTuple } from './types';
+export declare function box(points: PointTuple[]): import("./types").BBox;
+export declare function length(points: PointTuple[]): number;
+export declare function pointAt(points: PointTuple[], t: number): import("./types").Point;
+export declare function pointDistance(points: PointTuple[], x: number, y: number): number;
+export declare function tangentAngle(points: PointTuple[], t: number): number;
+//# sourceMappingURL=polygon.d.ts.map

types/polygon.d.ts.map

+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../src/polygon.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAU1C,wBAAgB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,0BAEvC;AACD,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,UAE1C;AACD,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,2BAEtD;AACD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAEvE;AACD,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,UAE3D"}

types/polyline.d.ts

+import type { BBox, PointTuple } from './types';
+export declare function box(points: PointTuple[]): BBox;
+export declare function length(points: PointTuple[]): number;
+export declare function pointAt(points: PointTuple[], t: number): import("./types").Point;
+export declare function pointDistance(points: PointTuple[], x: number, y: number): number;
+export declare function tangentAngle(points: PointTuple[], t: number): number;
+//# sourceMappingURL=polyline.d.ts.map

types/polyline.d.ts.map

+{"version":3,"file":"polyline.d.ts","sourceRoot":"","sources":["../src/polyline.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGhD,wBAAgB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAS9C;AACD,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,UAE1C;AACD,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,2BAEtD;AACD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAEvE;AACD,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,UAE3D"}

types/quadratic.d.ts

+import type { Point } from './types';
+export declare function box(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): import("./types").BBox;
+export declare function length(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number;
+export declare function nearestPoint(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0: number, y0: number): Point;
+export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0: number, y0: number): number;
+export declare function pointAt(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): Point;
+export declare function divide(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): number[][];
+export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): number;
+//# sourceMappingURL=quadratic.d.ts.map

types/quadratic.d.ts.map

+{"version":3,"file":"quadratic.d.ts","sourceRoot":"","sources":["../src/quadratic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AA4FrC,wBAAgB,GAAG,CACjB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,0BAcX;AAED,wBAAgB,MAAM,CACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,UAGX;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,SAGX;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,UAIX;AAGD,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,GACR,KAAK,CAKP;AAED,wBAAgB,MAAM,CACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,cAGV;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,UAMV"}

types/segments.d.ts

+import type { Point, PointTuple } from './types';
+export declare function lengthOfSegment(points: PointTuple[]): number;
+/**
+ * 按照比例在数据片段中获取点
+ * @param {array} points 点的集合
+ * @param {number} t 百分比 0-1
+ * @return {object} 点的坐标
+ */
+export declare function pointAtSegments(points: PointTuple[], t: number): Point | null;
+/**
+ * 按照比例在数据片段中获取切线的角度
+ * @param {array} points 点的集合
+ * @param {number} t 百分比 0-1
+ */
+export declare function angleAtSegments(points: PointTuple[], t: number): number;
+export declare function distanceAtSegment(points: PointTuple[], x: number, y: number): number;
+//# sourceMappingURL=segments.d.ts.map

types/segments.d.ts.map

+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../src/segments.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAW,MAAM,SAAS,CAAC;AAsB1D,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,UAWnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CA4B7E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,UAoB9D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAkB3E"}

types/types.d.ts

+/**
+ * 点（元组表示）
+ */
+export type PointTuple = [number, number];
+/**
+ * 点（对象表示）
+ */
+export type Point = {
+    x: number;
+    y: number;
+};
+/**
+ * 包围盒
+ */
+export type BBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * 一条线段
+ */
+export type Segment = {
+    from: PointTuple;
+    to: PointTuple;
+    length: number;
+};
+//# sourceMappingURL=types.d.ts.map

types/types.d.ts.map

+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

types/util.d.ts

+import type { BBox } from './types';
+export declare function distance(x1: number, y1: number, x2: number, y2: number): number;
+export declare function getBBoxByArray(xArr: number[], yArr: number[]): BBox;
+export declare function getBBoxRange(x1: number, y1: number, x2: number, y2: number): {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+export declare function piMod(angle: number): number;
+//# sourceMappingURL=util.d.ts.map

types/util.d.ts.map

+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAItE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAWnE;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;;;;;EAO1E;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,UAElC"}

dist/index.esm.js

@@ -1,2 +0,11 @@
-import { __spreadArray, __read } from 'tslib';
+/*!
+ * @antv/g-math
+ * @description Geometry util
+ * @version 3.0.1
+ * @date 5/9/2025, 8:18:51 AM
+ * @author AntVis
+ * @docs https://g.antv.antgroup.com/
+ */
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { isNumberEqual } from '@antv/util';
@@ -6,69 +15,68 @@ import { vec2 } from 'gl-matrix';
 function distance(x1, y1, x2, y2) {
-    var dx = x1 - x2;
-    var dy = y1 - y2;
-    return Math.sqrt(dx * dx + dy * dy);
+  var dx = x1 - x2;
+  var dy = y1 - y2;
+  return Math.sqrt(dx * dx + dy * dy);
 }
 function getBBoxByArray(xArr, yArr) {
-    var minX = Math.min.apply(Math, __spreadArray([], __read(xArr), false));
-    var minY = Math.min.apply(Math, __spreadArray([], __read(yArr), false));
-    var maxX = Math.max.apply(Math, __spreadArray([], __read(xArr), false));
-    var maxY = Math.max.apply(Math, __spreadArray([], __read(yArr), false));
-    return {
-        x: minX,
-        y: minY,
-        width: maxX - minX,
-        height: maxY - minY,
-    };
+  var minX = Math.min.apply(Math, _toConsumableArray(xArr));
+  var minY = Math.min.apply(Math, _toConsumableArray(yArr));
+  var maxX = Math.max.apply(Math, _toConsumableArray(xArr));
+  var maxY = Math.max.apply(Math, _toConsumableArray(yArr));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
 }
 function piMod(angle) {
-    return (angle + Math.PI * 2) % (Math.PI * 2);
+  return (angle + Math.PI * 2) % (Math.PI * 2);
 }
 
 function copysign(v1, v2) {
-    var absv = Math.abs(v1);
-    return v2 > 0 ? absv : absv * -1;
+  var absv = Math.abs(v1);
+  return v2 > 0 ? absv : absv * -1;
 }
 function nearestPoint$4(x, y, rx, ry, x0, y0) {
-    var a = rx;
-    var b = ry;
-    // 假如椭圆半径为0则返回圆心
-    if (a === 0 || b === 0) {
-        return {
-            x: x,
-            y: y,
-        };
-    }
-    // 转换成 0， 0 为中心的椭圆计算
-    var relativeX = x0 - x;
-    var relativeY = y0 - y;
-    var px = Math.abs(relativeX);
-    var py = Math.abs(relativeY);
-    var squareA = a * a;
-    var squareB = b * b;
-    // const angle0 = Math.atan2(relativeY, relativeX);
-    var t = Math.PI / 4;
-    var nearestX = 0; // 椭圆上的任一点
-    var nearestY = 0;
-    // 迭代 4 次
-    for (var i = 0; i < 4; i++) {
-        nearestX = a * Math.cos(t);
-        nearestY = b * Math.sin(t);
-        var ex = ((squareA - squareB) * Math.pow(Math.cos(t), 3)) / a;
-        var ey = ((squareB - squareA) * Math.pow(Math.sin(t), 3)) / b;
-        var rx1 = nearestX - ex;
-        var ry1 = nearestY - ey;
-        var qx = px - ex;
-        var qy = py - ey;
-        var r = Math.hypot(ry1, rx1);
-        var q = Math.hypot(qy, qx);
-        var delta_c = r * Math.asin((rx1 * qy - ry1 * qx) / (r * q));
-        var delta_t = delta_c /
-            Math.sqrt(squareA + squareB - nearestX * nearestX - nearestY * nearestY);
-        t += delta_t;
-        t = Math.min(Math.PI / 2, Math.max(0, t));
-    }
+  var a = rx;
+  var b = ry;
+  // 假如椭圆半径为0则返回圆心
+  if (a === 0 || b === 0) {
     return {
-        x: x + copysign(nearestX, relativeX),
-        y: y + copysign(nearestY, relativeY),
+      x: x,
+      y: y
     };
+  }
+  // 转换成 0， 0 为中心的椭圆计算
+  var relativeX = x0 - x;
+  var relativeY = y0 - y;
+  var px = Math.abs(relativeX);
+  var py = Math.abs(relativeY);
+  var squareA = a * a;
+  var squareB = b * b;
+  // const angle0 = Math.atan2(relativeY, relativeX);
+  var t = Math.PI / 4;
+  var nearestX = 0; // 椭圆上的任一点
+  var nearestY = 0;
+  // 迭代 4 次
+  for (var i = 0; i < 4; i++) {
+    nearestX = a * Math.cos(t);
+    nearestY = b * Math.sin(t);
+    var ex = (squareA - squareB) * Math.pow(Math.cos(t), 3) / a;
+    var ey = (squareB - squareA) * Math.pow(Math.sin(t), 3) / b;
+    var rx1 = nearestX - ex;
+    var ry1 = nearestY - ey;
+    var qx = px - ex;
+    var qy = py - ey;
+    var r = Math.hypot(ry1, rx1);
+    var q = Math.hypot(qy, qx);
+    var delta_c = r * Math.asin((rx1 * qy - ry1 * qx) / (r * q));
+    var delta_t = delta_c / Math.sqrt(squareA + squareB - nearestX * nearestX - nearestY * nearestY);
+    t += delta_t;
+    t = Math.min(Math.PI / 2, Math.max(0, t));
+  }
+  return {
+    x: x + copysign(nearestX, relativeX),
+    y: y + copysign(nearestY, relativeY)
+  };
 }
@@ -78,138 +86,135 @@
 function derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle) {
-    return (-1 * rx * Math.cos(xRotation) * Math.sin(angle) -
-        ry * Math.sin(xRotation) * Math.cos(angle));
+  return -1 * rx * Math.cos(xRotation) * Math.sin(angle) - ry * Math.sin(xRotation) * Math.cos(angle);
 }
+
 // 偏导数 y
 function derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle) {
-    return (-1 * rx * Math.sin(xRotation) * Math.sin(angle) +
-        ry * Math.cos(xRotation) * Math.cos(angle));
+  return -1 * rx * Math.sin(xRotation) * Math.sin(angle) + ry * Math.cos(xRotation) * Math.cos(angle);
 }
+
 // x 的极值
 function xExtrema(rx, ry, xRotation) {
-    return Math.atan((-ry / rx) * Math.tan(xRotation));
+  return Math.atan(-ry / rx * Math.tan(xRotation));
 }
+
 // y 的极值
 function yExtrema(rx, ry, xRotation) {
-    return Math.atan(ry / (rx * Math.tan(xRotation)));
+  return Math.atan(ry / (rx * Math.tan(xRotation)));
 }
+
 // 根据角度求 x 坐标
 function xAt(cx, cy, rx, ry, xRotation, angle) {
-    return (rx * Math.cos(xRotation) * Math.cos(angle) -
-        ry * Math.sin(xRotation) * Math.sin(angle) +
-        cx);
+  return rx * Math.cos(xRotation) * Math.cos(angle) - ry * Math.sin(xRotation) * Math.sin(angle) + cx;
 }
+
 // 根据角度求 y 坐标
 function yAt(cx, cy, rx, ry, xRotation, angle) {
-    return (rx * Math.sin(xRotation) * Math.cos(angle) +
-        ry * Math.cos(xRotation) * Math.sin(angle) +
-        cy);
+  return rx * Math.sin(xRotation) * Math.cos(angle) + ry * Math.cos(xRotation) * Math.sin(angle) + cy;
 }
+
 // 获取点在椭圆上的角度
 function getAngle(rx, ry, x0, y0) {
-    var angle = Math.atan2(y0 * rx, x0 * ry);
-    // 转换到 0 - 2PI 内
-    return (angle + Math.PI * 2) % (Math.PI * 2);
+  var angle = Math.atan2(y0 * rx, x0 * ry);
+  // 转换到 0 - 2PI 内
+  return (angle + Math.PI * 2) % (Math.PI * 2);
 }
+
 // 根据角度获取，x,y
 function getPoint(rx, ry, angle) {
-    return {
-        x: rx * Math.cos(angle),
-        y: ry * Math.sin(angle),
-    };
+  return {
+    x: rx * Math.cos(angle),
+    y: ry * Math.sin(angle)
+  };
 }
+
 // 旋转
 function rotate(x, y, angle) {
-    var cos = Math.cos(angle);
-    var sin = Math.sin(angle);
-    return [x * cos - y * sin, x * sin + y * cos];
+  var cos = Math.cos(angle);
+  var sin = Math.sin(angle);
+  return [x * cos - y * sin, x * sin + y * cos];
 }
 function box$5(cx, cy, rx, ry, xRotation, startAngle, endAngle) {
-    var xDim = xExtrema(rx, ry, xRotation);
-    var minX = Infinity;
-    var maxX = -Infinity;
-    var xs = [startAngle, endAngle];
-    for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
-        var xAngle = xDim + i;
-        if (startAngle < endAngle) {
-            if (startAngle < xAngle && xAngle < endAngle) {
-                xs.push(xAngle);
-            }
-        }
-        else {
-            if (endAngle < xAngle && xAngle < startAngle) {
-                xs.push(xAngle);
-            }
-        }
+  var xDim = xExtrema(rx, ry, xRotation);
+  var minX = Infinity;
+  var maxX = -Infinity;
+  var xs = [startAngle, endAngle];
+  for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
+    var xAngle = xDim + i;
+    if (startAngle < endAngle) {
+      if (startAngle < xAngle && xAngle < endAngle) {
+        xs.push(xAngle);
+      }
+    } else if (endAngle < xAngle && xAngle < startAngle) {
+      xs.push(xAngle);
     }
-    for (var i = 0; i < xs.length; i++) {
-        var x = xAt(cx, cy, rx, ry, xRotation, xs[i]);
-        if (x < minX) {
-            minX = x;
-        }
-        if (x > maxX) {
-            maxX = x;
-        }
+  }
+  for (var _i = 0; _i < xs.length; _i++) {
+    var x = xAt(cx, cy, rx, ry, xRotation, xs[_i]);
+    if (x < minX) {
+      minX = x;
     }
-    var yDim = yExtrema(rx, ry, xRotation);
-    var minY = Infinity;
-    var maxY = -Infinity;
-    var ys = [startAngle, endAngle];
-    for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
-        var yAngle = yDim + i;
-        if (startAngle < endAngle) {
-            if (startAngle < yAngle && yAngle < endAngle) {
-                ys.push(yAngle);
-            }
-        }
-        else {
-            if (endAngle < yAngle && yAngle < startAngle) {
-                ys.push(yAngle);
-            }
-        }
+    if (x > maxX) {
+      maxX = x;
     }
-    for (var i = 0; i < ys.length; i++) {
-        var y = yAt(cx, cy, rx, ry, xRotation, ys[i]);
-        if (y < minY) {
-            minY = y;
-        }
-        if (y > maxY) {
-            maxY = y;
-        }
+  }
+  var yDim = yExtrema(rx, ry, xRotation);
+  var minY = Infinity;
+  var maxY = -Infinity;
+  var ys = [startAngle, endAngle];
+  for (var _i2 = -Math.PI * 2; _i2 <= Math.PI * 2; _i2 += Math.PI) {
+    var yAngle = yDim + _i2;
+    if (startAngle < endAngle) {
+      if (startAngle < yAngle && yAngle < endAngle) {
+        ys.push(yAngle);
+      }
+    } else if (endAngle < yAngle && yAngle < startAngle) {
+      ys.push(yAngle);
     }
-    return {
-        x: minX,
-        y: minY,
-        width: maxX - minX,
-        height: maxY - minY,
-    };
-}
-function nearestPoint$3(cx, cy, rx, ry, xRotation, startAngle, endAngle, x0, y0) {
-    // 将最近距离问题转换成到椭圆中心 0,0 没有旋转的椭圆问题
-    var relativeVector = rotate(x0 - cx, y0 - cy, -xRotation);
-    var _a = __read(relativeVector, 2), x1 = _a[0], y1 = _a[1];
-    // 计算点到椭圆的最近的点
-    var relativePoint = nearestPoint$4(0, 0, rx, ry, x1, y1);
-    // 获取点在椭圆上的角度
-    var angle = getAngle(rx, ry, relativePoint.x, relativePoint.y);
-    // 点没有在圆弧上
-    if (angle < startAngle) {
-        // 小于起始圆弧
-        relativePoint = getPoint(rx, ry, startAngle);
+  }
+  for (var _i3 = 0; _i3 < ys.length; _i3++) {
+    var y = yAt(cx, cy, rx, ry, xRotation, ys[_i3]);
+    if (y < minY) {
+      minY = y;
     }
-    else if (angle > endAngle) {
-        // 大于结束圆弧
-        relativePoint = getPoint(rx, ry, endAngle);
+    if (y > maxY) {
+      maxY = y;
     }
-    // 旋转到 xRotation 的角度
-    var vector = rotate(relativePoint.x, relativePoint.y, xRotation);
-    return {
-        x: vector[0] + cx,
-        y: vector[1] + cy,
-    };
+  }
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
 }
+function nearestPoint$3(cx, cy, rx, ry, xRotation, startAngle, endAngle, x0, y0) {
+  // 将最近距离问题转换成到椭圆中心 0,0 没有旋转的椭圆问题
+  var relativeVector = rotate(x0 - cx, y0 - cy, -xRotation);
+  var _relativeVector = _slicedToArray(relativeVector, 2),
+    x1 = _relativeVector[0],
+    y1 = _relativeVector[1];
+  // 计算点到椭圆的最近的点
+  var relativePoint = nearestPoint$4(0, 0, rx, ry, x1, y1);
+  // 获取点在椭圆上的角度
+  var angle = getAngle(rx, ry, relativePoint.x, relativePoint.y);
+  // 点没有在圆弧上
+  if (angle < startAngle) {
+    // 小于起始圆弧
+    relativePoint = getPoint(rx, ry, startAngle);
+  } else if (angle > endAngle) {
+    // 大于结束圆弧
+    relativePoint = getPoint(rx, ry, endAngle);
+  }
+  // 旋转到 xRotation 的角度
+  var vector = rotate(relativePoint.x, relativePoint.y, xRotation);
+  return {
+    x: vector[0] + cx,
+    y: vector[1] + cy
+  };
+}
 function tangentAngle$4(cx, cy, rx, ry, xRotation, startAngle, endAngle, t) {
-    var angle = (endAngle - startAngle) * t + startAngle;
-    var dx = derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
-    var dy = derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
-    return piMod(Math.atan2(dy, dx));
+  var angle = (endAngle - startAngle) * t + startAngle;
+  var dx = derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
+  var dy = derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
+  return piMod(Math.atan2(dy, dx));
 }
@@ -227,265 +232,253 @@
 function nearestPoint$2(xArr, yArr, x, y, tCallback, length) {
-    var t = -1;
-    var d = Infinity;
-    var v0 = [x, y];
-    var segNum = 20;
-    if (length && length > 200) {
-        segNum = length / 10;
+  var t = -1;
+  var d = Infinity;
+  var v0 = [x, y];
+  var segNum = 20;
+  if (length && length > 200) {
+    segNum = length / 10;
+  }
+  var increaseRate = 1 / segNum;
+  var interval = increaseRate / 10;
+  for (var i = 0; i <= segNum; i++) {
+    var _t = i * increaseRate;
+    var v1 = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([_t]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([_t])))];
+    var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
+    if (d1 < d) {
+      t = _t;
+      d = d1;
     }
-    var increaseRate = 1 / segNum;
-    var interval = increaseRate / 10;
-    for (var i = 0; i <= segNum; i++) {
-        var _t = i * increaseRate;
-        var v1 = [
-            tCallback.apply(void 0, __spreadArray([], __read(xArr.concat([_t])), false)),
-            tCallback.apply(void 0, __spreadArray([], __read(yArr.concat([_t])), false)),
-        ];
-        var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
-        if (d1 < d) {
-            t = _t;
-            d = d1;
-        }
+  }
+  // 提前终止
+  if (t === 0) {
+    return {
+      x: xArr[0],
+      y: yArr[0]
+    };
+  }
+  if (t === 1) {
+    var count = xArr.length;
+    return {
+      x: xArr[count - 1],
+      y: yArr[count - 1]
+    };
+  }
+  d = Infinity;
+  for (var _i = 0; _i < 32; _i++) {
+    if (interval < EPSILON) {
+      break;
     }
-    // 提前终止
-    if (t === 0) {
-        return {
-            x: xArr[0],
-            y: yArr[0],
-        };
+    var prev = t - interval;
+    var next = t + interval;
+    var _v = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([prev]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([prev])))];
+    var _d = distance(v0[0], v0[1], _v[0], _v[1]);
+    if (prev >= 0 && _d < d) {
+      t = prev;
+      d = _d;
+    } else {
+      var v2 = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([next]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([next])))];
+      var d2 = distance(v0[0], v0[1], v2[0], v2[1]);
+      if (next <= 1 && d2 < d) {
+        t = next;
+        d = d2;
+      } else {
+        interval *= 0.5;
+      }
     }
-    if (t === 1) {
-        var count = xArr.length;
-        return {
-            x: xArr[count - 1],
-            y: yArr[count - 1],
-        };
-    }
-    d = Infinity;
-    for (var i = 0; i < 32; i++) {
-        if (interval < EPSILON) {
-            break;
-        }
-        var prev = t - interval;
-        var next = t + interval;
-        var v1 = [
-            tCallback.apply(void 0, __spreadArray([], __read(xArr.concat([prev])), false)),
-            tCallback.apply(void 0, __spreadArray([], __read(yArr.concat([prev])), false)),
-        ];
-        var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
-        if (prev >= 0 && d1 < d) {
-            t = prev;
-            d = d1;
-        }
-        else {
-            var v2 = [
-                tCallback.apply(void 0, __spreadArray([], __read(xArr.concat([next])), false)),
-                tCallback.apply(void 0, __spreadArray([], __read(yArr.concat([next])), false)),
-            ];
-            var d2 = distance(v0[0], v0[1], v2[0], v2[1]);
-            if (next <= 1 && d2 < d) {
-                t = next;
-                d = d2;
-            }
-            else {
-                interval *= 0.5;
-            }
-        }
-    }
-    return {
-        x: tCallback.apply(void 0, __spreadArray([], __read(xArr.concat([t])), false)),
-        y: tCallback.apply(void 0, __spreadArray([], __read(yArr.concat([t])), false)),
-    };
+  }
+  return {
+    x: tCallback.apply(void 0, _toConsumableArray(xArr.concat([t]))),
+    y: tCallback.apply(void 0, _toConsumableArray(yArr.concat([t])))
+  };
 }
+
 // 近似求解 https://community.khronos.org/t/3d-cubic-bezier-segment-length/62363/2
 function snapLength(xArr, yArr) {
-    var totalLength = 0;
-    var count = xArr.length;
-    for (var i = 0; i < count; i++) {
-        var x = xArr[i];
-        var y = yArr[i];
-        var nextX = xArr[(i + 1) % count];
-        var nextY = yArr[(i + 1) % count];
-        totalLength += distance(x, y, nextX, nextY);
-    }
-    return totalLength / 2;
+  var totalLength = 0;
+  var count = xArr.length;
+  for (var i = 0; i < count; i++) {
+    var x = xArr[i];
+    var y = yArr[i];
+    var nextX = xArr[(i + 1) % count];
+    var nextY = yArr[(i + 1) % count];
+    totalLength += distance(x, y, nextX, nextY);
+  }
+  return totalLength / 2;
 }
 
 function box$4(x1, y1, x2, y2) {
-    return getBBoxByArray([x1, x2], [y1, y2]);
+  return getBBoxByArray([x1, x2], [y1, y2]);
 }
 function length$4(x1, y1, x2, y2) {
-    return distance(x1, y1, x2, y2);
+  return distance(x1, y1, x2, y2);
 }
 function pointAt$3(x1, y1, x2, y2, t) {
-    return {
-        x: (1 - t) * x1 + t * x2,
-        y: (1 - t) * y1 + t * y2,
-    };
+  return {
+    x: (1 - t) * x1 + t * x2,
+    y: (1 - t) * y1 + t * y2
+  };
 }
 function pointDistance$4(x1, y1, x2, y2, x, y) {
-    // 投影距离 x1, y1 的向量，假设 p, p1, p2 三个点，投影点为 a
-    // p1a = p1p.p1p2/|p1p2| * (p1p 的单位向量)
-    var cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
-    if (cross < 0) {
-        return distance(x1, y1, x, y);
-    }
-    var lengthSquare = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
-    if (cross > lengthSquare) {
-        return distance(x2, y2, x, y);
-    }
-    return pointToLine(x1, y1, x2, y2, x, y);
+  // 投影距离 x1, y1 的向量，假设 p, p1, p2 三个点，投影点为 a
+  // p1a = p1p.p1p2/|p1p2| * (p1p 的单位向量)
+  var cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
+  if (cross < 0) {
+    return distance(x1, y1, x, y);
+  }
+  var lengthSquare = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+  if (cross > lengthSquare) {
+    return distance(x2, y2, x, y);
+  }
+  return pointToLine(x1, y1, x2, y2, x, y);
 }
 function pointToLine(x1, y1, x2, y2, x, y) {
-    var d = [x2 - x1, y2 - y1];
-    // 如果端点相等，则判定点到点的距离
-    if (vec2.exactEquals(d, [0, 0])) {
-        return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
-    }
-    var u = [-d[1], d[0]];
-    vec2.normalize(u, u);
-    var a = [x - x1, y - y1];
-    return Math.abs(vec2.dot(a, u));
+  var d = [x2 - x1, y2 - y1];
+  // 如果端点相等，则判定点到点的距离
+  if (vec2.exactEquals(d, [0, 0])) {
+    return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
+  }
+  var u = [-d[1], d[0]];
+  vec2.normalize(u, u);
+  var a = [x - x1, y - y1];
+  return Math.abs(vec2.dot(a, u));
 }
 function tangentAngle$3(x1, y1, x2, y2) {
-    return Math.atan2(y2 - y1, x2 - x1);
+  return Math.atan2(y2 - y1, x2 - x1);
 }
 
 function cubicAt(p0, p1, p2, p3, t) {
-    var onet = 1 - t; // t * t * t 的性能大概是 Math.pow(t, 3) 的三倍
-    return (onet * onet * onet * p0 +
-        3 * p1 * t * onet * onet +
-        3 * p2 * t * t * onet +
-        p3 * t * t * t);
+  var onet = 1 - t; // t * t * t 的性能大概是 Math.pow(t, 3) 的三倍
+  return onet * onet * onet * p0 + 3 * p1 * t * onet * onet + 3 * p2 * t * t * onet + p3 * t * t * t;
 }
 function derivativeAt(p0, p1, p2, p3, t) {
-    var onet = 1 - t;
-    return (3 * (onet * onet * (p1 - p0) + 2 * onet * t * (p2 - p1) + t * t * (p3 - p2)));
+  var onet = 1 - t;
+  return 3 * (onet * onet * (p1 - p0) + 2 * onet * t * (p2 - p1) + t * t * (p3 - p2));
 }
 function extrema$1(p0, p1, p2, p3) {
-    var a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
-    var b = 6 * p0 - 12 * p1 + 6 * p2;
-    var c = 3 * p1 - 3 * p0;
-    var extremas = [];
-    var t1;
-    var t2;
-    var discSqrt;
-    if (isNumberEqual(a, 0)) {
-        if (!isNumberEqual(b, 0)) {
-            t1 = -c / b;
-            if (t1 >= 0 && t1 <= 1) {
-                extremas.push(t1);
-            }
-        }
+  var a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
+  var b = 6 * p0 - 12 * p1 + 6 * p2;
+  var c = 3 * p1 - 3 * p0;
+  var extremas = [];
+  var t1;
+  var t2;
+  var discSqrt;
+  if (isNumberEqual(a, 0)) {
+    if (!isNumberEqual(b, 0)) {
+      t1 = -c / b;
+      if (t1 >= 0 && t1 <= 1) {
+        extremas.push(t1);
+      }
     }
-    else {
-        var disc = b * b - 4 * a * c;
-        if (isNumberEqual(disc, 0)) {
-            extremas.push(-b / (2 * a));
-        }
-        else if (disc > 0) {
-            discSqrt = Math.sqrt(disc);
-            t1 = (-b + discSqrt) / (2 * a);
-            t2 = (-b - discSqrt) / (2 * a);
-            if (t1 >= 0 && t1 <= 1) {
-                extremas.push(t1);
-            }
-            if (t2 >= 0 && t2 <= 1) {
-                extremas.push(t2);
-            }
-        }
+  } else {
+    var disc = b * b - 4 * a * c;
+    if (isNumberEqual(disc, 0)) {
+      extremas.push(-b / (2 * a));
+    } else if (disc > 0) {
+      discSqrt = Math.sqrt(disc);
+      t1 = (-b + discSqrt) / (2 * a);
+      t2 = (-b - discSqrt) / (2 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        extremas.push(t1);
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        extremas.push(t2);
+      }
     }
-    return extremas;
+  }
+  return extremas;
 }
+
 // 分割贝塞尔曲线
 function divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    // 划分点
-    var xt = cubicAt(x1, x2, x3, x4, t);
-    var yt = cubicAt(y1, y2, y3, y4, t);
-    // 计算两点之间的差值点
-    var c1 = pointAt$3(x1, y1, x2, y2, t);
-    var c2 = pointAt$3(x2, y2, x3, y3, t);
-    var c3 = pointAt$3(x3, y3, x4, y4, t);
-    var c12 = pointAt$3(c1.x, c1.y, c2.x, c2.y, t);
-    var c23 = pointAt$3(c2.x, c2.y, c3.x, c3.y, t);
-    return [
-        [x1, y1, c1.x, c1.y, c12.x, c12.y, xt, yt],
-        [xt, yt, c23.x, c23.y, c3.x, c3.y, x4, y4],
-    ];
+  // 划分点
+  var xt = cubicAt(x1, x2, x3, x4, t);
+  var yt = cubicAt(y1, y2, y3, y4, t);
+  // 计算两点之间的差值点
+  var c1 = pointAt$3(x1, y1, x2, y2, t);
+  var c2 = pointAt$3(x2, y2, x3, y3, t);
+  var c3 = pointAt$3(x3, y3, x4, y4, t);
+  var c12 = pointAt$3(c1.x, c1.y, c2.x, c2.y, t);
+  var c23 = pointAt$3(c2.x, c2.y, c3.x, c3.y, t);
+  return [[x1, y1, c1.x, c1.y, c12.x, c12.y, xt, yt], [xt, yt, c23.x, c23.y, c3.x, c3.y, x4, y4]];
 }
+
 // 使用迭代法取贝塞尔曲线的长度，二阶和三阶分开写，更清晰和便于调试
 function cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, iterationCount) {
-    if (iterationCount === 0) {
-        return snapLength([x1, x2, x3, x4], [y1, y2, y3, y4]);
-    }
-    var cubics = divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0.5);
-    var left = __spreadArray(__spreadArray([], __read(cubics[0]), false), [iterationCount - 1], false);
-    var right = __spreadArray(__spreadArray([], __read(cubics[1]), false), [iterationCount - 1], false);
-    return cubicLength.apply(void 0, __spreadArray([], __read(left), false)) + cubicLength.apply(void 0, __spreadArray([], __read(right), false));
+  if (iterationCount === 0) {
+    return snapLength([x1, x2, x3, x4], [y1, y2, y3, y4]);
+  }
+  var cubics = divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0.5);
+  var left = [].concat(_toConsumableArray(cubics[0]), [iterationCount - 1]);
+  var right = [].concat(_toConsumableArray(cubics[1]), [iterationCount - 1]);
+  return cubicLength.apply(void 0, _toConsumableArray(left)) + cubicLength.apply(void 0, _toConsumableArray(right));
 }
 function box$3(x1, y1, x2, y2, x3, y3, x4, y4) {
-    var xArr = [x1, x4];
-    var yArr = [y1, y4];
-    var xExtrema = extrema$1(x1, x2, x3, x4);
-    var yExtrema = extrema$1(y1, y2, y3, y4);
-    for (var i = 0; i < xExtrema.length; i++) {
-        xArr.push(cubicAt(x1, x2, x3, x4, xExtrema[i]));
-    }
-    for (var i = 0; i < yExtrema.length; i++) {
-        yArr.push(cubicAt(y1, y2, y3, y4, yExtrema[i]));
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xArr = [x1, x4];
+  var yArr = [y1, y4];
+  var xExtrema = extrema$1(x1, x2, x3, x4);
+  var yExtrema = extrema$1(y1, y2, y3, y4);
+  for (var i = 0; i < xExtrema.length; i++) {
+    xArr.push(cubicAt(x1, x2, x3, x4, xExtrema[i]));
+  }
+  for (var _i = 0; _i < yExtrema.length; _i++) {
+    yArr.push(cubicAt(y1, y2, y3, y4, yExtrema[_i]));
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length$3(x1, y1, x2, y2, x3, y3, x4, y4) {
-    // 迭代三次，划分成 8 段求长度
-    return cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, 3);
+  // 迭代三次，划分成 8 段求长度
+  return cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, 3);
 }
 function nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length) {
-    return nearestPoint$2([x1, x2, x3, x4], [y1, y2, y3, y4], x0, y0, cubicAt, length);
+  return nearestPoint$2([x1, x2, x3, x4], [y1, y2, y3, y4], x0, y0, cubicAt, length);
 }
 function pointDistance$3(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length) {
-    var point = nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length);
-    return distance(point.x, point.y, x0, y0);
+  var point = nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length);
+  return distance(point.x, point.y, x0, y0);
 }
 function pointAt$2(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    return {
-        x: cubicAt(x1, x2, x3, x4, t),
-        y: cubicAt(y1, y2, y3, y4, t),
-    };
+  return {
+    x: cubicAt(x1, x2, x3, x4, t),
+    y: cubicAt(y1, y2, y3, y4, t)
+  };
 }
 function tangentAngle$2(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    var dx = derivativeAt(x1, x2, x3, x4, t);
-    var dy = derivativeAt(y1, y2, y3, y4, t);
-    return piMod(Math.atan2(dy, dx));
+  var dx = derivativeAt(x1, x2, x3, x4, t);
+  var dy = derivativeAt(y1, y2, y3, y4, t);
+  return piMod(Math.atan2(dy, dx));
 }
 
 function analyzePoints(points) {
-    // 计算每段的长度和总的长度
-    var totalLength = 0;
-    var segments = [];
-    for (var i = 0; i < points.length - 1; i++) {
-        var from = points[i];
-        var to = points[i + 1];
-        var length_1 = distance(from[0], from[1], to[0], to[1]);
-        var seg = {
-            from: from,
-            to: to,
-            length: length_1,
-        };
-        segments.push(seg);
-        totalLength += length_1;
-    }
-    return { segments: segments, totalLength: totalLength };
+  // 计算每段的长度和总的长度
+  var totalLength = 0;
+  var segments = [];
+  for (var i = 0; i < points.length - 1; i++) {
+    var from = points[i];
+    var to = points[i + 1];
+    var length = distance(from[0], from[1], to[0], to[1]);
+    var seg = {
+      from: from,
+      to: to,
+      length: length
+    };
+    segments.push(seg);
+    totalLength += length;
+  }
+  return {
+    segments: segments,
+    totalLength: totalLength
+  };
 }
 function lengthOfSegment(points) {
-    if (points.length < 2) {
-        return 0;
-    }
-    var totalLength = 0;
-    for (var i = 0; i < points.length - 1; i++) {
-        var from = points[i];
-        var to = points[i + 1];
-        totalLength += distance(from[0], from[1], to[0], to[1]);
-    }
-    return totalLength;
+  if (points.length < 2) {
+    return 0;
+  }
+  var totalLength = 0;
+  for (var i = 0; i < points.length - 1; i++) {
+    var from = points[i];
+    var to = points[i + 1];
+    totalLength += distance(from[0], from[1], to[0], to[1]);
+  }
+  return totalLength;
 }
+
 /**
@@ -498,30 +491,34 @@ * 按照比例在数据片段中获取点
 function pointAtSegments(points, t) {
-    // 边界判断
-    if (t > 1 || t < 0 || points.length < 2) {
-        return null;
+  // 边界判断
+  if (t > 1 || t < 0 || points.length < 2) {
+    return null;
+  }
+  var _analyzePoints = analyzePoints(points),
+    segments = _analyzePoints.segments,
+    totalLength = _analyzePoints.totalLength;
+  // 多个点有可能重合
+  if (totalLength === 0) {
+    return {
+      x: points[0][0],
+      y: points[0][1]
+    };
+  }
+  // 计算比例
+  var startRatio = 0;
+  var point = null;
+  for (var i = 0; i < segments.length; i++) {
+    var seg = segments[i];
+    var from = seg.from,
+      to = seg.to;
+    var currentRatio = seg.length / totalLength;
+    if (t >= startRatio && t <= startRatio + currentRatio) {
+      var localRatio = (t - startRatio) / currentRatio;
+      point = pointAt$3(from[0], from[1], to[0], to[1], localRatio);
+      break;
     }
-    var _a = analyzePoints(points), segments = _a.segments, totalLength = _a.totalLength;
-    // 多个点有可能重合
-    if (totalLength === 0) {
-        return {
-            x: points[0][0],
-            y: points[0][1],
-        };
-    }
-    // 计算比例
-    var startRatio = 0;
-    var point = null;
-    for (var i = 0; i < segments.length; i++) {
-        var seg = segments[i];
-        var from = seg.from, to = seg.to;
-        var currentRatio = seg.length / totalLength;
-        if (t >= startRatio && t <= startRatio + currentRatio) {
-            var localRatio = (t - startRatio) / currentRatio;
-            point = pointAt$3(from[0], from[1], to[0], to[1], localRatio);
-            break;
-        }
-        startRatio += currentRatio;
-    }
-    return point;
+    startRatio += currentRatio;
+  }
+  return point;
 }
+
 /**
@@ -533,79 +530,82 @@ * 按照比例在数据片段中获取切线的角度
 function angleAtSegments(points, t) {
-    // 边界判断
-    if (t > 1 || t < 0 || points.length < 2) {
-        return 0;
+  // 边界判断
+  if (t > 1 || t < 0 || points.length < 2) {
+    return 0;
+  }
+  var _analyzePoints2 = analyzePoints(points),
+    segments = _analyzePoints2.segments,
+    totalLength = _analyzePoints2.totalLength;
+  // 计算比例
+  var startRatio = 0;
+  var angle = 0;
+  for (var i = 0; i < segments.length; i++) {
+    var seg = segments[i];
+    var from = seg.from,
+      to = seg.to;
+    var currentRatio = seg.length / totalLength;
+    if (t >= startRatio && t <= startRatio + currentRatio) {
+      angle = Math.atan2(to[1] - from[1], to[0] - from[0]);
+      break;
     }
-    var _a = analyzePoints(points), segments = _a.segments, totalLength = _a.totalLength;
-    // 计算比例
-    var startRatio = 0;
-    var angle = 0;
-    for (var i = 0; i < segments.length; i++) {
-        var seg = segments[i];
-        var from = seg.from, to = seg.to;
-        var currentRatio = seg.length / totalLength;
-        if (t >= startRatio && t <= startRatio + currentRatio) {
-            angle = Math.atan2(to[1] - from[1], to[0] - from[0]);
-            break;
-        }
-        startRatio += currentRatio;
-    }
-    return angle;
+    startRatio += currentRatio;
+  }
+  return angle;
 }
 function distanceAtSegment(points, x, y) {
-    var minDistance = Infinity;
-    for (var i = 0; i < points.length - 1; i++) {
-        var point = points[i];
-        var nextPoint = points[i + 1];
-        var distance_1 = pointDistance$4(point[0], point[1], nextPoint[0], nextPoint[1], x, y);
-        if (distance_1 < minDistance) {
-            minDistance = distance_1;
-        }
+  var minDistance = Infinity;
+  for (var i = 0; i < points.length - 1; i++) {
+    var point = points[i];
+    var nextPoint = points[i + 1];
+    var _distance = pointDistance$4(point[0], point[1], nextPoint[0], nextPoint[1], x, y);
+    if (_distance < minDistance) {
+      minDistance = _distance;
     }
-    return minDistance;
+  }
+  return minDistance;
 }
 
 function box$2(points) {
-    var xArr = [];
-    var yArr = [];
-    for (var i = 0; i < points.length; i++) {
-        var point = points[i];
-        xArr.push(point[0]);
-        yArr.push(point[1]);
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xArr = [];
+  var yArr = [];
+  for (var i = 0; i < points.length; i++) {
+    var point = points[i];
+    xArr.push(point[0]);
+    yArr.push(point[1]);
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length$2(points) {
-    return lengthOfSegment(points);
+  return lengthOfSegment(points);
 }
 function pointAt$1(points, t) {
-    return pointAtSegments(points, t);
+  return pointAtSegments(points, t);
 }
 function pointDistance$2(points, x, y) {
-    return distanceAtSegment(points, x, y);
+  return distanceAtSegment(points, x, y);
 }
 function tangentAngle$1(points, t) {
-    return angleAtSegments(points, t);
+  return angleAtSegments(points, t);
 }
 
 function getAllPoints(points) {
-    var tmp = points.slice(0);
-    if (points.length) {
-        tmp.push(points[0]);
-    }
-    return tmp;
+  var tmp = points.slice(0);
+  if (points.length) {
+    tmp.push(points[0]);
+  }
+  return tmp;
 }
 function box$1(points) {
-    return box$2(points);
+  return box$2(points);
 }
 function length$1(points) {
-    return lengthOfSegment(getAllPoints(points));
+  return lengthOfSegment(getAllPoints(points));
 }
 function pointAt(points, t) {
-    return pointAtSegments(getAllPoints(points), t);
+  return pointAtSegments(getAllPoints(points), t);
 }
 function pointDistance$1(points, x, y) {
-    return distanceAtSegment(getAllPoints(points), x, y);
+  return distanceAtSegment(getAllPoints(points), x, y);
 }
 function tangentAngle(points, t) {
-    return angleAtSegments(getAllPoints(points), t);
+  return angleAtSegments(getAllPoints(points), t);
 }
@@ -615,69 +615,67 @@
 function quadraticAt(p0, p1, p2, t) {
-    var onet = 1 - t;
-    return onet * onet * p0 + 2 * t * onet * p1 + t * t * p2;
+  var onet = 1 - t;
+  return onet * onet * p0 + 2 * t * onet * p1 + t * t * p2;
 }
+
 // 求极值
 function extrema(p0, p1, p2) {
-    var a = p0 + p2 - 2 * p1;
-    if (isNumberEqual(a, 0)) {
-        return [0.5];
-    }
-    var rst = (p0 - p1) / a;
-    if (rst <= 1 && rst >= 0) {
-        return [rst];
-    }
-    return [];
+  var a = p0 + p2 - 2 * p1;
+  if (isNumberEqual(a, 0)) {
+    return [0.5];
+  }
+  var rst = (p0 - p1) / a;
+  if (rst <= 1 && rst >= 0) {
+    return [rst];
+  }
+  return [];
 }
+
 // 分割贝塞尔曲线
 function divideQuadratic(x1, y1, x2, y2, x3, y3, t) {
-    // 划分点
-    var xt = quadraticAt(x1, x2, x3, t);
-    var yt = quadraticAt(y1, y2, y3, t);
-    // 分割的第一条曲线的控制点
-    var controlPoint1 = pointAt$3(x1, y1, x2, y2, t);
-    // 分割的第二条曲线的控制点
-    var controlPoint2 = pointAt$3(x2, y2, x3, y3, t);
-    return [
-        [x1, y1, controlPoint1.x, controlPoint1.y, xt, yt],
-        [xt, yt, controlPoint2.x, controlPoint2.y, x3, y3],
-    ];
+  // 划分点
+  var xt = quadraticAt(x1, x2, x3, t);
+  var yt = quadraticAt(y1, y2, y3, t);
+
+  // 分割的第一条曲线的控制点
+  var controlPoint1 = pointAt$3(x1, y1, x2, y2, t);
+  // 分割的第二条曲线的控制点
+  var controlPoint2 = pointAt$3(x2, y2, x3, y3, t);
+  return [[x1, y1, controlPoint1.x, controlPoint1.y, xt, yt], [xt, yt, controlPoint2.x, controlPoint2.y, x3, y3]];
 }
+
 // 使用迭代法取贝塞尔曲线的长度
 function quadraticLength(x1, y1, x2, y2, x3, y3, iterationCount) {
-    if (iterationCount === 0) {
-        return ((distance(x1, y1, x2, y2) +
-            distance(x2, y2, x3, y3) +
-            distance(x1, y1, x3, y3)) /
-            2);
-    }
-    var quadratics = divideQuadratic(x1, y1, x2, y2, x3, y3, 0.5);
-    var left = quadratics[0];
-    var right = quadratics[1];
-    left.push(iterationCount - 1);
-    right.push(iterationCount - 1);
-    return quadraticLength.apply(void 0, __spreadArray([], __read(left), false)) + quadraticLength.apply(void 0, __spreadArray([], __read(right), false));
+  if (iterationCount === 0) {
+    return (distance(x1, y1, x2, y2) + distance(x2, y2, x3, y3) + distance(x1, y1, x3, y3)) / 2;
+  }
+  var quadratics = divideQuadratic(x1, y1, x2, y2, x3, y3, 0.5);
+  var left = quadratics[0];
+  var right = quadratics[1];
+  left.push(iterationCount - 1);
+  right.push(iterationCount - 1);
+  return quadraticLength.apply(void 0, _toConsumableArray(left)) + quadraticLength.apply(void 0, _toConsumableArray(right));
 }
 function box(x1, y1, x2, y2, x3, y3) {
-    var xExtrema = extrema(x1, x2, x3)[0];
-    var yExtrema = extrema(y1, y2, y3)[0];
-    // 控制点不加入 box 的计算
-    var xArr = [x1, x3];
-    var yArr = [y1, y3];
-    if (xExtrema !== undefined) {
-        xArr.push(quadraticAt(x1, x2, x3, xExtrema));
-    }
-    if (yExtrema !== undefined) {
-        yArr.push(quadraticAt(y1, y2, y3, yExtrema));
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xExtrema = extrema(x1, x2, x3)[0];
+  var yExtrema = extrema(y1, y2, y3)[0];
+  // 控制点不加入 box 的计算
+  var xArr = [x1, x3];
+  var yArr = [y1, y3];
+  if (xExtrema !== undefined) {
+    xArr.push(quadraticAt(x1, x2, x3, xExtrema));
+  }
+  if (yExtrema !== undefined) {
+    yArr.push(quadraticAt(y1, y2, y3, yExtrema));
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length(x1, y1, x2, y2, x3, y3) {
-    return quadraticLength(x1, y1, x2, y2, x3, y3, 3);
+  return quadraticLength(x1, y1, x2, y2, x3, y3, 3);
 }
 function nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0) {
-    return nearestPoint$2([x1, x2, x3], [y1, y2, y3], x0, y0, quadraticAt);
+  return nearestPoint$2([x1, x2, x3], [y1, y2, y3], x0, y0, quadraticAt);
 }
 function pointDistance(x1, y1, x2, y2, x3, y3, x0, y0) {
-    var point = nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0);
-    return distance(point.x, point.y, x0, y0);
+  var point = nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0);
+  return distance(point.x, point.y, x0, y0);
 }
@@ -684,0 +682,0 @@

dist/index.js

@@ -0,4 +1,13 @@
+/*!
+ * @antv/g-math
+ * @description Geometry util
+ * @version 3.0.1
+ * @date 5/9/2025, 8:18:51 AM
+ * @author AntVis
+ * @docs https://g.antv.antgroup.com/
+ */
 'use strict';
 
-var tslib = require('tslib');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var util = require('@antv/util');
@@ -8,69 +17,68 @@ var glMatrix = require('gl-matrix');
 function distance(x1, y1, x2, y2) {
-    var dx = x1 - x2;
-    var dy = y1 - y2;
-    return Math.sqrt(dx * dx + dy * dy);
+  var dx = x1 - x2;
+  var dy = y1 - y2;
+  return Math.sqrt(dx * dx + dy * dy);
 }
 function getBBoxByArray(xArr, yArr) {
-    var minX = Math.min.apply(Math, tslib.__spreadArray([], tslib.__read(xArr), false));
-    var minY = Math.min.apply(Math, tslib.__spreadArray([], tslib.__read(yArr), false));
-    var maxX = Math.max.apply(Math, tslib.__spreadArray([], tslib.__read(xArr), false));
-    var maxY = Math.max.apply(Math, tslib.__spreadArray([], tslib.__read(yArr), false));
-    return {
-        x: minX,
-        y: minY,
-        width: maxX - minX,
-        height: maxY - minY,
-    };
+  var minX = Math.min.apply(Math, _toConsumableArray(xArr));
+  var minY = Math.min.apply(Math, _toConsumableArray(yArr));
+  var maxX = Math.max.apply(Math, _toConsumableArray(xArr));
+  var maxY = Math.max.apply(Math, _toConsumableArray(yArr));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
 }
 function piMod(angle) {
-    return (angle + Math.PI * 2) % (Math.PI * 2);
+  return (angle + Math.PI * 2) % (Math.PI * 2);
 }
 
 function copysign(v1, v2) {
-    var absv = Math.abs(v1);
-    return v2 > 0 ? absv : absv * -1;
+  var absv = Math.abs(v1);
+  return v2 > 0 ? absv : absv * -1;
 }
 function nearestPoint$4(x, y, rx, ry, x0, y0) {
-    var a = rx;
-    var b = ry;
-    // 假如椭圆半径为0则返回圆心
-    if (a === 0 || b === 0) {
-        return {
-            x: x,
-            y: y,
-        };
-    }
-    // 转换成 0， 0 为中心的椭圆计算
-    var relativeX = x0 - x;
-    var relativeY = y0 - y;
-    var px = Math.abs(relativeX);
-    var py = Math.abs(relativeY);
-    var squareA = a * a;
-    var squareB = b * b;
-    // const angle0 = Math.atan2(relativeY, relativeX);
-    var t = Math.PI / 4;
-    var nearestX = 0; // 椭圆上的任一点
-    var nearestY = 0;
-    // 迭代 4 次
-    for (var i = 0; i < 4; i++) {
-        nearestX = a * Math.cos(t);
-        nearestY = b * Math.sin(t);
-        var ex = ((squareA - squareB) * Math.pow(Math.cos(t), 3)) / a;
-        var ey = ((squareB - squareA) * Math.pow(Math.sin(t), 3)) / b;
-        var rx1 = nearestX - ex;
-        var ry1 = nearestY - ey;
-        var qx = px - ex;
-        var qy = py - ey;
-        var r = Math.hypot(ry1, rx1);
-        var q = Math.hypot(qy, qx);
-        var delta_c = r * Math.asin((rx1 * qy - ry1 * qx) / (r * q));
-        var delta_t = delta_c /
-            Math.sqrt(squareA + squareB - nearestX * nearestX - nearestY * nearestY);
-        t += delta_t;
-        t = Math.min(Math.PI / 2, Math.max(0, t));
-    }
+  var a = rx;
+  var b = ry;
+  // 假如椭圆半径为0则返回圆心
+  if (a === 0 || b === 0) {
     return {
-        x: x + copysign(nearestX, relativeX),
-        y: y + copysign(nearestY, relativeY),
+      x: x,
+      y: y
     };
+  }
+  // 转换成 0， 0 为中心的椭圆计算
+  var relativeX = x0 - x;
+  var relativeY = y0 - y;
+  var px = Math.abs(relativeX);
+  var py = Math.abs(relativeY);
+  var squareA = a * a;
+  var squareB = b * b;
+  // const angle0 = Math.atan2(relativeY, relativeX);
+  var t = Math.PI / 4;
+  var nearestX = 0; // 椭圆上的任一点
+  var nearestY = 0;
+  // 迭代 4 次
+  for (var i = 0; i < 4; i++) {
+    nearestX = a * Math.cos(t);
+    nearestY = b * Math.sin(t);
+    var ex = (squareA - squareB) * Math.pow(Math.cos(t), 3) / a;
+    var ey = (squareB - squareA) * Math.pow(Math.sin(t), 3) / b;
+    var rx1 = nearestX - ex;
+    var ry1 = nearestY - ey;
+    var qx = px - ex;
+    var qy = py - ey;
+    var r = Math.hypot(ry1, rx1);
+    var q = Math.hypot(qy, qx);
+    var delta_c = r * Math.asin((rx1 * qy - ry1 * qx) / (r * q));
+    var delta_t = delta_c / Math.sqrt(squareA + squareB - nearestX * nearestX - nearestY * nearestY);
+    t += delta_t;
+    t = Math.min(Math.PI / 2, Math.max(0, t));
+  }
+  return {
+    x: x + copysign(nearestX, relativeX),
+    y: y + copysign(nearestY, relativeY)
+  };
 }
@@ -80,138 +88,135 @@
 function derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle) {
-    return (-1 * rx * Math.cos(xRotation) * Math.sin(angle) -
-        ry * Math.sin(xRotation) * Math.cos(angle));
+  return -1 * rx * Math.cos(xRotation) * Math.sin(angle) - ry * Math.sin(xRotation) * Math.cos(angle);
 }
+
 // 偏导数 y
 function derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle) {
-    return (-1 * rx * Math.sin(xRotation) * Math.sin(angle) +
-        ry * Math.cos(xRotation) * Math.cos(angle));
+  return -1 * rx * Math.sin(xRotation) * Math.sin(angle) + ry * Math.cos(xRotation) * Math.cos(angle);
 }
+
 // x 的极值
 function xExtrema(rx, ry, xRotation) {
-    return Math.atan((-ry / rx) * Math.tan(xRotation));
+  return Math.atan(-ry / rx * Math.tan(xRotation));
 }
+
 // y 的极值
 function yExtrema(rx, ry, xRotation) {
-    return Math.atan(ry / (rx * Math.tan(xRotation)));
+  return Math.atan(ry / (rx * Math.tan(xRotation)));
 }
+
 // 根据角度求 x 坐标
 function xAt(cx, cy, rx, ry, xRotation, angle) {
-    return (rx * Math.cos(xRotation) * Math.cos(angle) -
-        ry * Math.sin(xRotation) * Math.sin(angle) +
-        cx);
+  return rx * Math.cos(xRotation) * Math.cos(angle) - ry * Math.sin(xRotation) * Math.sin(angle) + cx;
 }
+
 // 根据角度求 y 坐标
 function yAt(cx, cy, rx, ry, xRotation, angle) {
-    return (rx * Math.sin(xRotation) * Math.cos(angle) +
-        ry * Math.cos(xRotation) * Math.sin(angle) +
-        cy);
+  return rx * Math.sin(xRotation) * Math.cos(angle) + ry * Math.cos(xRotation) * Math.sin(angle) + cy;
 }
+
 // 获取点在椭圆上的角度
 function getAngle(rx, ry, x0, y0) {
-    var angle = Math.atan2(y0 * rx, x0 * ry);
-    // 转换到 0 - 2PI 内
-    return (angle + Math.PI * 2) % (Math.PI * 2);
+  var angle = Math.atan2(y0 * rx, x0 * ry);
+  // 转换到 0 - 2PI 内
+  return (angle + Math.PI * 2) % (Math.PI * 2);
 }
+
 // 根据角度获取，x,y
 function getPoint(rx, ry, angle) {
-    return {
-        x: rx * Math.cos(angle),
-        y: ry * Math.sin(angle),
-    };
+  return {
+    x: rx * Math.cos(angle),
+    y: ry * Math.sin(angle)
+  };
 }
+
 // 旋转
 function rotate(x, y, angle) {
-    var cos = Math.cos(angle);
-    var sin = Math.sin(angle);
-    return [x * cos - y * sin, x * sin + y * cos];
+  var cos = Math.cos(angle);
+  var sin = Math.sin(angle);
+  return [x * cos - y * sin, x * sin + y * cos];
 }
 function box$5(cx, cy, rx, ry, xRotation, startAngle, endAngle) {
-    var xDim = xExtrema(rx, ry, xRotation);
-    var minX = Infinity;
-    var maxX = -Infinity;
-    var xs = [startAngle, endAngle];
-    for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
-        var xAngle = xDim + i;
-        if (startAngle < endAngle) {
-            if (startAngle < xAngle && xAngle < endAngle) {
-                xs.push(xAngle);
-            }
-        }
-        else {
-            if (endAngle < xAngle && xAngle < startAngle) {
-                xs.push(xAngle);
-            }
-        }
+  var xDim = xExtrema(rx, ry, xRotation);
+  var minX = Infinity;
+  var maxX = -Infinity;
+  var xs = [startAngle, endAngle];
+  for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
+    var xAngle = xDim + i;
+    if (startAngle < endAngle) {
+      if (startAngle < xAngle && xAngle < endAngle) {
+        xs.push(xAngle);
+      }
+    } else if (endAngle < xAngle && xAngle < startAngle) {
+      xs.push(xAngle);
     }
-    for (var i = 0; i < xs.length; i++) {
-        var x = xAt(cx, cy, rx, ry, xRotation, xs[i]);
-        if (x < minX) {
-            minX = x;
-        }
-        if (x > maxX) {
-            maxX = x;
-        }
+  }
+  for (var _i = 0; _i < xs.length; _i++) {
+    var x = xAt(cx, cy, rx, ry, xRotation, xs[_i]);
+    if (x < minX) {
+      minX = x;
     }
-    var yDim = yExtrema(rx, ry, xRotation);
-    var minY = Infinity;
-    var maxY = -Infinity;
-    var ys = [startAngle, endAngle];
-    for (var i = -Math.PI * 2; i <= Math.PI * 2; i += Math.PI) {
-        var yAngle = yDim + i;
-        if (startAngle < endAngle) {
-            if (startAngle < yAngle && yAngle < endAngle) {
-                ys.push(yAngle);
-            }
-        }
-        else {
-            if (endAngle < yAngle && yAngle < startAngle) {
-                ys.push(yAngle);
-            }
-        }
+    if (x > maxX) {
+      maxX = x;
     }
-    for (var i = 0; i < ys.length; i++) {
-        var y = yAt(cx, cy, rx, ry, xRotation, ys[i]);
-        if (y < minY) {
-            minY = y;
-        }
-        if (y > maxY) {
-            maxY = y;
-        }
+  }
+  var yDim = yExtrema(rx, ry, xRotation);
+  var minY = Infinity;
+  var maxY = -Infinity;
+  var ys = [startAngle, endAngle];
+  for (var _i2 = -Math.PI * 2; _i2 <= Math.PI * 2; _i2 += Math.PI) {
+    var yAngle = yDim + _i2;
+    if (startAngle < endAngle) {
+      if (startAngle < yAngle && yAngle < endAngle) {
+        ys.push(yAngle);
+      }
+    } else if (endAngle < yAngle && yAngle < startAngle) {
+      ys.push(yAngle);
     }
-    return {
-        x: minX,
-        y: minY,
-        width: maxX - minX,
-        height: maxY - minY,
-    };
-}
-function nearestPoint$3(cx, cy, rx, ry, xRotation, startAngle, endAngle, x0, y0) {
-    // 将最近距离问题转换成到椭圆中心 0,0 没有旋转的椭圆问题
-    var relativeVector = rotate(x0 - cx, y0 - cy, -xRotation);
-    var _a = tslib.__read(relativeVector, 2), x1 = _a[0], y1 = _a[1];
-    // 计算点到椭圆的最近的点
-    var relativePoint = nearestPoint$4(0, 0, rx, ry, x1, y1);
-    // 获取点在椭圆上的角度
-    var angle = getAngle(rx, ry, relativePoint.x, relativePoint.y);
-    // 点没有在圆弧上
-    if (angle < startAngle) {
-        // 小于起始圆弧
-        relativePoint = getPoint(rx, ry, startAngle);
+  }
+  for (var _i3 = 0; _i3 < ys.length; _i3++) {
+    var y = yAt(cx, cy, rx, ry, xRotation, ys[_i3]);
+    if (y < minY) {
+      minY = y;
     }
-    else if (angle > endAngle) {
-        // 大于结束圆弧
-        relativePoint = getPoint(rx, ry, endAngle);
+    if (y > maxY) {
+      maxY = y;
     }
-    // 旋转到 xRotation 的角度
-    var vector = rotate(relativePoint.x, relativePoint.y, xRotation);
-    return {
-        x: vector[0] + cx,
-        y: vector[1] + cy,
-    };
+  }
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
 }
+function nearestPoint$3(cx, cy, rx, ry, xRotation, startAngle, endAngle, x0, y0) {
+  // 将最近距离问题转换成到椭圆中心 0,0 没有旋转的椭圆问题
+  var relativeVector = rotate(x0 - cx, y0 - cy, -xRotation);
+  var _relativeVector = _slicedToArray(relativeVector, 2),
+    x1 = _relativeVector[0],
+    y1 = _relativeVector[1];
+  // 计算点到椭圆的最近的点
+  var relativePoint = nearestPoint$4(0, 0, rx, ry, x1, y1);
+  // 获取点在椭圆上的角度
+  var angle = getAngle(rx, ry, relativePoint.x, relativePoint.y);
+  // 点没有在圆弧上
+  if (angle < startAngle) {
+    // 小于起始圆弧
+    relativePoint = getPoint(rx, ry, startAngle);
+  } else if (angle > endAngle) {
+    // 大于结束圆弧
+    relativePoint = getPoint(rx, ry, endAngle);
+  }
+  // 旋转到 xRotation 的角度
+  var vector = rotate(relativePoint.x, relativePoint.y, xRotation);
+  return {
+    x: vector[0] + cx,
+    y: vector[1] + cy
+  };
+}
 function tangentAngle$4(cx, cy, rx, ry, xRotation, startAngle, endAngle, t) {
-    var angle = (endAngle - startAngle) * t + startAngle;
-    var dx = derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
-    var dy = derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
-    return piMod(Math.atan2(dy, dx));
+  var angle = (endAngle - startAngle) * t + startAngle;
+  var dx = derivativeXAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
+  var dy = derivativeYAt(cx, cy, rx, ry, xRotation, startAngle, endAngle, angle);
+  return piMod(Math.atan2(dy, dx));
 }
@@ -229,265 +234,253 @@
 function nearestPoint$2(xArr, yArr, x, y, tCallback, length) {
-    var t = -1;
-    var d = Infinity;
-    var v0 = [x, y];
-    var segNum = 20;
-    if (length && length > 200) {
-        segNum = length / 10;
+  var t = -1;
+  var d = Infinity;
+  var v0 = [x, y];
+  var segNum = 20;
+  if (length && length > 200) {
+    segNum = length / 10;
+  }
+  var increaseRate = 1 / segNum;
+  var interval = increaseRate / 10;
+  for (var i = 0; i <= segNum; i++) {
+    var _t = i * increaseRate;
+    var v1 = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([_t]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([_t])))];
+    var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
+    if (d1 < d) {
+      t = _t;
+      d = d1;
     }
-    var increaseRate = 1 / segNum;
-    var interval = increaseRate / 10;
-    for (var i = 0; i <= segNum; i++) {
-        var _t = i * increaseRate;
-        var v1 = [
-            tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(xArr.concat([_t])), false)),
-            tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(yArr.concat([_t])), false)),
-        ];
-        var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
-        if (d1 < d) {
-            t = _t;
-            d = d1;
-        }
+  }
+  // 提前终止
+  if (t === 0) {
+    return {
+      x: xArr[0],
+      y: yArr[0]
+    };
+  }
+  if (t === 1) {
+    var count = xArr.length;
+    return {
+      x: xArr[count - 1],
+      y: yArr[count - 1]
+    };
+  }
+  d = Infinity;
+  for (var _i = 0; _i < 32; _i++) {
+    if (interval < EPSILON) {
+      break;
     }
-    // 提前终止
-    if (t === 0) {
-        return {
-            x: xArr[0],
-            y: yArr[0],
-        };
+    var prev = t - interval;
+    var next = t + interval;
+    var _v = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([prev]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([prev])))];
+    var _d = distance(v0[0], v0[1], _v[0], _v[1]);
+    if (prev >= 0 && _d < d) {
+      t = prev;
+      d = _d;
+    } else {
+      var v2 = [tCallback.apply(void 0, _toConsumableArray(xArr.concat([next]))), tCallback.apply(void 0, _toConsumableArray(yArr.concat([next])))];
+      var d2 = distance(v0[0], v0[1], v2[0], v2[1]);
+      if (next <= 1 && d2 < d) {
+        t = next;
+        d = d2;
+      } else {
+        interval *= 0.5;
+      }
     }
-    if (t === 1) {
-        var count = xArr.length;
-        return {
-            x: xArr[count - 1],
-            y: yArr[count - 1],
-        };
-    }
-    d = Infinity;
-    for (var i = 0; i < 32; i++) {
-        if (interval < EPSILON) {
-            break;
-        }
-        var prev = t - interval;
-        var next = t + interval;
-        var v1 = [
-            tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(xArr.concat([prev])), false)),
-            tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(yArr.concat([prev])), false)),
-        ];
-        var d1 = distance(v0[0], v0[1], v1[0], v1[1]);
-        if (prev >= 0 && d1 < d) {
-            t = prev;
-            d = d1;
-        }
-        else {
-            var v2 = [
-                tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(xArr.concat([next])), false)),
-                tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(yArr.concat([next])), false)),
-            ];
-            var d2 = distance(v0[0], v0[1], v2[0], v2[1]);
-            if (next <= 1 && d2 < d) {
-                t = next;
-                d = d2;
-            }
-            else {
-                interval *= 0.5;
-            }
-        }
-    }
-    return {
-        x: tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(xArr.concat([t])), false)),
-        y: tCallback.apply(void 0, tslib.__spreadArray([], tslib.__read(yArr.concat([t])), false)),
-    };
+  }
+  return {
+    x: tCallback.apply(void 0, _toConsumableArray(xArr.concat([t]))),
+    y: tCallback.apply(void 0, _toConsumableArray(yArr.concat([t])))
+  };
 }
+
 // 近似求解 https://community.khronos.org/t/3d-cubic-bezier-segment-length/62363/2
 function snapLength(xArr, yArr) {
-    var totalLength = 0;
-    var count = xArr.length;
-    for (var i = 0; i < count; i++) {
-        var x = xArr[i];
-        var y = yArr[i];
-        var nextX = xArr[(i + 1) % count];
-        var nextY = yArr[(i + 1) % count];
-        totalLength += distance(x, y, nextX, nextY);
-    }
-    return totalLength / 2;
+  var totalLength = 0;
+  var count = xArr.length;
+  for (var i = 0; i < count; i++) {
+    var x = xArr[i];
+    var y = yArr[i];
+    var nextX = xArr[(i + 1) % count];
+    var nextY = yArr[(i + 1) % count];
+    totalLength += distance(x, y, nextX, nextY);
+  }
+  return totalLength / 2;
 }
 
 function box$4(x1, y1, x2, y2) {
-    return getBBoxByArray([x1, x2], [y1, y2]);
+  return getBBoxByArray([x1, x2], [y1, y2]);
 }
 function length$4(x1, y1, x2, y2) {
-    return distance(x1, y1, x2, y2);
+  return distance(x1, y1, x2, y2);
 }
 function pointAt$3(x1, y1, x2, y2, t) {
-    return {
-        x: (1 - t) * x1 + t * x2,
-        y: (1 - t) * y1 + t * y2,
-    };
+  return {
+    x: (1 - t) * x1 + t * x2,
+    y: (1 - t) * y1 + t * y2
+  };
 }
 function pointDistance$4(x1, y1, x2, y2, x, y) {
-    // 投影距离 x1, y1 的向量，假设 p, p1, p2 三个点，投影点为 a
-    // p1a = p1p.p1p2/|p1p2| * (p1p 的单位向量)
-    var cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
-    if (cross < 0) {
-        return distance(x1, y1, x, y);
-    }
-    var lengthSquare = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
-    if (cross > lengthSquare) {
-        return distance(x2, y2, x, y);
-    }
-    return pointToLine(x1, y1, x2, y2, x, y);
+  // 投影距离 x1, y1 的向量，假设 p, p1, p2 三个点，投影点为 a
+  // p1a = p1p.p1p2/|p1p2| * (p1p 的单位向量)
+  var cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
+  if (cross < 0) {
+    return distance(x1, y1, x, y);
+  }
+  var lengthSquare = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+  if (cross > lengthSquare) {
+    return distance(x2, y2, x, y);
+  }
+  return pointToLine(x1, y1, x2, y2, x, y);
 }
 function pointToLine(x1, y1, x2, y2, x, y) {
-    var d = [x2 - x1, y2 - y1];
-    // 如果端点相等，则判定点到点的距离
-    if (glMatrix.vec2.exactEquals(d, [0, 0])) {
-        return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
-    }
-    var u = [-d[1], d[0]];
-    glMatrix.vec2.normalize(u, u);
-    var a = [x - x1, y - y1];
-    return Math.abs(glMatrix.vec2.dot(a, u));
+  var d = [x2 - x1, y2 - y1];
+  // 如果端点相等，则判定点到点的距离
+  if (glMatrix.vec2.exactEquals(d, [0, 0])) {
+    return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
+  }
+  var u = [-d[1], d[0]];
+  glMatrix.vec2.normalize(u, u);
+  var a = [x - x1, y - y1];
+  return Math.abs(glMatrix.vec2.dot(a, u));
 }
 function tangentAngle$3(x1, y1, x2, y2) {
-    return Math.atan2(y2 - y1, x2 - x1);
+  return Math.atan2(y2 - y1, x2 - x1);
 }
 
 function cubicAt(p0, p1, p2, p3, t) {
-    var onet = 1 - t; // t * t * t 的性能大概是 Math.pow(t, 3) 的三倍
-    return (onet * onet * onet * p0 +
-        3 * p1 * t * onet * onet +
-        3 * p2 * t * t * onet +
-        p3 * t * t * t);
+  var onet = 1 - t; // t * t * t 的性能大概是 Math.pow(t, 3) 的三倍
+  return onet * onet * onet * p0 + 3 * p1 * t * onet * onet + 3 * p2 * t * t * onet + p3 * t * t * t;
 }
 function derivativeAt(p0, p1, p2, p3, t) {
-    var onet = 1 - t;
-    return (3 * (onet * onet * (p1 - p0) + 2 * onet * t * (p2 - p1) + t * t * (p3 - p2)));
+  var onet = 1 - t;
+  return 3 * (onet * onet * (p1 - p0) + 2 * onet * t * (p2 - p1) + t * t * (p3 - p2));
 }
 function extrema$1(p0, p1, p2, p3) {
-    var a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
-    var b = 6 * p0 - 12 * p1 + 6 * p2;
-    var c = 3 * p1 - 3 * p0;
-    var extremas = [];
-    var t1;
-    var t2;
-    var discSqrt;
-    if (util.isNumberEqual(a, 0)) {
-        if (!util.isNumberEqual(b, 0)) {
-            t1 = -c / b;
-            if (t1 >= 0 && t1 <= 1) {
-                extremas.push(t1);
-            }
-        }
+  var a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
+  var b = 6 * p0 - 12 * p1 + 6 * p2;
+  var c = 3 * p1 - 3 * p0;
+  var extremas = [];
+  var t1;
+  var t2;
+  var discSqrt;
+  if (util.isNumberEqual(a, 0)) {
+    if (!util.isNumberEqual(b, 0)) {
+      t1 = -c / b;
+      if (t1 >= 0 && t1 <= 1) {
+        extremas.push(t1);
+      }
     }
-    else {
-        var disc = b * b - 4 * a * c;
-        if (util.isNumberEqual(disc, 0)) {
-            extremas.push(-b / (2 * a));
-        }
-        else if (disc > 0) {
-            discSqrt = Math.sqrt(disc);
-            t1 = (-b + discSqrt) / (2 * a);
-            t2 = (-b - discSqrt) / (2 * a);
-            if (t1 >= 0 && t1 <= 1) {
-                extremas.push(t1);
-            }
-            if (t2 >= 0 && t2 <= 1) {
-                extremas.push(t2);
-            }
-        }
+  } else {
+    var disc = b * b - 4 * a * c;
+    if (util.isNumberEqual(disc, 0)) {
+      extremas.push(-b / (2 * a));
+    } else if (disc > 0) {
+      discSqrt = Math.sqrt(disc);
+      t1 = (-b + discSqrt) / (2 * a);
+      t2 = (-b - discSqrt) / (2 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        extremas.push(t1);
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        extremas.push(t2);
+      }
     }
-    return extremas;
+  }
+  return extremas;
 }
+
 // 分割贝塞尔曲线
 function divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    // 划分点
-    var xt = cubicAt(x1, x2, x3, x4, t);
-    var yt = cubicAt(y1, y2, y3, y4, t);
-    // 计算两点之间的差值点
-    var c1 = pointAt$3(x1, y1, x2, y2, t);
-    var c2 = pointAt$3(x2, y2, x3, y3, t);
-    var c3 = pointAt$3(x3, y3, x4, y4, t);
-    var c12 = pointAt$3(c1.x, c1.y, c2.x, c2.y, t);
-    var c23 = pointAt$3(c2.x, c2.y, c3.x, c3.y, t);
-    return [
-        [x1, y1, c1.x, c1.y, c12.x, c12.y, xt, yt],
-        [xt, yt, c23.x, c23.y, c3.x, c3.y, x4, y4],
-    ];
+  // 划分点
+  var xt = cubicAt(x1, x2, x3, x4, t);
+  var yt = cubicAt(y1, y2, y3, y4, t);
+  // 计算两点之间的差值点
+  var c1 = pointAt$3(x1, y1, x2, y2, t);
+  var c2 = pointAt$3(x2, y2, x3, y3, t);
+  var c3 = pointAt$3(x3, y3, x4, y4, t);
+  var c12 = pointAt$3(c1.x, c1.y, c2.x, c2.y, t);
+  var c23 = pointAt$3(c2.x, c2.y, c3.x, c3.y, t);
+  return [[x1, y1, c1.x, c1.y, c12.x, c12.y, xt, yt], [xt, yt, c23.x, c23.y, c3.x, c3.y, x4, y4]];
 }
+
 // 使用迭代法取贝塞尔曲线的长度，二阶和三阶分开写，更清晰和便于调试
 function cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, iterationCount) {
-    if (iterationCount === 0) {
-        return snapLength([x1, x2, x3, x4], [y1, y2, y3, y4]);
-    }
-    var cubics = divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0.5);
-    var left = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(cubics[0]), false), [iterationCount - 1], false);
-    var right = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(cubics[1]), false), [iterationCount - 1], false);
-    return cubicLength.apply(void 0, tslib.__spreadArray([], tslib.__read(left), false)) + cubicLength.apply(void 0, tslib.__spreadArray([], tslib.__read(right), false));
+  if (iterationCount === 0) {
+    return snapLength([x1, x2, x3, x4], [y1, y2, y3, y4]);
+  }
+  var cubics = divideCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0.5);
+  var left = [].concat(_toConsumableArray(cubics[0]), [iterationCount - 1]);
+  var right = [].concat(_toConsumableArray(cubics[1]), [iterationCount - 1]);
+  return cubicLength.apply(void 0, _toConsumableArray(left)) + cubicLength.apply(void 0, _toConsumableArray(right));
 }
 function box$3(x1, y1, x2, y2, x3, y3, x4, y4) {
-    var xArr = [x1, x4];
-    var yArr = [y1, y4];
-    var xExtrema = extrema$1(x1, x2, x3, x4);
-    var yExtrema = extrema$1(y1, y2, y3, y4);
-    for (var i = 0; i < xExtrema.length; i++) {
-        xArr.push(cubicAt(x1, x2, x3, x4, xExtrema[i]));
-    }
-    for (var i = 0; i < yExtrema.length; i++) {
-        yArr.push(cubicAt(y1, y2, y3, y4, yExtrema[i]));
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xArr = [x1, x4];
+  var yArr = [y1, y4];
+  var xExtrema = extrema$1(x1, x2, x3, x4);
+  var yExtrema = extrema$1(y1, y2, y3, y4);
+  for (var i = 0; i < xExtrema.length; i++) {
+    xArr.push(cubicAt(x1, x2, x3, x4, xExtrema[i]));
+  }
+  for (var _i = 0; _i < yExtrema.length; _i++) {
+    yArr.push(cubicAt(y1, y2, y3, y4, yExtrema[_i]));
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length$3(x1, y1, x2, y2, x3, y3, x4, y4) {
-    // 迭代三次，划分成 8 段求长度
-    return cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, 3);
+  // 迭代三次，划分成 8 段求长度
+  return cubicLength(x1, y1, x2, y2, x3, y3, x4, y4, 3);
 }
 function nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length) {
-    return nearestPoint$2([x1, x2, x3, x4], [y1, y2, y3, y4], x0, y0, cubicAt, length);
+  return nearestPoint$2([x1, x2, x3, x4], [y1, y2, y3, y4], x0, y0, cubicAt, length);
 }
 function pointDistance$3(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length) {
-    var point = nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length);
-    return distance(point.x, point.y, x0, y0);
+  var point = nearestPoint$1(x1, y1, x2, y2, x3, y3, x4, y4, x0, y0, length);
+  return distance(point.x, point.y, x0, y0);
 }
 function pointAt$2(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    return {
-        x: cubicAt(x1, x2, x3, x4, t),
-        y: cubicAt(y1, y2, y3, y4, t),
-    };
+  return {
+    x: cubicAt(x1, x2, x3, x4, t),
+    y: cubicAt(y1, y2, y3, y4, t)
+  };
 }
 function tangentAngle$2(x1, y1, x2, y2, x3, y3, x4, y4, t) {
-    var dx = derivativeAt(x1, x2, x3, x4, t);
-    var dy = derivativeAt(y1, y2, y3, y4, t);
-    return piMod(Math.atan2(dy, dx));
+  var dx = derivativeAt(x1, x2, x3, x4, t);
+  var dy = derivativeAt(y1, y2, y3, y4, t);
+  return piMod(Math.atan2(dy, dx));
 }
 
 function analyzePoints(points) {
-    // 计算每段的长度和总的长度
-    var totalLength = 0;
-    var segments = [];
-    for (var i = 0; i < points.length - 1; i++) {
-        var from = points[i];
-        var to = points[i + 1];
-        var length_1 = distance(from[0], from[1], to[0], to[1]);
-        var seg = {
-            from: from,
-            to: to,
-            length: length_1,
-        };
-        segments.push(seg);
-        totalLength += length_1;
-    }
-    return { segments: segments, totalLength: totalLength };
+  // 计算每段的长度和总的长度
+  var totalLength = 0;
+  var segments = [];
+  for (var i = 0; i < points.length - 1; i++) {
+    var from = points[i];
+    var to = points[i + 1];
+    var length = distance(from[0], from[1], to[0], to[1]);
+    var seg = {
+      from: from,
+      to: to,
+      length: length
+    };
+    segments.push(seg);
+    totalLength += length;
+  }
+  return {
+    segments: segments,
+    totalLength: totalLength
+  };
 }
 function lengthOfSegment(points) {
-    if (points.length < 2) {
-        return 0;
-    }
-    var totalLength = 0;
-    for (var i = 0; i < points.length - 1; i++) {
-        var from = points[i];
-        var to = points[i + 1];
-        totalLength += distance(from[0], from[1], to[0], to[1]);
-    }
-    return totalLength;
+  if (points.length < 2) {
+    return 0;
+  }
+  var totalLength = 0;
+  for (var i = 0; i < points.length - 1; i++) {
+    var from = points[i];
+    var to = points[i + 1];
+    totalLength += distance(from[0], from[1], to[0], to[1]);
+  }
+  return totalLength;
 }
+
 /**
@@ -500,30 +493,34 @@ * 按照比例在数据片段中获取点
 function pointAtSegments(points, t) {
-    // 边界判断
-    if (t > 1 || t < 0 || points.length < 2) {
-        return null;
+  // 边界判断
+  if (t > 1 || t < 0 || points.length < 2) {
+    return null;
+  }
+  var _analyzePoints = analyzePoints(points),
+    segments = _analyzePoints.segments,
+    totalLength = _analyzePoints.totalLength;
+  // 多个点有可能重合
+  if (totalLength === 0) {
+    return {
+      x: points[0][0],
+      y: points[0][1]
+    };
+  }
+  // 计算比例
+  var startRatio = 0;
+  var point = null;
+  for (var i = 0; i < segments.length; i++) {
+    var seg = segments[i];
+    var from = seg.from,
+      to = seg.to;
+    var currentRatio = seg.length / totalLength;
+    if (t >= startRatio && t <= startRatio + currentRatio) {
+      var localRatio = (t - startRatio) / currentRatio;
+      point = pointAt$3(from[0], from[1], to[0], to[1], localRatio);
+      break;
     }
-    var _a = analyzePoints(points), segments = _a.segments, totalLength = _a.totalLength;
-    // 多个点有可能重合
-    if (totalLength === 0) {
-        return {
-            x: points[0][0],
-            y: points[0][1],
-        };
-    }
-    // 计算比例
-    var startRatio = 0;
-    var point = null;
-    for (var i = 0; i < segments.length; i++) {
-        var seg = segments[i];
-        var from = seg.from, to = seg.to;
-        var currentRatio = seg.length / totalLength;
-        if (t >= startRatio && t <= startRatio + currentRatio) {
-            var localRatio = (t - startRatio) / currentRatio;
-            point = pointAt$3(from[0], from[1], to[0], to[1], localRatio);
-            break;
-        }
-        startRatio += currentRatio;
-    }
-    return point;
+    startRatio += currentRatio;
+  }
+  return point;
 }
+
 /**
@@ -535,79 +532,82 @@ * 按照比例在数据片段中获取切线的角度
 function angleAtSegments(points, t) {
-    // 边界判断
-    if (t > 1 || t < 0 || points.length < 2) {
-        return 0;
+  // 边界判断
+  if (t > 1 || t < 0 || points.length < 2) {
+    return 0;
+  }
+  var _analyzePoints2 = analyzePoints(points),
+    segments = _analyzePoints2.segments,
+    totalLength = _analyzePoints2.totalLength;
+  // 计算比例
+  var startRatio = 0;
+  var angle = 0;
+  for (var i = 0; i < segments.length; i++) {
+    var seg = segments[i];
+    var from = seg.from,
+      to = seg.to;
+    var currentRatio = seg.length / totalLength;
+    if (t >= startRatio && t <= startRatio + currentRatio) {
+      angle = Math.atan2(to[1] - from[1], to[0] - from[0]);
+      break;
     }
-    var _a = analyzePoints(points), segments = _a.segments, totalLength = _a.totalLength;
-    // 计算比例
-    var startRatio = 0;
-    var angle = 0;
-    for (var i = 0; i < segments.length; i++) {
-        var seg = segments[i];
-        var from = seg.from, to = seg.to;
-        var currentRatio = seg.length / totalLength;
-        if (t >= startRatio && t <= startRatio + currentRatio) {
-            angle = Math.atan2(to[1] - from[1], to[0] - from[0]);
-            break;
-        }
-        startRatio += currentRatio;
-    }
-    return angle;
+    startRatio += currentRatio;
+  }
+  return angle;
 }
 function distanceAtSegment(points, x, y) {
-    var minDistance = Infinity;
-    for (var i = 0; i < points.length - 1; i++) {
-        var point = points[i];
-        var nextPoint = points[i + 1];
-        var distance_1 = pointDistance$4(point[0], point[1], nextPoint[0], nextPoint[1], x, y);
-        if (distance_1 < minDistance) {
-            minDistance = distance_1;
-        }
+  var minDistance = Infinity;
+  for (var i = 0; i < points.length - 1; i++) {
+    var point = points[i];
+    var nextPoint = points[i + 1];
+    var _distance = pointDistance$4(point[0], point[1], nextPoint[0], nextPoint[1], x, y);
+    if (_distance < minDistance) {
+      minDistance = _distance;
     }
-    return minDistance;
+  }
+  return minDistance;
 }
 
 function box$2(points) {
-    var xArr = [];
-    var yArr = [];
-    for (var i = 0; i < points.length; i++) {
-        var point = points[i];
-        xArr.push(point[0]);
-        yArr.push(point[1]);
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xArr = [];
+  var yArr = [];
+  for (var i = 0; i < points.length; i++) {
+    var point = points[i];
+    xArr.push(point[0]);
+    yArr.push(point[1]);
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length$2(points) {
-    return lengthOfSegment(points);
+  return lengthOfSegment(points);
 }
 function pointAt$1(points, t) {
-    return pointAtSegments(points, t);
+  return pointAtSegments(points, t);
 }
 function pointDistance$2(points, x, y) {
-    return distanceAtSegment(points, x, y);
+  return distanceAtSegment(points, x, y);
 }
 function tangentAngle$1(points, t) {
-    return angleAtSegments(points, t);
+  return angleAtSegments(points, t);
 }
 
 function getAllPoints(points) {
-    var tmp = points.slice(0);
-    if (points.length) {
-        tmp.push(points[0]);
-    }
-    return tmp;
+  var tmp = points.slice(0);
+  if (points.length) {
+    tmp.push(points[0]);
+  }
+  return tmp;
 }
 function box$1(points) {
-    return box$2(points);
+  return box$2(points);
 }
 function length$1(points) {
-    return lengthOfSegment(getAllPoints(points));
+  return lengthOfSegment(getAllPoints(points));
 }
 function pointAt(points, t) {
-    return pointAtSegments(getAllPoints(points), t);
+  return pointAtSegments(getAllPoints(points), t);
 }
 function pointDistance$1(points, x, y) {
-    return distanceAtSegment(getAllPoints(points), x, y);
+  return distanceAtSegment(getAllPoints(points), x, y);
 }
 function tangentAngle(points, t) {
-    return angleAtSegments(getAllPoints(points), t);
+  return angleAtSegments(getAllPoints(points), t);
 }
@@ -617,69 +617,67 @@
 function quadraticAt(p0, p1, p2, t) {
-    var onet = 1 - t;
-    return onet * onet * p0 + 2 * t * onet * p1 + t * t * p2;
+  var onet = 1 - t;
+  return onet * onet * p0 + 2 * t * onet * p1 + t * t * p2;
 }
+
 // 求极值
 function extrema(p0, p1, p2) {
-    var a = p0 + p2 - 2 * p1;
-    if (util.isNumberEqual(a, 0)) {
-        return [0.5];
-    }
-    var rst = (p0 - p1) / a;
-    if (rst <= 1 && rst >= 0) {
-        return [rst];
-    }
-    return [];
+  var a = p0 + p2 - 2 * p1;
+  if (util.isNumberEqual(a, 0)) {
+    return [0.5];
+  }
+  var rst = (p0 - p1) / a;
+  if (rst <= 1 && rst >= 0) {
+    return [rst];
+  }
+  return [];
 }
+
 // 分割贝塞尔曲线
 function divideQuadratic(x1, y1, x2, y2, x3, y3, t) {
-    // 划分点
-    var xt = quadraticAt(x1, x2, x3, t);
-    var yt = quadraticAt(y1, y2, y3, t);
-    // 分割的第一条曲线的控制点
-    var controlPoint1 = pointAt$3(x1, y1, x2, y2, t);
-    // 分割的第二条曲线的控制点
-    var controlPoint2 = pointAt$3(x2, y2, x3, y3, t);
-    return [
-        [x1, y1, controlPoint1.x, controlPoint1.y, xt, yt],
-        [xt, yt, controlPoint2.x, controlPoint2.y, x3, y3],
-    ];
+  // 划分点
+  var xt = quadraticAt(x1, x2, x3, t);
+  var yt = quadraticAt(y1, y2, y3, t);
+
+  // 分割的第一条曲线的控制点
+  var controlPoint1 = pointAt$3(x1, y1, x2, y2, t);
+  // 分割的第二条曲线的控制点
+  var controlPoint2 = pointAt$3(x2, y2, x3, y3, t);
+  return [[x1, y1, controlPoint1.x, controlPoint1.y, xt, yt], [xt, yt, controlPoint2.x, controlPoint2.y, x3, y3]];
 }
+
 // 使用迭代法取贝塞尔曲线的长度
 function quadraticLength(x1, y1, x2, y2, x3, y3, iterationCount) {
-    if (iterationCount === 0) {
-        return ((distance(x1, y1, x2, y2) +
-            distance(x2, y2, x3, y3) +
-            distance(x1, y1, x3, y3)) /
-            2);
-    }
-    var quadratics = divideQuadratic(x1, y1, x2, y2, x3, y3, 0.5);
-    var left = quadratics[0];
-    var right = quadratics[1];
-    left.push(iterationCount - 1);
-    right.push(iterationCount - 1);
-    return quadraticLength.apply(void 0, tslib.__spreadArray([], tslib.__read(left), false)) + quadraticLength.apply(void 0, tslib.__spreadArray([], tslib.__read(right), false));
+  if (iterationCount === 0) {
+    return (distance(x1, y1, x2, y2) + distance(x2, y2, x3, y3) + distance(x1, y1, x3, y3)) / 2;
+  }
+  var quadratics = divideQuadratic(x1, y1, x2, y2, x3, y3, 0.5);
+  var left = quadratics[0];
+  var right = quadratics[1];
+  left.push(iterationCount - 1);
+  right.push(iterationCount - 1);
+  return quadraticLength.apply(void 0, _toConsumableArray(left)) + quadraticLength.apply(void 0, _toConsumableArray(right));
 }
 function box(x1, y1, x2, y2, x3, y3) {
-    var xExtrema = extrema(x1, x2, x3)[0];
-    var yExtrema = extrema(y1, y2, y3)[0];
-    // 控制点不加入 box 的计算
-    var xArr = [x1, x3];
-    var yArr = [y1, y3];
-    if (xExtrema !== undefined) {
-        xArr.push(quadraticAt(x1, x2, x3, xExtrema));
-    }
-    if (yExtrema !== undefined) {
-        yArr.push(quadraticAt(y1, y2, y3, yExtrema));
-    }
-    return getBBoxByArray(xArr, yArr);
+  var xExtrema = extrema(x1, x2, x3)[0];
+  var yExtrema = extrema(y1, y2, y3)[0];
+  // 控制点不加入 box 的计算
+  var xArr = [x1, x3];
+  var yArr = [y1, y3];
+  if (xExtrema !== undefined) {
+    xArr.push(quadraticAt(x1, x2, x3, xExtrema));
+  }
+  if (yExtrema !== undefined) {
+    yArr.push(quadraticAt(y1, y2, y3, yExtrema));
+  }
+  return getBBoxByArray(xArr, yArr);
 }
 function length(x1, y1, x2, y2, x3, y3) {
-    return quadraticLength(x1, y1, x2, y2, x3, y3, 3);
+  return quadraticLength(x1, y1, x2, y2, x3, y3, 3);
 }
 function nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0) {
-    return nearestPoint$2([x1, x2, x3], [y1, y2, y3], x0, y0, quadraticAt);
+  return nearestPoint$2([x1, x2, x3], [y1, y2, y3], x0, y0, quadraticAt);
 }
 function pointDistance(x1, y1, x2, y2, x3, y3, x0, y0) {
-    var point = nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0);
-    return distance(point.x, point.y, x0, y0);
+  var point = nearestPoint(x1, y1, x2, y2, x3, y3, x0, y0);
+  return distance(point.x, point.y, x0, y0);
 }
@@ -686,0 +684,0 @@

dist/index.umd.min.js

@@ -1,2 +0,10 @@
-!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t(((n="undefined"!=typeof globalThis?globalThis:n||self).G=n.G||{},n.G.Math={}))}(this,(function(n){"use strict";function t(n,t){var r="function"==typeof Symbol&&n[Symbol.iterator];if(!r)return n;var a,o,e=r.call(n),u=[];try{for(;(void 0===t||t-- >0)&&!(a=e.next()).done;)u.push(a.value)}catch(n){o={error:n}}finally{try{a&&!a.done&&(r=e.return)&&r.call(e)}finally{if(o)throw o.error}}return u}function r(n,t,r){if(r||2===arguments.length)for(var a,o=0,e=t.length;e>o;o++)!a&&o in t||(a||(a=Array.prototype.slice.call(t,0,o)),a[o]=t[o]);return n.concat(a||Array.prototype.slice.call(t))}function a(n,t,r,a){var o=n-r,e=t-a;return Math.sqrt(o*o+e*e)}function o(n,a){var o=Math.min.apply(Math,r([],t(n),!1)),e=Math.min.apply(Math,r([],t(a),!1));return{x:o,y:e,width:Math.max.apply(Math,r([],t(n),!1))-o,height:Math.max.apply(Math,r([],t(a),!1))-e}}function e(n){return(n+2*Math.PI)%(2*Math.PI)}function u(n,t){var r=Math.abs(n);return t>0?r:-1*r}function i(n,t,r,a,o,e){return r*Math.cos(o)*Math.cos(e)-a*Math.sin(o)*Math.sin(e)+n}function h(n,t,r,a,o,e){return r*Math.sin(o)*Math.cos(e)+a*Math.cos(o)*Math.sin(e)+t}function c(n,t,r){return{x:n*Math.cos(r),y:t*Math.sin(r)}}function f(n,t,r){var a=Math.cos(r),o=Math.sin(r);return[n*a-t*o,n*o+t*a]}var l=1e-5;function s(n,t,r){return void 0===r&&(r=l),r>Math.abs(n-t)}var v,p="undefined"!=typeof Float32Array?Float32Array:Array;Math.hypot||(Math.hypot=function(){for(var n=0,t=arguments.length;t--;)n+=arguments[t]*arguments[t];return Math.sqrt(n)}),v=new p(2),p!=Float32Array&&(v[0]=0,v[1]=0);var y=1e-4;function M(n,o,e,u,i,h){var c=-1,f=1/0,l=[e,u],s=20;h&&h>200&&(s=h/10);for(var v=1/s,p=v/10,M=0;s>=M;M++){var g=M*v,x=[i.apply(void 0,r([],t(n.concat([g])),!1)),i.apply(void 0,r([],t(o.concat([g])),!1))];f>(m=a(l[0],l[1],x[0],x[1]))&&(c=g,f=m)}if(0===c)return{x:n[0],y:o[0]};if(1===c){var d=n.length;return{x:n[d-1],y:o[d-1]}}f=1/0;for(M=0;32>M&&y<=p;M++){var P=c-p,b=c+p,m=(x=[i.apply(void 0,r([],t(n.concat([P])),!1)),i.apply(void 0,r([],t(o.concat([P])),!1))],a(l[0],l[1],x[0],x[1]));if(P>=0&&f>m)c=P,f=m;else{var A=[i.apply(void 0,r([],t(n.concat([b])),!1)),i.apply(void 0,r([],t(o.concat([b])),!1))],I=a(l[0],l[1],A[0],A[1]);1>=b&&f>I?(c=b,f=I):p*=.5}}return{x:i.apply(void 0,r([],t(n.concat([c])),!1)),y:i.apply(void 0,r([],t(o.concat([c])),!1))}}function g(n,t,r,a,o){return{x:(1-o)*n+o*r,y:(1-o)*t+o*a}}function x(n,t,r,o,e,u){var i=(r-n)*(e-n)+(o-t)*(u-t);return 0>i?a(n,t,e,u):i>(r-n)*(r-n)+(o-t)*(o-t)?a(r,o,e,u):d(n,t,r,o,e,u)}function d(n,t,r,a,o,e){var u=[r-n,a-t];if(function(n,t){return n[0]===t[0]&&n[1]===t[1]}(u,[0,0]))return Math.sqrt((o-n)*(o-n)+(e-t)*(e-t));var i=[-u[1],u[0]];return function(n,t){var r=t[0],a=t[1],o=r*r+a*a;o>0&&(o=1/Math.sqrt(o)),n[0]=t[0]*o,n[1]=t[1]*o}(i,i),Math.abs(function(n,t){return n[0]*t[0]+n[1]*t[1]}([o-n,e-t],i))}function P(n,t,r,a,o){var e=1-o;return e*e*e*n+3*t*o*e*e+3*r*o*o*e+a*o*o*o}function b(n,t,r,a,o){var e=1-o;return 3*(e*e*(t-n)+2*e*o*(r-t)+o*o*(a-r))}function m(n,t,r,a){var o,e,u,i=-3*n+9*t-9*r+3*a,h=6*n-12*t+6*r,c=3*t-3*n,f=[];if(s(i,0))s(h,0)||0>(o=-c/h)||o>1||f.push(o);else{var l=h*h-4*i*c;s(l,0)?f.push(-h/(2*i)):l>0&&(e=(-h-(u=Math.sqrt(l)))/(2*i),0>(o=(-h+u)/(2*i))||o>1||f.push(o),0>e||e>1||f.push(e))}return f}function A(n,o,e,u,i,h,c,f,l){if(0===l)return function(n,t){for(var r=0,o=n.length,e=0;o>e;e++)r+=a(n[e],t[e],n[(e+1)%o],t[(e+1)%o]);return r/2}([n,e,i,c],[o,u,h,f]);var s=function(n,t,r,a,o,e,u,i,h){var c=P(n,r,o,u,h),f=P(t,a,e,i,h),l=g(n,t,r,a,h),s=g(r,a,o,e,h),v=g(o,e,u,i,h),p=g(l.x,l.y,s.x,s.y,h),y=g(s.x,s.y,v.x,v.y,h);return[[n,t,l.x,l.y,p.x,p.y,c,f],[c,f,y.x,y.y,v.x,v.y,u,i]]}(n,o,e,u,i,h,c,f,.5),v=r(r([],t(s[0]),!1),[l-1],!1),p=r(r([],t(s[1]),!1),[l-1],!1);return A.apply(void 0,r([],t(v),!1))+A.apply(void 0,r([],t(p),!1))}function I(n,t,r,a,o,e,u,i,h,c,f){return M([n,r,o,u],[t,a,e,i],h,c,P,f)}function q(n){for(var t=0,r=[],o=0;n.length-1>o;o++){var e=n[o],u=n[o+1],i=a(e[0],e[1],u[0],u[1]);r.push({from:e,to:u,length:i}),t+=i}return{segments:r,totalLength:t}}function L(n){if(2>n.length)return 0;for(var t=0,r=0;n.length-1>r;r++){var o=n[r],e=n[r+1];t+=a(o[0],o[1],e[0],e[1])}return t}function T(n,t){if(t>1||0>t||2>n.length)return null;var r=q(n),a=r.segments,o=r.totalLength;if(0===o)return{x:n[0][0],y:n[0][1]};for(var e=0,u=null,i=0;a.length>i;i++){var h=a[i],c=h.from,f=h.to,l=h.length/o;if(t>=e&&e+l>=t){u=g(c[0],c[1],f[0],f[1],(t-e)/l);break}e+=l}return u}function w(n,t){if(t>1||0>t||2>n.length)return 0;for(var r=q(n),a=r.segments,o=r.totalLength,e=0,u=0,i=0;a.length>i;i++){var h=a[i],c=h.from,f=h.to,l=h.length/o;if(t>=e&&e+l>=t){u=Math.atan2(f[1]-c[1],f[0]-c[0]);break}e+=l}return u}function B(n,t,r){for(var a=1/0,o=0;n.length-1>o;o++){var e=n[o],u=n[o+1],i=x(e[0],e[1],u[0],u[1],t,r);a>i&&(a=i)}return a}function D(n){for(var t=[],r=[],a=0;n.length>a;a++){var e=n[a];t.push(e[0]),r.push(e[1])}return o(t,r)}function F(n){var t=n.slice(0);return n.length&&t.push(n[0]),t}function G(n,t,r,a){var o=1-a;return o*o*n+2*a*o*t+a*a*r}function N(n,t,r){var a=n+r-2*t;if(s(a,0))return[.5];var o=(n-t)/a;return o>1||0>o?[]:[o]}function k(n,o,e,u,i,h,c){if(0===c)return(a(n,o,e,u)+a(e,u,i,h)+a(n,o,i,h))/2;var f=function(n,t,r,a,o,e,u){var i=G(n,r,o,u),h=G(t,a,e,u),c=g(n,t,r,a,u),f=g(r,a,o,e,u);return[[n,t,c.x,c.y,i,h],[i,h,f.x,f.y,o,e]]}(n,o,e,u,i,h,.5),l=f[0],s=f[1];return l.push(c-1),s.push(c-1),k.apply(void 0,r([],t(l),!1))+k.apply(void 0,r([],t(s),!1))}function S(n,t,r,a,o,e,u,i){return M([n,r,o],[t,a,e],u,i,G)}n.arcBox=function(n,t,r,a,o,e,u){for(var c=function(n,t,r){return Math.atan(-t/n*Math.tan(r))}(r,a,o),f=1/0,l=-1/0,s=[e,u],v=2*-Math.PI;2*Math.PI>=v;v+=Math.PI){var p=c+v;u>e?p>e&&u>p&&s.push(p):p>u&&e>p&&s.push(p)}for(v=0;s.length>v;v++){var y=i(n,0,r,a,o,s[v]);f>y&&(f=y),y>l&&(l=y)}var M=function(n,t,r){return Math.atan(t/(n*Math.tan(r)))}(r,a,o),g=1/0,x=-1/0,d=[e,u];for(v=2*-Math.PI;2*Math.PI>=v;v+=Math.PI){var P=M+v;u>e?P>e&&u>P&&d.push(P):P>u&&e>P&&d.push(P)}for(v=0;d.length>v;v++){var b=h(0,t,r,a,o,d[v]);g>b&&(g=b),b>x&&(x=b)}return{x:f,y:g,width:l-f,height:x-g}},n.arcNearestPoint=function(n,r,a,o,e,i,h,l,s){var v=t(f(l-n,s-r,-e),2),p=function(n,t,r,a,o,e){var i=r,h=a;if(0===i||0===h)return{x:n,y:t};for(var c=o-n,f=e-t,l=Math.abs(c),s=Math.abs(f),v=i*i,p=h*h,y=Math.PI/4,M=0,g=0,x=0;4>x;x++){M=i*Math.cos(y),g=h*Math.sin(y);var d=(v-p)*Math.pow(Math.cos(y),3)/i,P=(p-v)*Math.pow(Math.sin(y),3)/h,b=M-d,m=g-P,A=l-d,I=s-P,q=Math.hypot(m,b),L=Math.hypot(I,A);y=Math.min(Math.PI/2,Math.max(0,y+=q*Math.asin((b*I-m*A)/(q*L))/Math.sqrt(v+p-M*M-g*g)))}return{x:n+u(M,c),y:t+u(g,f)}}(0,0,a,o,v[0],v[1]),y=function(n,t,r,a){return(Math.atan2(a*n,r*t)+2*Math.PI)%(2*Math.PI)}(a,o,p.x,p.y);i>y?p=c(a,o,i):y>h&&(p=c(a,o,h));var M=f(p.x,p.y,e);return{x:M[0]+n,y:M[1]+r}},n.arcTangentAngle=function(n,t,r,a,o,u,i,h){var c=(i-u)*h+u,f=function(n,t,r,a,o,e,u,i){return-1*r*Math.cos(o)*Math.sin(i)-a*Math.sin(o)*Math.cos(i)}(0,0,r,a,o,0,0,c),l=function(n,t,r,a,o,e,u,i){return-1*r*Math.sin(o)*Math.sin(i)+a*Math.cos(o)*Math.cos(i)}(0,0,r,a,o,0,0,c);return e(Math.atan2(l,f))},n.cubicBox=function(n,t,r,a,e,u,i,h){for(var c=[n,i],f=[t,h],l=m(n,r,e,i),s=m(t,a,u,h),v=0;l.length>v;v++)c.push(P(n,r,e,i,l[v]));for(v=0;s.length>v;v++)f.push(P(t,a,u,h,s[v]));return o(c,f)},n.cubicLength=function(n,t,r,a,o,e,u,i){return A(n,t,r,a,o,e,u,i,3)},n.cubicNearestPoint=I,n.cubicPointAt=function(n,t,r,a,o,e,u,i,h){return{x:P(n,r,o,u,h),y:P(t,a,e,i,h)}},n.cubicPointDistance=function(n,t,r,o,e,u,i,h,c,f,l){var s=I(n,t,r,o,e,u,i,h,c,f,l);return a(s.x,s.y,c,f)},n.cubicTangentAngle=function(n,t,r,a,o,u,i,h,c){var f=b(n,r,o,i,c),l=b(t,a,u,h,c);return e(Math.atan2(l,f))},n.distance=a,n.lineBox=function(n,t,r,a){return o([n,r],[t,a])},n.lineLength=function(n,t,r,o){return a(n,t,r,o)},n.linePointAt=g,n.linePointDistance=x,n.linePointToLine=d,n.lineTangentAngle=function(n,t,r,a){return Math.atan2(a-t,r-n)},n.polygonBox=function(n){return D(n)},n.polygonLength=function(n){return L(F(n))},n.polygonPointAt=function(n,t){return T(F(n),t)},n.polygonPointDistance=function(n,t,r){return B(F(n),t,r)},n.polygonTangentAngle=function(n,t){return w(F(n),t)},n.polylineBox=D,n.polylineLength=function(n){return L(n)},n.polylinePointAt=function(n,t){return T(n,t)},n.polylinePointDistance=function(n,t,r){return B(n,t,r)},n.polylineTangentAngle=function(n,t){return w(n,t)},n.quadBox=function(n,t,r,a,e,u){var i=N(n,r,e)[0],h=N(t,a,u)[0],c=[n,e],f=[t,u];return void 0!==i&&c.push(G(n,r,e,i)),void 0!==h&&f.push(G(t,a,u,h)),o(c,f)},n.quadLength=function(n,t,r,a,o,e){return k(n,t,r,a,o,e,3)},n.quadNearestPoint=S,n.quadPointDistance=function(n,t,r,o,e,u,i,h){var c=S(n,t,r,o,e,u,i,h);return a(c.x,c.y,i,h)}}));
+/*!
+ * @antv/g-math
+ * @description Geometry util
+ * @version 3.0.1
+ * @date 5/9/2025, 8:18:51 AM
+ * @author AntVis
+ * @docs https://g.antv.antgroup.com/
+ */
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(((t="undefined"!=typeof globalThis?globalThis:t||self).G=t.G||{},t.G.Math={}))}(this,(function(t){"use strict";function n(t,n){(null==n||n>t.length)&&(n=t.length);for(var r=0,a=Array(n);n>r;r++)a[r]=t[r];return a}function r(t,r){if(t){if("string"==typeof t)return n(t,r);var a={}.toString.call(t).slice(8,-1);return"Object"===a&&t.constructor&&(a=t.constructor.name),"Map"===a||"Set"===a?Array.from(t):"Arguments"===a||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a)?n(t,r):void 0}}function a(t,n){return function(t){if(Array.isArray(t))return t}(t)||function(t,n){var r=null==t?null:"undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(null!=r){var a,e,o,u,i=[],c=!0,f=!1;try{if(o=(r=r.call(t)).next,0===n){if(Object(r)!==r)return;c=!1}else for(;!(c=(a=o.call(r)).done)&&(i.push(a.value),i.length!==n);c=!0);}catch(t){f=!0,e=t}finally{try{if(!c&&null!=r.return&&(u=r.return(),Object(u)!==u))return}finally{if(f)throw e}}return i}}(t,n)||r(t,n)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function e(t){return function(t){if(Array.isArray(t))return n(t)}(t)||function(t){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)}(t)||r(t)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(t,n,r,a){var e=t-r,o=n-a;return Math.sqrt(e*e+o*o)}function u(t,n){var r=Math.min.apply(Math,e(t)),a=Math.min.apply(Math,e(n));return{x:r,y:a,width:Math.max.apply(Math,e(t))-r,height:Math.max.apply(Math,e(n))-a}}function i(t){return(t+2*Math.PI)%(2*Math.PI)}function c(t,n){var r=Math.abs(t);return n>0?r:-1*r}function f(t,n,r,a,e,o){return r*Math.cos(e)*Math.cos(o)-a*Math.sin(e)*Math.sin(o)+t}function h(t,n,r,a,e,o){return r*Math.sin(e)*Math.cos(o)+a*Math.cos(e)*Math.sin(o)+n}function l(t,n,r){return{x:t*Math.cos(r),y:n*Math.sin(r)}}function s(t,n,r){var a=Math.cos(r),e=Math.sin(r);return[t*a-n*e,t*e+n*a]}function y(t,n,r){return void 0===r&&(r=1e-5),t===n||r>Math.abs(t-n)}var v,p="undefined"!=typeof Float32Array?Float32Array:Array;Math.hypot||(Math.hypot=function(){for(var t=0,n=arguments.length;n--;)t+=arguments[n]*arguments[n];return Math.sqrt(t)}),v=new p(2),p!=Float32Array&&(v[0]=0,v[1]=0);function M(t,n,r,a,u,i){var c=-1,f=1/0,h=[r,a],l=20;i&&i>200&&(l=i/10);for(var s=1/l,y=s/10,v=0;l>=v;v++){var p=v*s,M=[u.apply(void 0,e(t.concat([p]))),u.apply(void 0,e(n.concat([p])))],g=o(h[0],h[1],M[0],M[1]);f>g&&(c=p,f=g)}if(0===c)return{x:t[0],y:n[0]};if(1===c){var d=t.length;return{x:t[d-1],y:n[d-1]}}f=1/0;for(var x=0;32>x&&1e-4<=y;x++){var b=c-y,m=c+y,P=[u.apply(void 0,e(t.concat([b]))),u.apply(void 0,e(n.concat([b])))],A=o(h[0],h[1],P[0],P[1]);if(b>=0&&f>A)c=b,f=A;else{var I=[u.apply(void 0,e(t.concat([m]))),u.apply(void 0,e(n.concat([m])))],q=o(h[0],h[1],I[0],I[1]);1>=m&&f>q?(c=m,f=q):y*=.5}}return{x:u.apply(void 0,e(t.concat([c]))),y:u.apply(void 0,e(n.concat([c])))}}function g(t,n,r,a,e){return{x:(1-e)*t+e*r,y:(1-e)*n+e*a}}function d(t,n,r,a,e,u){var i=(r-t)*(e-t)+(a-n)*(u-n);return 0>i?o(t,n,e,u):i>(r-t)*(r-t)+(a-n)*(a-n)?o(r,a,e,u):x(t,n,r,a,e,u)}function x(t,n,r,a,e,o){var u=[r-t,a-n];if(function(t,n){return t[0]===n[0]&&t[1]===n[1]}(u,[0,0]))return Math.sqrt((e-t)*(e-t)+(o-n)*(o-n));var i=[-u[1],u[0]];return function(t,n){var r=n[0],a=n[1],e=r*r+a*a;e>0&&(e=1/Math.sqrt(e)),t[0]=n[0]*e,t[1]=n[1]*e}(i,i),Math.abs(function(t,n){return t[0]*n[0]+t[1]*n[1]}([e-t,o-n],i))}function b(t,n,r,a,e){var o=1-e;return o*o*o*t+3*n*e*o*o+3*r*e*e*o+a*e*e*e}function m(t,n,r,a,e){var o=1-e;return 3*(o*o*(n-t)+2*o*e*(r-n)+e*e*(a-r))}function P(t,n,r,a){var e,o,u,i=-3*t+9*n-9*r+3*a,c=6*t-12*n+6*r,f=3*n-3*t,h=[];if(y(i,0))y(c,0)||0>(e=-f/c)||e>1||h.push(e);else{var l=c*c-4*i*f;y(l,0)?h.push(-c/(2*i)):l>0&&(o=(-c-(u=Math.sqrt(l)))/(2*i),0>(e=(-c+u)/(2*i))||e>1||h.push(e),0>o||o>1||h.push(o))}return h}function A(t,n,r,a,u,i,c,f,h){if(0===h)return function(t,n){for(var r=0,a=t.length,e=0;a>e;e++)r+=o(t[e],n[e],t[(e+1)%a],n[(e+1)%a]);return r/2}([t,r,u,c],[n,a,i,f]);var l=function(t,n,r,a,e,o,u,i,c){var f=b(t,r,e,u,c),h=b(n,a,o,i,c),l=g(t,n,r,a,c),s=g(r,a,e,o,c),y=g(e,o,u,i,c),v=g(l.x,l.y,s.x,s.y,c),p=g(s.x,s.y,y.x,y.y,c);return[[t,n,l.x,l.y,v.x,v.y,f,h],[f,h,p.x,p.y,y.x,y.y,u,i]]}(t,n,r,a,u,i,c,f,.5),s=[].concat(e(l[0]),[h-1]),y=[].concat(e(l[1]),[h-1]);return A.apply(void 0,e(s))+A.apply(void 0,e(y))}function I(t,n,r,a,e,o,u,i,c,f,h){return M([t,r,e,u],[n,a,o,i],c,f,b,h)}function q(t){for(var n=0,r=[],a=0;t.length-1>a;a++){var e=t[a],u=t[a+1],i=o(e[0],e[1],u[0],u[1]);r.push({from:e,to:u,length:i}),n+=i}return{segments:r,totalLength:n}}function w(t){if(2>t.length)return 0;for(var n=0,r=0;t.length-1>r;r++){var a=t[r],e=t[r+1];n+=o(a[0],a[1],e[0],e[1])}return n}function T(t,n){if(n>1||0>n||2>t.length)return null;var r=q(t),a=r.segments,e=r.totalLength;if(0===e)return{x:t[0][0],y:t[0][1]};for(var o=0,u=null,i=0;a.length>i;i++){var c=a[i],f=c.from,h=c.to,l=c.length/e;if(n>=o&&o+l>=n){u=g(f[0],f[1],h[0],h[1],(n-o)/l);break}o+=l}return u}function L(t,n){if(n>1||0>n||2>t.length)return 0;for(var r=q(t),a=r.segments,e=r.totalLength,o=0,u=0,i=0;a.length>i;i++){var c=a[i],f=c.from,h=c.to,l=c.length/e;if(n>=o&&o+l>=n){u=Math.atan2(h[1]-f[1],h[0]-f[0]);break}o+=l}return u}function S(t,n,r){for(var a=1/0,e=0;t.length-1>e;e++){var o=t[e],u=t[e+1],i=d(o[0],o[1],u[0],u[1],n,r);a>i&&(a=i)}return a}function j(t){for(var n=[],r=[],a=0;t.length>a;a++){var e=t[a];n.push(e[0]),r.push(e[1])}return u(n,r)}function B(t){var n=t.slice(0);return t.length&&n.push(t[0]),n}function D(t,n,r,a){var e=1-a;return e*e*t+2*a*e*n+a*a*r}function F(t,n,r){var a=t+r-2*n;if(y(a,0))return[.5];var e=(t-n)/a;return e>1||0>e?[]:[e]}function G(t,n,r,a,u,i,c){if(0===c)return(o(t,n,r,a)+o(r,a,u,i)+o(t,n,u,i))/2;var f=function(t,n,r,a,e,o,u){var i=D(t,r,e,u),c=D(n,a,o,u),f=g(t,n,r,a,u),h=g(r,a,e,o,u);return[[t,n,f.x,f.y,i,c],[i,c,h.x,h.y,e,o]]}(t,n,r,a,u,i,.5),h=f[0],l=f[1];return h.push(c-1),l.push(c-1),G.apply(void 0,e(h))+G.apply(void 0,e(l))}function N(t,n,r,a,e,o,u,i){return M([t,r,e],[n,a,o],u,i,D)}t.arcBox=function(t,n,r,a,e,o,u){for(var i=function(t,n,r){return Math.atan(-n/t*Math.tan(r))}(r,a,e),c=1/0,l=-1/0,s=[o,u],y=2*-Math.PI;2*Math.PI>=y;y+=Math.PI){var v=i+y;u>o?v>o&&u>v&&s.push(v):v>u&&o>v&&s.push(v)}for(var p=0;s.length>p;p++){var M=f(t,0,r,a,e,s[p]);c>M&&(c=M),M>l&&(l=M)}for(var g=function(t,n,r){return Math.atan(n/(t*Math.tan(r)))}(r,a,e),d=1/0,x=-1/0,b=[o,u],m=2*-Math.PI;2*Math.PI>=m;m+=Math.PI){var P=g+m;u>o?P>o&&u>P&&b.push(P):P>u&&o>P&&b.push(P)}for(var A=0;b.length>A;A++){var I=h(0,n,r,a,e,b[A]);d>I&&(d=I),I>x&&(x=I)}return{x:c,y:d,width:l-c,height:x-d}},t.arcNearestPoint=function(t,n,r,e,o,u,i,f,h){var y=a(s(f-t,h-n,-o),2),v=function(t,n,r,a,e,o){var u=r,i=a;if(0===u||0===i)return{x:t,y:n};for(var f=e-t,h=o-n,l=Math.abs(f),s=Math.abs(h),y=u*u,v=i*i,p=Math.PI/4,M=0,g=0,d=0;4>d;d++){M=u*Math.cos(p),g=i*Math.sin(p);var x=(y-v)*Math.pow(Math.cos(p),3)/u,b=(v-y)*Math.pow(Math.sin(p),3)/i,m=M-x,P=g-b,A=l-x,I=s-b,q=Math.hypot(P,m),w=Math.hypot(I,A);p=Math.min(Math.PI/2,Math.max(0,p+=q*Math.asin((m*I-P*A)/(q*w))/Math.sqrt(y+v-M*M-g*g)))}return{x:t+c(M,f),y:n+c(g,h)}}(0,0,r,e,y[0],y[1]),p=function(t,n,r,a){return(Math.atan2(a*t,r*n)+2*Math.PI)%(2*Math.PI)}(r,e,v.x,v.y);u>p?v=l(r,e,u):p>i&&(v=l(r,e,i));var M=s(v.x,v.y,o);return{x:M[0]+t,y:M[1]+n}},t.arcTangentAngle=function(t,n,r,a,e,o,u,c){var f=(u-o)*c+o,h=function(t,n,r,a,e,o,u,i){return-1*r*Math.cos(e)*Math.sin(i)-a*Math.sin(e)*Math.cos(i)}(0,0,r,a,e,0,0,f),l=function(t,n,r,a,e,o,u,i){return-1*r*Math.sin(e)*Math.sin(i)+a*Math.cos(e)*Math.cos(i)}(0,0,r,a,e,0,0,f);return i(Math.atan2(l,h))},t.cubicBox=function(t,n,r,a,e,o,i,c){for(var f=[t,i],h=[n,c],l=P(t,r,e,i),s=P(n,a,o,c),y=0;l.length>y;y++)f.push(b(t,r,e,i,l[y]));for(var v=0;s.length>v;v++)h.push(b(n,a,o,c,s[v]));return u(f,h)},t.cubicLength=function(t,n,r,a,e,o,u,i){return A(t,n,r,a,e,o,u,i,3)},t.cubicNearestPoint=I,t.cubicPointAt=function(t,n,r,a,e,o,u,i,c){return{x:b(t,r,e,u,c),y:b(n,a,o,i,c)}},t.cubicPointDistance=function(t,n,r,a,e,u,i,c,f,h,l){var s=I(t,n,r,a,e,u,i,c,f,h,l);return o(s.x,s.y,f,h)},t.cubicTangentAngle=function(t,n,r,a,e,o,u,c,f){var h=m(t,r,e,u,f),l=m(n,a,o,c,f);return i(Math.atan2(l,h))},t.distance=o,t.lineBox=function(t,n,r,a){return u([t,r],[n,a])},t.lineLength=function(t,n,r,a){return o(t,n,r,a)},t.linePointAt=g,t.linePointDistance=d,t.linePointToLine=x,t.lineTangentAngle=function(t,n,r,a){return Math.atan2(a-n,r-t)},t.polygonBox=function(t){return j(t)},t.polygonLength=function(t){return w(B(t))},t.polygonPointAt=function(t,n){return T(B(t),n)},t.polygonPointDistance=function(t,n,r){return S(B(t),n,r)},t.polygonTangentAngle=function(t,n){return L(B(t),n)},t.polylineBox=j,t.polylineLength=function(t){return w(t)},t.polylinePointAt=function(t,n){return T(t,n)},t.polylinePointDistance=function(t,n,r){return S(t,n,r)},t.polylineTangentAngle=function(t,n){return L(t,n)},t.quadBox=function(t,n,r,a,e,o){var i=F(t,r,e)[0],c=F(n,a,o)[0],f=[t,e],h=[n,o];return void 0!==i&&f.push(D(t,r,e,i)),void 0!==c&&h.push(D(n,a,o,c)),u(f,h)},t.quadLength=function(t,n,r,a,e,o){return G(t,n,r,a,e,o,3)},t.quadNearestPoint=N,t.quadPointDistance=function(t,n,r,a,e,u,i,c){var f=N(t,n,r,a,e,u,i,c);return o(f.x,f.y,i,c)}}));
 //# sourceMappingURL=index.umd.min.js.map

package.json

 {
   "name": "@antv/g-math",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Geometry util",
@@ -20,3 +20,3 @@ "keywords": [
   "exports": {
-    "types": "./dist/index.d.ts",
+    "types": "./types/index.d.ts",
     "import": "./dist/index.esm.js",
@@ -28,6 +28,7 @@ "default": "./dist/index.js"
   "module": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
+  "types": "types/index.d.ts",
   "files": [
     "package.json",
     "dist",
+    "types",
     "LICENSE",
@@ -38,2 +39,3 @@ "README.md"
     "@antv/util": "^3.3.5",
+    "@babel/runtime": "^7.25.6",
     "gl-matrix": "^3.4.3",
@@ -47,3 +49,4 @@ "tslib": "^2.5.3"
   "scripts": {
-    "build": "npm run clean && rollup -c",
+    "build:types": "tsc --emitDeclarationOnly --noCheck",
+    "build": "npm run clean && npm run build:types && rollup -c",
     "clean": "rimraf dist",
@@ -50,0 +53,0 @@ "sync": "tnpm sync",

dist/arc.d.ts

-import type { BBox, Point } from './types';
-export declare function box(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number): BBox;
-export declare function nearestPoint(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, x0: number, y0: number): {
-    x: number;
-    y: number;
-};
-export declare function pointDistance(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, x0: number, y0: number): number;
-export declare function pointAt(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, t: number): Point;
-export declare function tangentAngle(cx: number, cy: number, rx: number, ry: number, xRotation: number, startAngle: number, endAngle: number, t: number): number;

dist/bezier.d.ts

-import type { Point } from './types';
-/**
- * 使用牛顿切割法求最近的点
- * @param {number[]} xArr      点的 x 数组
- * @param {number[]} yArr      点的 y 数组
- * @param {number}   x         指定的点 x
- * @param {number}   y         指定的点 y
- * @param {Function} tCallback 差值函数
- */
-export declare function nearestPoint(xArr: number[], yArr: number[], x: number, y: number, tCallback: (...arr: number[]) => number, length?: number): Point;
-export declare function snapLength(xArr: number[], yArr: number[]): number;

dist/cubic.d.ts

-import type { Point } from './types';
-export declare function box(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): import("./types").BBox;
-export declare function length(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): number;
-export declare function nearestPoint(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, x0: number, y0: number, length?: number): Point;
-export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, x0: number, y0: number, length?: number): number;
-export declare function pointAt(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): Point;
-export declare function divide(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): [number, number, number, number, number, number, number, number][];
-export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, t: number): number;

dist/ellipse.d.ts

-import type { BBox, Point } from './types';
-export declare function box(x: number, y: number, rx: number, ry: number): BBox;
-export declare function length(x: number, y: number, rx: number, ry: number): number;
-export declare function nearestPoint(x: number, y: number, rx: number, ry: number, x0: number, y0: number): {
-    x: number;
-    y: number;
-};
-export declare function pointDistance(x: number, y: number, rx: number, ry: number, x0: number, y0: number): number;
-export declare function pointAt(x: number, y: number, rx: number, ry: number, t: number): Point;
-export declare function tangentAngle(x: number, y: number, rx: number, ry: number, t: number): number;

dist/index.d.ts

-import { box as arcBox, nearestPoint as arcNearestPoint, tangentAngle as arcTangentAngle } from './arc';
-import { box as cubicBox, length as cubicLength, nearestPoint as cubicNearestPoint, pointAt as cubicPointAt, pointDistance as cubicPointDistance, tangentAngle as cubicTangentAngle } from './cubic';
-import { box as lineBox, length as lineLength, pointAt as linePointAt, pointDistance as linePointDistance, pointToLine as linePointToLine, tangentAngle as lineTangentAngle } from './line';
-import { box as polygonBox, length as polygonLength, pointAt as polygonPointAt, pointDistance as polygonPointDistance, tangentAngle as polygonTangentAngle } from './polygon';
-import { box as polylineBox, length as polylineLength, pointAt as polylinePointAt, pointDistance as polylinePointDistance, tangentAngle as polylineTangentAngle } from './polyline';
-import { box as quadBox, length as quadLength, nearestPoint as quadNearestPoint, pointDistance as quadPointDistance } from './quadratic';
-import { distance } from './util';
-export { distance, quadBox, quadLength, quadPointDistance, quadNearestPoint, cubicBox, cubicLength, cubicNearestPoint, cubicPointDistance, cubicPointAt, cubicTangentAngle, polygonBox, polygonLength, polygonPointDistance, polygonPointAt, polygonTangentAngle, polylineBox, polylineLength, polylinePointDistance, polylinePointAt, polylineTangentAngle, lineBox, lineLength, linePointDistance, linePointAt, linePointToLine, lineTangentAngle, arcBox, arcTangentAngle, arcNearestPoint, };

dist/line.d.ts

-import type { BBox, Point } from './types';
-export declare function box(x1: number, y1: number, x2: number, y2: number): BBox;
-export declare function length(x1: number, y1: number, x2: number, y2: number): number;
-export declare function pointAt(x1: number, y1: number, x2: number, y2: number, t: number): Point;
-export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x: number, y: number): number;
-export declare function pointToLine(x1: number, y1: number, x2: number, y2: number, x: number, y: number): number;
-export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number): number;

dist/polygon.d.ts

-import type { PointTuple } from './types';
-export declare function box(points: PointTuple[]): import("./types").BBox;
-export declare function length(points: PointTuple[]): number;
-export declare function pointAt(points: PointTuple[], t: number): import("./types").Point;
-export declare function pointDistance(points: PointTuple[], x: number, y: number): number;
-export declare function tangentAngle(points: PointTuple[], t: number): number;

dist/polyline.d.ts

-import type { BBox, PointTuple } from './types';
-export declare function box(points: PointTuple[]): BBox;
-export declare function length(points: PointTuple[]): number;
-export declare function pointAt(points: PointTuple[], t: number): import("./types").Point;
-export declare function pointDistance(points: PointTuple[], x: number, y: number): number;
-export declare function tangentAngle(points: PointTuple[], t: number): number;

dist/quadratic.d.ts

-import type { Point } from './types';
-export declare function box(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): import("./types").BBox;
-export declare function length(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number;
-export declare function nearestPoint(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0: number, y0: number): Point;
-export declare function pointDistance(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0: number, y0: number): number;
-export declare function pointAt(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): Point;
-export declare function divide(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): number[][];
-export declare function tangentAngle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): number;

dist/segments.d.ts

-import type { Point, PointTuple } from './types';
-export declare function lengthOfSegment(points: PointTuple[]): number;
-/**
- * 按照比例在数据片段中获取点
- * @param {array} points 点的集合
- * @param {number} t 百分比 0-1
- * @return {object} 点的坐标
- */
-export declare function pointAtSegments(points: PointTuple[], t: number): Point | null;
-/**
- * 按照比例在数据片段中获取切线的角度
- * @param {array} points 点的集合
- * @param {number} t 百分比 0-1
- */
-export declare function angleAtSegments(points: PointTuple[], t: number): number;
-export declare function distanceAtSegment(points: PointTuple[], x: number, y: number): number;

dist/types.d.ts

-/**
- * 点（元组表示）
- */
-export type PointTuple = [number, number];
-/**
- * 点（对象表示）
- */
-export type Point = {
-    x: number;
-    y: number;
-};
-/**
- * 包围盒
- */
-export type BBox = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-/**
- * 一条线段
- */
-export type Segment = {
-    from: PointTuple;
-    to: PointTuple;
-    length: number;
-};

dist/util.d.ts

-import type { BBox } from './types';
-export declare function distance(x1: number, y1: number, x2: number, y2: number): number;
-export declare function getBBoxByArray(xArr: number[], yArr: number[]): BBox;
-export declare function getBBoxRange(x1: number, y1: number, x2: number, y2: number): {
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: number;
-};
-export declare function piMod(angle: number): number;

New alerts

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

274066

52.34%

Number of package files

33

57.14%

Worsened metrics

Dependency count

4

33.33%

Lines of code

1507

-1.76%

Number of medium supply chain risk alerts

1

Infinity%

Dependency changes

• + Added

  @babel/runtime@^7.25.6

• + Added

  @babel/runtime@7.28.6
  (transitive)