brepjs 18.123.0 → 18.124.0

package/dist/{shapeTypes-D9TjxkdO.cjs → shapeTypes-DZKuRt24.cjs}

@@ -11770,7 +11770,7 @@ function meshVertices(shape) {
 function spinePath(spine, segments) {
 	const shape = asShape$1(spine);
 	const params = shape.node?.params;
-	const recorded = params?.["path"] ?? params?.["points"];
+	const recorded = params?.["path"] ?? params?.["points"] ?? params?.["ring"];
 	if (recorded && recorded.length >= 2) return recorded.map((p) => [
 		p[0],
 		p[1],
@@ -12117,12 +12117,21 @@ function makeSweepOps(module) {
 		}),
 		...sweepFamilyEntries(module),
 		draftPrism: (shape, face, _baseFace, height, angleDeg, fuse) => draftPrismOp(module, shape, face, height, angleDeg, fuse),
-		buildExtrusionLaw: (profile, length, endFactor) => ({
-			type: "extrusionLaw",
-			profile,
-			length,
-			endFactor
-		}),
+		buildExtrusionLaw: (profile, length, endFactor) => {
+			const law = {
+				type: "extrusionLaw",
+				profile,
+				length,
+				endFactor,
+				Trim: (first, last, _tol) => ({
+					...law,
+					trimFirst: first,
+					trimLast: last
+				}),
+				delete: () => {}
+			};
+			return law;
+		},
 		loftBatch: () => notImplemented("loftBatch"),
 		extrudeBatch: (entries) => entries.map((e) => extrudeOp(module, e.face, e.direction, e.length))
 	};
@@ -14598,6 +14607,320 @@ function makeRepairOps(_module) {
 //#endregion
 //#region src/kernel/manifold/kernel2dNative.ts
 var CHORD_TOL = .004;
+/**
+* Closest parameter on a native curve to (x, y), in that curve's own
+* parametrization: signed distance for a line, angle for a conic, [0,1] for a
+* bezier. Exact where the geometry allows it, and a bounded golden-section
+* search where it does not (general ellipse, bezier) — both of which are
+* unimodal in distance over a single arc, so the search cannot land on a
+* spurious local minimum.
+*/
+function closestParamOn(c, x, y) {
+	if (c.k === "line") {
+		const dx = c.p2[0] - c.p1[0];
+		const dy = c.p2[1] - c.p1[1];
+		const len = Math.hypot(dx, dy);
+		if (len === 0) return 0;
+		const t = ((x - c.p1[0]) * dx + (y - c.p1[1]) * dy) / len;
+		return Math.min(Math.max(t, 0), len);
+	}
+	if (c.k === "conic") {
+		const ru = Math.hypot(c.u[0], c.u[1]);
+		const rv = Math.hypot(c.v[0], c.v[1]);
+		if (Math.abs(ru - rv) < 1e-12 && Math.abs(c.u[0] * c.v[0] + c.u[1] * c.v[1]) < 1e-12) {
+			const px = x - c.c[0];
+			const py = y - c.c[1];
+			return clampToArc(Math.atan2((px * c.v[0] + py * c.v[1]) / (rv * rv || 1), (px * c.u[0] + py * c.u[1]) / (ru * ru || 1)), c.a0, c.a1);
+		}
+		return bracketedMin(c.a0, c.a1, (t) => distSqAt(c, t, x, y), stepsFor(c, CHORD_TOL));
+	}
+	return bracketedMin(0, 1, (t) => distSqAt(c, t, x, y), stepsFor(c, CHORD_TOL));
+}
+/**
+* Global minimum of f over [lo, hi].
+*
+* Distance to an eccentric ellipse or a cubic-or-higher bezier is NOT unimodal
+* — a point inside a flat ellipse has one minimum per end, and a self-nearing
+* bezier can have several. So scan coarsely for the best sample, then refine
+* only inside the bracket around it, which is unimodal by construction.
+*/
+function bracketedMin(lo, hi, f, steps) {
+	const N = Math.max(8, steps);
+	let bestI = 0;
+	let best = Infinity;
+	for (let i = 0; i <= N; i++) {
+		const v = f(lo + (hi - lo) * i / N);
+		if (v < best) {
+			best = v;
+			bestI = i;
+		}
+	}
+	return goldenMin(lo + (hi - lo) * Math.max(0, bestI - 1) / N, lo + (hi - lo) * Math.min(N, bestI + 1) / N, f);
+}
+/** Wrap an angle into [a0, a1] where possible, else clamp to the nearer end. */
+function clampToArc(a, a0, a1) {
+	if (a1 - a0 >= 2 * Math.PI - 1e-12) return a;
+	let t = a;
+	while (t < a0) t += 2 * Math.PI;
+	while (t > a0 + 2 * Math.PI) t -= 2 * Math.PI;
+	if (t <= a1) return t;
+	return t - a1 < a0 + 2 * Math.PI - t ? a1 : a0;
+}
+function distSqAt(c, t, x, y) {
+	const p = nativeAt(c, t);
+	const dx = p[0] - x;
+	const dy = p[1] - y;
+	return dx * dx + dy * dy;
+}
+function nativeAt(c, t) {
+	if (c.k === "line") {
+		const dx = c.p2[0] - c.p1[0];
+		const dy = c.p2[1] - c.p1[1];
+		const len = Math.hypot(dx, dy) || 1;
+		return [c.p1[0] + dx * t / len, c.p1[1] + dy * t / len];
+	}
+	if (c.k === "bezier") return bezierAt(c.pts, t);
+	return [c.c[0] + c.u[0] * Math.cos(t) + c.v[0] * Math.sin(t), c.c[1] + c.u[1] * Math.cos(t) + c.v[1] * Math.sin(t)];
+}
+/** Golden-section minimum of a unimodal f over [lo, hi]. */
+function goldenMin(lo, hi, f) {
+	const phi = (Math.sqrt(5) - 1) / 2;
+	let a = lo;
+	let b = hi;
+	let c1 = b - phi * (b - a);
+	let d1 = a + phi * (b - a);
+	for (let i = 0; i < 80 && b - a > 1e-12; i++) if (f(c1) < f(d1)) {
+		b = d1;
+		d1 = c1;
+		c1 = b - phi * (b - a);
+	} else {
+		a = c1;
+		c1 = d1;
+		d1 = a + phi * (b - a);
+	}
+	return (a + b) / 2;
+}
+/**
+* Curve-curve intersection over the shim's own polyline discretization.
+*
+* Manifold has no exact curve algebra, so candidate crossings come from
+* segment pairs and are then refined by alternating projection: each point is
+* projected onto the other curve until it stops moving. That converges to a
+* genuine crossing when the segments really cross, and to the closest approach
+* when they only nearly touch — which the tolerance check then rejects.
+*/
+function intersectNative(a, b, tol) {
+	const pa = sample(a);
+	const pb = sample(b);
+	const points = [];
+	const params = [];
+	for (let i = 0; i + 1 < pa.length; i++) for (let j = 0; j + 1 < pb.length; j++) {
+		const hit = segSeg(pa[i], pa[i + 1], pb[j], pb[j + 1]);
+		if (!hit) continue;
+		let p = hit;
+		for (let k = 0; k < 24; k++) {
+			const qa = nativeAt(a, closestParamOn(a, p[0], p[1]));
+			const qb = nativeAt(b, closestParamOn(b, qa[0], qa[1]));
+			const moved = Math.hypot(qb[0] - p[0], qb[1] - p[1]);
+			p = [(qa[0] + qb[0]) / 2, (qa[1] + qb[1]) / 2];
+			if (moved < 1e-12) break;
+		}
+		const ta = closestParamOn(a, p[0], p[1]);
+		const tb = closestParamOn(b, p[0], p[1]);
+		const d = sub2(nativeAt(a, ta), nativeAt(b, tb));
+		if (Math.hypot(d[0], d[1]) > Math.max(tol, 1e-7)) continue;
+		if (points.some((q) => Math.hypot(q[0] - p[0], q[1] - p[1]) <= Math.max(tol, 1e-9))) continue;
+		points.push(p);
+		params.push(ta);
+	}
+	return dropOverlapPoints(points, params, contactRuns(a, b, tol, points, params), tol);
+}
+/**
+* Spans of `a` that lie on `b` within tolerance.
+*
+* Coincident spans and tangential touches never register as segment crossings —
+* collinear chords are parallel, and a tangency grazes without passing through.
+* Walking a's parameter range finds both: a run with length is a common
+* segment, an isolated dip is a tangential point (appended to `points`).
+*/
+function contactRuns(a, b, tol, points, params) {
+	const { first, last } = nativeBounds(a);
+	const M = 192;
+	const on = [];
+	for (let i = 0; i <= M; i++) {
+		const p = nativeAt(a, first + (last - first) * i / M);
+		const tb = closestParamOn(b, p[0], p[1]);
+		on.push(Math.sqrt(distSqAt(b, tb, p[0], p[1])) <= Math.max(tol, 1e-9));
+	}
+	const segments = [];
+	let runStart = -1;
+	for (let i = 0; i <= 193; i++) {
+		const inside = i <= M && on[i] === true;
+		if (inside && runStart < 0) runStart = i;
+		if (inside || runStart < 0) continue;
+		const t0 = first + (last - first) * runStart / M;
+		const t1 = first + (last - first) * (i - 1) / M;
+		let physical = 0;
+		for (let k = runStart; k < i - 1; k++) {
+			const q0 = nativeAt(a, first + (last - first) * k / M);
+			const q1 = nativeAt(a, first + (last - first) * (k + 1) / M);
+			physical += Math.hypot(q1[0] - q0[0], q1[1] - q0[1]);
+		}
+		if (physical > Math.max(tol, CHORD_TOL)) segments.push(trimNative(a, t0, t1));
+		else {
+			const p = nativeAt(a, t0);
+			if (!points.some((q) => Math.hypot(q[0] - p[0], q[1] - p[1]) <= Math.max(tol, 1e-9))) {
+				points.push(p);
+				params.push(t0);
+			}
+		}
+		runStart = -1;
+	}
+	return segments;
+}
+/**
+* A coincident span makes the crossing search fire at every sampled chord pair
+* along it — 79 "intersections" for two identical circles. Those points are the
+* overlap, not isolated crossings, so drop any that land on a reported segment.
+*/
+function dropOverlapPoints(points, params, segments, tol) {
+	if (segments.length === 0) return {
+		points,
+		params,
+		segments
+	};
+	const keep = [];
+	for (let i = 0; i < points.length; i++) {
+		const p = points[i];
+		if (!segments.some((seg) => {
+			const t = closestParamOn(seg, p[0], p[1]);
+			return Math.sqrt(distSqAt(seg, t, p[0], p[1])) <= Math.max(tol, CHORD_TOL);
+		})) keep.push(i);
+	}
+	return {
+		points: keep.map((i) => points[i]),
+		params: keep.map((i) => params[i]),
+		segments
+	};
+}
+function sub2(a, b) {
+	return [a[0] - b[0], a[1] - b[1]];
+}
+/** Intersection point of two segments, or null when they do not cross. */
+function segSeg(p1, p2, p3, p4) {
+	const d1x = p2[0] - p1[0];
+	const d1y = p2[1] - p1[1];
+	const d2x = p4[0] - p3[0];
+	const d2y = p4[1] - p3[1];
+	const den = d1x * d2y - d1y * d2x;
+	if (Math.abs(den) < 1e-15) return null;
+	const t = ((p3[0] - p1[0]) * d2y - (p3[1] - p1[1]) * d2x) / den;
+	const u = ((p3[0] - p1[0]) * d1y - (p3[1] - p1[1]) * d1x) / den;
+	if (t < -1e-9 || t > 1.000000001 || u < -1e-9 || u > 1.000000001) return null;
+	return [p1[0] + d1x * t, p1[1] + d1y * t];
+}
+/**
+* How many parameter steps resolve `c` to within `tol`.
+*
+* A fixed step count is wrong at both ends: wasteful on a short line and blind
+* to a feature narrower than one interval on a long or wiggly curve. Deriving
+* it from the curve's own extent — control-polygon length for a bezier, arc
+* length for a conic — ties the resolution to the geometry and the caller's
+* tolerance, the same way conicSegments already does for discretization.
+*
+* This bounds the miss, it does not remove it: any sampling scheme can still
+* step over a feature narrower than its own interval. Exactly resolving that
+* needs polynomial root-finding on the distance function, which is a different
+* and much larger piece of machinery than this shim carries.
+*/
+function stepsFor(c, tol) {
+	const t = Math.max(tol, 1e-9);
+	if (c.k === "line") return 2;
+	let extent;
+	if (c.k === "conic") {
+		const r = Math.max(Math.hypot(c.u[0], c.u[1]), Math.hypot(c.v[0], c.v[1]));
+		extent = Math.abs(c.a1 - c.a0) * r;
+	} else {
+		extent = 0;
+		for (let i = 0; i + 1 < c.pts.length; i++) {
+			const a = c.pts[i];
+			const b = c.pts[i + 1];
+			extent += Math.hypot(b[0] - a[0], b[1] - a[1]);
+		}
+	}
+	return Math.min(2e4, Math.max(64, Math.ceil(2 * extent / t)));
+}
+/** Parameter range of a native curve, matching getCurve2dBounds. */
+function nativeBounds(c) {
+	if (c.k === "conic") return {
+		first: c.a0,
+		last: c.a1
+	};
+	if (c.k === "line") return {
+		first: 0,
+		last: Math.hypot(c.p2[0] - c.p1[0], c.p2[1] - c.p1[1])
+	};
+	return {
+		first: 0,
+		last: 1
+	};
+}
+/** Restrict a native curve to [from, to] in its own parametrization. */
+function trimNative(c, from, to) {
+	if (c.k === "conic") return {
+		...c,
+		a0: from,
+		a1: to
+	};
+	if (c.k === "line") {
+		const p1 = nativeAt(c, from);
+		const p2 = nativeAt(c, to);
+		return {
+			...c,
+			p1,
+			p2
+		};
+	}
+	const right = deCasteljauRight(c.pts, from);
+	const span = 1 - from;
+	const t2 = span <= 1e-15 ? 1 : (to - from) / span;
+	return {
+		...c,
+		pts: deCasteljauLeft(right, t2)
+	};
+}
+function deCasteljauLeft(pts, t) {
+	const out = [];
+	let cur = pts.map((p) => [p[0], p[1]]);
+	out.push(cur[0]);
+	while (cur.length > 1) {
+		const next = [];
+		for (let i = 0; i + 1 < cur.length; i++) {
+			const a = cur[i];
+			const b = cur[i + 1];
+			next.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+		}
+		cur = next;
+		out.push(cur[0]);
+	}
+	return out;
+}
+function deCasteljauRight(pts, t) {
+	const out = [];
+	let cur = pts.map((p) => [p[0], p[1]]);
+	out.push(cur[cur.length - 1]);
+	while (cur.length > 1) {
+		const next = [];
+		for (let i = 0; i + 1 < cur.length; i++) {
+			const a = cur[i];
+			const b = cur[i + 1];
+			next.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+		}
+		cur = next;
+		out.push(cur[cur.length - 1]);
+	}
+	return out.reverse();
+}
 function isNative(x) {
 	return !!x && typeof x === "object" && x.__nativeC2d === true;
 }
@@ -15159,14 +15482,62 @@ function makeNativeKernel2DOps(module, occt) {
 		},
 		makeBSpline2d: (points, options) => occtOr("makeBSpline2d").makeBSpline2d(points, options),
 		offsetCurve2d: (c, offset) => occtOr("offsetCurve2d").offsetCurve2d(toOcct(c), offset),
-		intersectCurves2d: (c1, c2, tol) => occtOr("intersectCurves2d").intersectCurves2d(toOcct(c1), toOcct(c2), tol),
-		projectPointOnCurve2d: (c, x, y) => occtOr("projectPointOnCurve2d").projectPointOnCurve2d(toOcct(c), x, y),
-		distanceBetweenCurves2d: (c1, c2, s1, e1, s2, e2) => occtOr("distanceBetweenCurves2d").distanceBetweenCurves2d(toOcct(c1), toOcct(c2), s1, e1, s2, e2),
+		intersectCurves2d: (c1, c2, tol) => {
+			if (!isNative(c1) || !isNative(c2)) return occtOr("intersectCurves2d").intersectCurves2d(toOcct(c1), toOcct(c2), tol);
+			const { points, segments } = intersectNative(asC(c1), asC(c2), tol);
+			return {
+				points: points.map((p) => [p[0], p[1]]),
+				segments
+			};
+		},
+		projectPointOnCurve2d: (c, x, y) => {
+			if (!isNative(c)) return occtOr("projectPointOnCurve2d").projectPointOnCurve2d(toOcct(c), x, y);
+			const n = asC(c);
+			const param = closestParamOn(n, x, y);
+			return {
+				param,
+				distance: Math.sqrt(distSqAt(n, param, x, y))
+			};
+		},
+		distanceBetweenCurves2d: (c1, c2, s1, e1, s2, e2) => {
+			if (!isNative(c1) || !isNative(c2)) return occtOr("distanceBetweenCurves2d").distanceBetweenCurves2d(toOcct(c1), toOcct(c2), s1, e1, s2, e2);
+			const a = asC(c1);
+			const b = asC(c2);
+			const N = 256;
+			let best = Infinity;
+			for (let i = 0; i <= N; i++) {
+				const p = nativeAt(a, s1 + (e1 - s1) * i / N);
+				const q = closestParamOn(b, p[0], p[1]);
+				best = Math.min(best, Math.sqrt(distSqAt(b, Math.min(Math.max(q, Math.min(s2, e2)), Math.max(s2, e2)), p[0], p[1])));
+			}
+			return best;
+		},
 		approximateCurve2dAsBSpline: (c, tol, cont, maxSeg) => occtOr("approximateCurve2dAsBSpline").approximateCurve2dAsBSpline(toOcct(c), tol, cont, maxSeg),
 		decomposeBSpline2dToBeziers: (c) => occtOr("decomposeBSpline2dToBeziers").decomposeBSpline2dToBeziers(toOcct(c)),
-		serializeCurve2d: (c) => occtOr("serializeCurve2d").serializeCurve2d(toOcct(c)),
-		deserializeCurve2d: (data) => occtOr("deserializeCurve2d").deserializeCurve2d(data),
-		splitCurve2d: (c, params) => occtOr("splitCurve2d").splitCurve2d(toOcct(c), params),
+		serializeCurve2d: (c) => isNative(c) ? JSON.stringify({
+			__nativeC2d: 1,
+			c: asC(c)
+		}) : occtOr("serializeCurve2d").serializeCurve2d(toOcct(c)),
+		deserializeCurve2d: (data) => {
+			if (data.startsWith("{\"__nativeC2d\"")) return {
+				__nativeC2d: true,
+				...JSON.parse(data).c
+			};
+			return occtOr("deserializeCurve2d").deserializeCurve2d(data);
+		},
+		splitCurve2d: (c, params) => {
+			if (!isNative(c)) return occtOr("splitCurve2d").splitCurve2d(toOcct(c), params);
+			const n = asC(c);
+			const { first, last } = nativeBounds(n);
+			const cuts = [
+				first,
+				...params.filter((t) => t > first && t < last).sort((a, b) => a - b),
+				last
+			];
+			const out = [];
+			for (let i = 0; i + 1 < cuts.length; i++) out.push(trimNative(n, cuts[i] ?? 0, cuts[i + 1] ?? 0));
+			return out;
+		},
 		getCurve2dEllipseData: (c) => occtOr("getCurve2dEllipseData").getCurve2dEllipseData(toOcct(c)),
 		getCurve2dBezierPoles: (c) => occtOr("getCurve2dBezierPoles").getCurve2dBezierPoles(toOcct(c)),
 		getCurve2dBezierDegree: (c) => occtOr("getCurve2dBezierDegree").getCurve2dBezierDegree(toOcct(c)),