brepjs 20.12.5 → 20.12.7

package/dist/{occtWasmAdapter-DeoeK2iJ.cjs → occtWasmAdapter-D3qerQTq.cjs}

@@ -296,9 +296,393 @@ function quickHull(inputPoints, tolerance) {
 		points
 	};
 }
+// src/kernel/bspline2dFit.ts
+/* v8 ignore file -- pure-math hot path for 2D curve ops; excluded from coverage for the
+same reason as geometry2d.ts (instrumentation overhead times out 2D-heavy tests). */
+function findSpan(U, p, n, u) {
+	if (u >= U[n + 1]) return n;
+	if (u <= U[p]) return p;
+	let low = p;
+	let high = n + 1;
+	let mid = low + high >> 1;
+	while (u < U[mid] || u >= U[mid + 1]) {
+		if (u < U[mid]) high = mid;
+		else low = mid;
+		mid = low + high >> 1;
+	}
+	return mid;
+}
+function basisFuns(U, span, u, p) {
+	const N = new Array(p + 1).fill(0);
+	const left = new Array(p + 1).fill(0);
+	const right = new Array(p + 1).fill(0);
+	N[0] = 1;
+	for (let j = 1; j <= p; j++) {
+		left[j] = u - U[span + 1 - j];
+		right[j] = U[span + j] - u;
+		let saved = 0;
+		for (let r = 0; r < j; r++) {
+			const denom = right[r + 1] + left[j - r];
+			const temp = denom === 0 ? 0 : N[r] / denom;
+			N[r] = saved + right[r + 1] * temp;
+			saved = left[j - r] * temp;
+		}
+		N[j] = saved;
+	}
+	return N;
+}
+function evaluateFull(U, poles, p, u) {
+	const span = findSpan(U, p, poles.length - 1, u);
+	const N = basisFuns(U, span, u, p);
+	let x = 0;
+	let y = 0;
+	for (let j = 0; j <= p; j++) {
+		const pole = poles[span - p + j];
+		x += N[j] * pole[0];
+		y += N[j] * pole[1];
+	}
+	return [x, y];
+}
+/**
+* Gaussian elimination without pivoting on a banded system. B-spline collocation
+* matrices are totally positive, so elimination in natural order is stable.
+*/
+function solveBanded(rows, rhs) {
+	const n = rows.length;
+	let kl = 0;
+	let ku = 0;
+	rows.forEach((row, k) => {
+		kl = Math.max(kl, k - row.start);
+		ku = Math.max(ku, row.start + row.vals.length - 1 - k);
+	});
+	const width = kl + ku + 1;
+	const band = rows.map((row, k) => {
+		const r = new Float64Array(width);
+		row.vals.forEach((v, j) => {
+			r[row.start + j - k + kl] = v;
+		});
+		return r;
+	});
+	const bx = rhs.map((q) => q[0]);
+	const by = rhs.map((q) => q[1]);
+	const at = (r, c) => band[r][c - r + kl];
+	for (let i = 0; i < n; i++) {
+		const pivot = at(i, i);
+		if (Math.abs(pivot) < 1e-300) throw new Error("interpolateBSpline2d: singular system");
+		for (let r = i + 1; r <= Math.min(n - 1, i + kl); r++) {
+			const f = at(r, i) / pivot;
+			if (f === 0) continue;
+			const rowR = band[r];
+			for (let c = i; c <= Math.min(n - 1, i + ku); c++) rowR[c - r + kl] = rowR[c - r + kl] - f * at(i, c);
+			bx[r] = bx[r] - f * bx[i];
+			by[r] = by[r] - f * by[i];
+		}
+	}
+	const out = new Array(n);
+	for (let i = n - 1; i >= 0; i--) {
+		let sx = bx[i];
+		let sy = by[i];
+		for (let c = i + 1; c <= Math.min(n - 1, i + ku); c++) {
+			const a = at(i, c);
+			sx -= a * out[c][0];
+			sy -= a * out[c][1];
+		}
+		const d = at(i, i);
+		out[i] = [sx / d, sy / d];
+	}
+	return out;
+}
+function chordLengthParams(points) {
+	const n = points.length - 1;
+	const d = [0];
+	for (let k = 1; k <= n; k++) {
+		const a = points[k - 1];
+		const b = points[k];
+		d.push(d[k - 1] + Math.hypot(b[0] - a[0], b[1] - a[1]));
+	}
+	const total = d[n];
+	if (total < 1e-300) return d.map((_, k) => k / n);
+	return d.map((v) => v / total);
+}
+function compressKnots(U) {
+	const knots = [];
+	const multiplicities = [];
+	for (const u of U) {
+		const last = knots.length - 1;
+		if (last >= 0 && u === knots[last]) multiplicities[last] = multiplicities[last] + 1;
+		else {
+			knots.push(u);
+			multiplicities.push(1);
+		}
+	}
+	return {
+		knots,
+		multiplicities
+	};
+}
+/**
+* Interpolate `points` with a clamped B-spline of `degree` (capped at
+* `points.length - 1`). `params` are the increasing curve parameters assigned to
+* the points, normalised to [0, 1]; chord length when omitted.
+*/
+function interpolateBSpline2d(points, degree = 3, params) {
+	const n = points.length - 1;
+	if (n < 1) throw new Error("interpolateBSpline2d: need at least 2 points");
+	const p = Math.max(1, Math.min(degree, n));
+	const ub = params ? [...params] : chordLengthParams(points);
+	const U = [];
+	for (let i = 0; i <= p; i++) U.push(0);
+	for (let j = 1; j <= n - p; j++) {
+		let sum = 0;
+		for (let i = j; i < j + p; i++) sum += ub[i];
+		U.push(sum / p);
+	}
+	for (let i = 0; i <= p; i++) U.push(1);
+	const poles = solveBanded(ub.map((u) => {
+		const span = findSpan(U, p, n, u);
+		return {
+			start: span - p,
+			vals: basisFuns(U, span, u, p)
+		};
+	}), points.map((q) => [q[0], q[1]]));
+	poles[0] = [points[0][0], points[0][1]];
+	poles[n] = [points[n][0], points[n][1]];
+	const { knots, multiplicities } = compressKnots(U);
+	return {
+		__bk2d: "bspline",
+		poles,
+		knots,
+		multiplicities,
+		degree: p,
+		isPeriodic: false
+	};
+}
+function fitPiece(evaluate, s0, s1, tolerance, degree, minSegments, maxSegments) {
+	let segments = Math.min(maxSegments, Math.max(2, minSegments));
+	for (;;) {
+		const params = [];
+		const points = [];
+		for (let i = 0; i <= segments; i++) {
+			const u = i / segments;
+			params.push(u);
+			points.push(evaluate(s0 + (s1 - s0) * u));
+		}
+		const curve = interpolateBSpline2d(points, degree, params);
+		if (segments >= maxSegments) return curve;
+		const U = [];
+		curve.knots.forEach((k, i) => {
+			for (let m = 0; m < (curve.multiplicities[i] ?? 1); m++) U.push(k);
+		});
+		let maxErr = 0;
+		for (let i = 0; i < segments && maxErr <= tolerance; i++) {
+			const u = (i + .5) / segments;
+			const [fx, fy] = evaluateFull(U, curve.poles, curve.degree, u);
+			const [tx, ty] = evaluate(s0 + (s1 - s0) * u);
+			maxErr = Math.max(maxErr, Math.hypot(fx - tx, fy - ty));
+		}
+		if (maxErr <= tolerance) return curve;
+		segments = Math.min(maxSegments, segments * 2);
+	}
+}
+/**
+* Concatenate clamped B-splines of one degree, each running over [0, 1], onto
+* the consecutive intervals of `cuts`. Joints are C0 (knot multiplicity =
+* degree); each piece starts on the pole the previous one ended on.
+*/
+function joinPieces(pieces, cuts) {
+	const p = pieces[0].degree;
+	const knots = [];
+	const multiplicities = [];
+	const poles = [];
+	pieces.forEach((piece, i) => {
+		const a = cuts[i];
+		const b = cuts[i + 1];
+		if (i === 0) {
+			knots.push(a);
+			multiplicities.push(p + 1);
+			poles.push(...piece.poles);
+		} else poles.push(...piece.poles.slice(1));
+		for (let j = 1; j < piece.knots.length - 1; j++) {
+			knots.push(a + piece.knots[j] * (b - a));
+			multiplicities.push(piece.multiplicities[j]);
+		}
+		knots.push(b);
+		multiplicities.push(i === pieces.length - 1 ? p + 1 : p);
+	});
+	return {
+		__bk2d: "bspline",
+		poles,
+		knots,
+		multiplicities,
+		degree: p,
+		isPeriodic: false
+	};
+}
+/**
+* Approximate the parametric curve `evaluate` over [s0, s1] by interpolating
+* uniformly spaced samples, doubling the sample count until the interpolant is
+* within `tolerance` of the curve at every mid-sample parameter (or the
+* segment cap is reached). With `breaks`, each piece between them is fitted
+* separately and the pieces are joined. The B-spline runs over [0, 1] in step
+* with s.
+*/
+function fitBSpline2d(evaluate, s0, s1, tolerance, options = {}) {
+	const degree = options.degree ?? 3;
+	const maxSegments = Math.max(2, options.maxSegments ?? 1024);
+	const lo = Math.min(s0, s1);
+	const hi = Math.max(s0, s1);
+	const margin = 1e-12 * (hi - lo);
+	const inner = [...new Set(options.breaks ?? [])].filter((b) => b > lo + margin && b < hi - margin).sort((a, b) => s0 <= s1 ? a - b : b - a);
+	if (!inner.length) return fitPiece(evaluate, s0, s1, tolerance, degree, options.minSegments ?? 8, maxSegments);
+	const cuts = [
+		s0,
+		...inner,
+		s1
+	];
+	return joinPieces(cuts.slice(1).map((end, i) => fitPiece(evaluate, cuts[i], end, tolerance, degree, Math.max(degree, 2), maxSegments)), cuts.map((c) => (c - s0) / (s1 - s0)));
+}
+function fullKnotVector(c) {
+	const U = [];
+	c.knots.forEach((k, i) => {
+		for (let m = 0; m < (c.multiplicities[i] ?? 1); m++) U.push(k);
+	});
+	return U;
+}
+/** The B-spline form of a Bezier; a B-spline is returned as is. */
+function asBSpline2d(c) {
+	if (c.__bk2d === "bspline") return c;
+	const degree = c.poles.length - 1;
+	return {
+		__bk2d: "bspline",
+		poles: c.poles.map(([x, y]) => [x, y]),
+		knots: [0, 1],
+		multiplicities: [degree + 1, degree + 1],
+		degree,
+		isPeriodic: false
+	};
+}
+/** Insert `u` once (Boehm, The NURBS Book A5.1 with r = 1). */
+function insertKnot(U, P, p, u) {
+	const n = P.length - 1;
+	const k = findSpan(U, p, n, u);
+	const Q = [];
+	for (let i = 0; i <= n + 1; i++) if (i <= k - p) Q.push(P[i]);
+	else if (i > k) Q.push(P[i - 1]);
+	else {
+		const alpha = (u - U[i]) / (U[i + p] - U[i]);
+		const a = P[i];
+		const b = P[i - 1];
+		Q.push([alpha * a[0] + (1 - alpha) * b[0], alpha * a[1] + (1 - alpha) * b[1]]);
+	}
+	return {
+		U: [
+			...U.slice(0, k + 1),
+			u,
+			...U.slice(k + 1)
+		],
+		P: Q
+	};
+}
+/**
+* The part of a clamped B-spline over [lo, hi] (inside its knot range, lo < hi)
+* as a clamped B-spline of its own, exact by knot insertion.
+*/
+function subBSpline2d(c, lo, hi) {
+	const p = c.degree;
+	let U = fullKnotVector(c);
+	let P = c.poles.map(([x, y]) => [x, y]);
+	const first = U[p];
+	const last = U[U.length - 1 - p];
+	const a = Math.min(last, Math.max(first, lo));
+	const b = Math.min(last, Math.max(first, hi));
+	for (const u of [a, b]) {
+		if (u <= first || u >= last) continue;
+		while (U.filter((k) => k === u).length < p) ({U, P} = insertKnot(U, P, p, u));
+	}
+	const kLo = a <= first ? p : U.lastIndexOf(a);
+	const kHi = b >= last ? U.length - 1 - p : U.indexOf(b);
+	const sub = [];
+	for (let i = 0; i <= p; i++) sub.push(a);
+	sub.push(...U.slice(kLo + 1, kHi));
+	for (let i = 0; i <= p; i++) sub.push(b);
+	const { knots, multiplicities } = compressKnots(sub);
+	return {
+		__bk2d: "bspline",
+		poles: P.slice(kLo - p, kHi),
+		knots,
+		multiplicities,
+		degree: p,
+		isPeriodic: false
+	};
+}
+/**
+* Bezier poles of every non-empty knot span (The NURBS Book A5.6). A malformed
+* knot vector yields the whole control polygon as one segment, which still
+* bounds the curve.
+*/
+function bezierSegments2d(c) {
+	const poles = c.poles;
+	const p = c.degree;
+	const U = fullKnotVector(c);
+	const m = poles.length - 1 + p + 1;
+	const clone = (pt) => [pt[0], pt[1]];
+	if (p < 1 || U.length !== m + 1) return [poles.map(clone)];
+	const segments = [];
+	let a = p;
+	let b = p + 1;
+	let segPoles = [];
+	for (let i = 0; i <= p; i++) segPoles[i] = clone(poles[i]);
+	let nextPoles = [];
+	while (b < m) {
+		const i0 = b;
+		while (b < m && U[b + 1] === U[b]) b++;
+		const mult = b - i0 + 1;
+		if (mult > p && b < m) return [poles.map(clone)];
+		if (mult < p) {
+			const numer = U[b] - U[a];
+			const alphas = [];
+			for (let j = p; j > mult; j--) alphas[j - mult - 1] = numer / (U[a + j] - U[a]);
+			const r = p - mult;
+			for (let j = 1; j <= r; j++) {
+				const save = r - j;
+				const s = mult + j;
+				for (let k = p; k >= s; k--) {
+					const alpha = alphas[k - s];
+					const cur = segPoles[k];
+					const prev = segPoles[k - 1];
+					segPoles[k] = [alpha * cur[0] + (1 - alpha) * prev[0], alpha * cur[1] + (1 - alpha) * prev[1]];
+				}
+				if (b < m) nextPoles[save] = clone(segPoles[p]);
+			}
+		}
+		segments.push(segPoles);
+		if (b < m) {
+			for (let i = p - mult; i <= p; i++) nextPoles[i] = clone(poles[b - p + i]);
+			segPoles = nextPoles;
+			nextPoles = [];
+			a = b;
+			b++;
+		}
+	}
+	return segments;
+}
 // src/kernel/geometry2d.ts
 /* v8 ignore file -- excluded from coverage reports; prevents V8 instrumentation
 overhead that causes 2D-heavy tests to timeout under coverage mode. */
+/**
+* Pure-TypeScript 2D geometry implementation for Kernel2DCapability.
+*
+* All 2D curves are represented as plain objects with a `type` discriminant
+* and `evaluate(t)` method. No WASM boundary crossing required.
+*
+* ADR-0006: Inline math here (distance, rotation, normalization, dot/cross
+* products) operates on curve struct fields, not Point2D tuples. The canonical
+* tuple-based functions live in src/utils/vec2d.ts. The struct-field patterns
+* are not worth converting to tuple form — the temporary array allocations
+* would degrade both readability and performance.
+*
+* @module
+*/
 function evaluateCurve2d$1(c, t) {
 	switch (c.__bk2d) {
 		case "line": return [c.ox + c.dx * t, c.oy + c.dy * t];
@@ -398,6 +782,79 @@ function curveTypeName(c) {
 		case "trimmed": return "TRIMMED_" + curveTypeName(c.basis);
 	}
 }
+/**
+* Collapse nested trimmed wrappers into a single trimmed curve over a
+* non-trimmed basis (or return the curve itself when it is not trimmed).
+* Evaluation is unchanged: both forms map t in [0, 1] to the same basis point.
+*/
+function flattenTrimmed(c) {
+	if (c.__bk2d !== "trimmed") return c;
+	const inner = flattenTrimmed(c.basis);
+	if (inner.__bk2d !== "trimmed") return c;
+	const span = inner.tEnd - inner.tStart;
+	return {
+		__bk2d: "trimmed",
+		basis: inner.basis,
+		tStart: inner.tStart + c.tStart * span,
+		tEnd: inner.tStart + c.tEnd * span
+	};
+}
+/** Basis parameter of the reversed basis that lands on the point at `u` of the original. */
+function reversedBasisParam(c, u) {
+	switch (c.__bk2d) {
+		case "circle":
+		case "ellipse": return -u;
+		default: {
+			const { first, last } = curveBounds(c);
+			return first + last - u;
+		}
+	}
+}
+/**
+* The same geometry traversed in the opposite direction (OCCT `Geom2d_Curve::Reversed`).
+* Trimmed curves keep an increasing trim range: the basis is reversed and the
+* range is remapped onto it.
+*/
+function reverseCurve2d$1(c) {
+	switch (c.__bk2d) {
+		case "line": return {
+			...c,
+			ox: c.ox + c.dx * c.len,
+			oy: c.oy + c.dy * c.len,
+			dx: -c.dx,
+			dy: -c.dy
+		};
+		case "circle":
+		case "ellipse": return {
+			...c,
+			sense: !c.sense
+		};
+		case "bezier": return {
+			...c,
+			poles: [...c.poles].reverse()
+		};
+		case "bspline": {
+			const lo = c.knots[0] ?? 0;
+			const hi = c.knots[c.knots.length - 1] ?? 1;
+			return {
+				...c,
+				poles: [...c.poles].reverse(),
+				knots: c.knots.map((k) => lo + hi - k).reverse(),
+				multiplicities: [...c.multiplicities].reverse()
+			};
+		}
+		case "trimmed": {
+			const flat = flattenTrimmed(c);
+			if (flat.__bk2d !== "trimmed") return reverseCurve2d$1(flat);
+			return {
+				__bk2d: "trimmed",
+				basis: reverseCurve2d$1(flat.basis),
+				tStart: reversedBasisParam(flat.basis, flat.tEnd),
+				tEnd: reversedBasisParam(flat.basis, flat.tStart)
+			};
+		}
+	}
+}
 function makeLine2d$1(x1, y1, x2, y2) {
 	const dx = x2 - x1;
 	const dy = y2 - y1;
@@ -630,7 +1087,8 @@ function scaleCurve2d$1(c, factor, cx, cy) {
 				cx: ncx,
 				cy: ncy,
 				majorRadius: c.majorRadius * Math.abs(factor),
-				minorRadius: c.minorRadius * Math.abs(factor)
+				minorRadius: c.minorRadius * Math.abs(factor),
+				xDirAngle: factor < 0 ? c.xDirAngle + Math.PI : c.xDirAngle
 			};
 		}
 		case "bezier": return {
@@ -641,10 +1099,31 @@ function scaleCurve2d$1(c, factor, cx, cy) {
 			...c,
 			poles: c.poles.map(([x, y]) => scalePoint(x, y))
 		};
-		case "trimmed": return {
-			...c,
-			basis: scaleCurve2d$1(c.basis, factor, cx, cy)
-		};
+		case "trimmed": {
+			const basis = scaleCurve2d$1(c.basis, factor, cx, cy);
+			if (basis.__bk2d === "line") {
+				const s = Math.abs(factor);
+				return {
+					...c,
+					basis,
+					tStart: c.tStart * s,
+					tEnd: c.tEnd * s
+				};
+			}
+			if (basis.__bk2d === "circle" && factor < 0) {
+				const shift = basis.sense ? Math.PI : -Math.PI;
+				return {
+					...c,
+					basis,
+					tStart: c.tStart + shift,
+					tEnd: c.tEnd + shift
+				};
+			}
+			return {
+				...c,
+				basis
+			};
+		}
 	}
 }
 function mirrorAtPoint(c, cx, cy) {
@@ -723,6 +1202,328 @@ function mirrorAcrossAxis(c, ox, oy, dx, dy) {
 		}
 	}
 }
+function applyAffine(m, x, y) {
+	return [m.a * x + m.b * y + m.tx, m.c * x + m.d * y + m.ty];
+}
+/**
+* Image of the conic C + M0 * (cos psi, sin psi), psi = sense ? t : -t.
+* The closed-form 2x2 SVD M = R(phi) * diag(sx, sy) * R(theta) gives the new
+* frame (phi), radii (sx, |sy|) and the angular shift (theta); sy < 0 means the
+* map reflects, which flips the sense.
+*/
+function affineConic(cx, cy, m0, sense, m) {
+	const [ncx, ncy] = applyAffine(m, cx, cy);
+	const m00 = m.a * m0[0] + m.b * m0[2];
+	const m01 = m.a * m0[1] + m.b * m0[3];
+	const m10 = m.c * m0[0] + m.d * m0[2];
+	const m11 = m.c * m0[1] + m.d * m0[3];
+	const e = (m00 + m11) / 2;
+	const f = (m00 - m11) / 2;
+	const g = (m10 + m01) / 2;
+	const h = (m10 - m01) / 2;
+	const q = Math.hypot(e, h);
+	const r = Math.hypot(f, g);
+	const sx = q + r;
+	const sy = q - r;
+	const a1 = Math.atan2(g, f);
+	const a2 = Math.atan2(h, e);
+	const theta = (a2 - a1) / 2;
+	const phi = (a2 + a1) / 2;
+	const newSense = sy < 0 ? !sense : sense;
+	const shift = sense ? theta : -theta;
+	if (Math.min(q, r) <= 1e-12 * Math.max(q, r)) {
+		const circleShift = shift + (newSense ? phi : -phi);
+		return {
+			curve: {
+				__bk2d: "circle",
+				cx: ncx,
+				cy: ncy,
+				radius: sx,
+				sense: newSense
+			},
+			mapParam: (u) => u + circleShift
+		};
+	}
+	return {
+		curve: {
+			__bk2d: "ellipse",
+			cx: ncx,
+			cy: ncy,
+			majorRadius: sx,
+			minorRadius: Math.abs(sy),
+			xDirAngle: phi,
+			sense: newSense
+		},
+		mapParam: (u) => u + shift
+	};
+}
+function affineBasis(c, m) {
+	switch (c.__bk2d) {
+		case "line": {
+			const ldx = m.a * c.dx + m.b * c.dy;
+			const ldy = m.c * c.dx + m.d * c.dy;
+			const speed = Math.hypot(ldx, ldy);
+			const [ox, oy] = applyAffine(m, c.ox, c.oy);
+			if (speed < 1e-300) return {
+				curve: {
+					...c,
+					ox,
+					oy,
+					len: 0
+				},
+				mapParam: () => 0
+			};
+			return {
+				curve: {
+					__bk2d: "line",
+					ox,
+					oy,
+					dx: ldx / speed,
+					dy: ldy / speed,
+					len: c.len * speed
+				},
+				mapParam: (u) => u * speed
+			};
+		}
+		case "circle": return affineConic(c.cx, c.cy, [
+			c.radius,
+			0,
+			0,
+			c.radius
+		], c.sense, m);
+		case "ellipse": {
+			const cos = Math.cos(c.xDirAngle);
+			const sin = Math.sin(c.xDirAngle);
+			const m0 = [
+				c.majorRadius * cos,
+				-c.minorRadius * sin,
+				c.majorRadius * sin,
+				c.minorRadius * cos
+			];
+			return affineConic(c.cx, c.cy, m0, c.sense, m);
+		}
+		case "bezier":
+		case "bspline": return {
+			curve: {
+				...c,
+				poles: c.poles.map(([x, y]) => applyAffine(m, x, y))
+			},
+			mapParam: (u) => u
+		};
+		case "trimmed": return {
+			curve: affineCurve2d(c, m),
+			mapParam: (u) => u
+		};
+	}
+}
+/**
+* Exact image of a curve under an affine map (OCCT `Geom2d_Curve::Transformed`
+* with a `gp_GTrsf2d`): lines stay lines, circles and ellipses become ellipses
+* (or circles), and pole-based curves map their poles.
+*/
+function affineCurve2d(c, m) {
+	const flat = flattenTrimmed(c);
+	if (flat.__bk2d !== "trimmed") return affineBasis(flat, m).curve;
+	const { curve, mapParam } = affineBasis(flat.basis, m);
+	return {
+		__bk2d: "trimmed",
+		basis: curve,
+		tStart: mapParam(flat.tStart),
+		tEnd: mapParam(flat.tEnd)
+	};
+}
+function unitTangent(c, t, first, last) {
+	let [tx, ty] = tangentCurve2d(c, t);
+	let len = Math.hypot(tx, ty);
+	for (let k = 1; len < 1e-12 && k <= 6; k++) {
+		const h = (last - first) * 10 ** (-9 + k);
+		[tx, ty] = tangentCurve2d(c, t + h <= Math.max(first, last) ? t + h : t - h);
+		len = Math.hypot(tx, ty);
+	}
+	return len < 1e-300 ? [1, 0] : [tx / len, ty / len];
+}
+function curveExtent(c) {
+	const box = createBBox2d();
+	addCurveToBBox(box, c, 0);
+	return Math.hypot(box.xMax - box.xMin, box.yMax - box.yMin);
+}
+/**
+* Parameters of `c`, in its own parameter range, at the interior knots of its
+* B-spline basis: where a fit of the curve (or of its offset) must sample.
+*/
+function curveKnotParams(c) {
+	const flat = flattenTrimmed(c);
+	const basis = flat.__bk2d === "trimmed" ? flat.basis : flat;
+	if (basis.__bk2d !== "bspline") return [];
+	const inner = basis.knots.slice(1, -1);
+	if (flat.__bk2d !== "trimmed") return inner;
+	const { tStart, tEnd } = flat;
+	return inner.filter((k) => k > Math.min(tStart, tEnd) && k < Math.max(tStart, tEnd)).map((k) => (k - tStart) / (tEnd - tStart));
+}
+/**
+* Offset `distance` to the right of the direction of travel (OCCT
+* `Geom2d_OffsetCurve`: a counter-clockwise circle grows). Lines and circles
+* are offset exactly; other curves are fitted within `tolerance` (by default
+* relative to the curve's size).
+*/
+function offsetCurve2d$1(c, distance, tolerance) {
+	const flat = flattenTrimmed(c);
+	const trimmed = flat.__bk2d === "trimmed" ? flat : null;
+	const basis = trimmed ? trimmed.basis : flat;
+	const d = trimmed && trimmed.tEnd < trimmed.tStart ? -distance : distance;
+	if (basis.__bk2d === "line") {
+		const shifted = {
+			...basis,
+			ox: basis.ox + basis.dy * d,
+			oy: basis.oy - basis.dx * d
+		};
+		return trimmed ? {
+			...trimmed,
+			basis: shifted
+		} : shifted;
+	}
+	if (basis.__bk2d === "circle") {
+		const radius = basis.radius + (basis.sense ? d : -d);
+		if (Math.abs(radius) <= 1e-12 * Math.max(1, basis.radius)) throw new Error("offsetCurve2d: the offset collapses the circle to its center");
+		const circle = {
+			...basis,
+			radius: Math.abs(radius)
+		};
+		if (!trimmed) return circle;
+		if (radius > 0) return {
+			...trimmed,
+			basis: circle
+		};
+		const shift = basis.sense ? Math.PI : -Math.PI;
+		return {
+			...trimmed,
+			basis: circle,
+			tStart: trimmed.tStart + shift,
+			tEnd: trimmed.tEnd + shift
+		};
+	}
+	const { first, last } = curveBounds(flat);
+	return fitBSpline2d((t) => {
+		const [px, py] = evaluateCurve2d$1(flat, t);
+		const [ux, uy] = unitTangent(flat, t, first, last);
+		return [px + uy * distance, py - ux * distance];
+	}, first, last, tolerance ?? 1e-9 * Math.max(1, curveExtent(flat) + Math.abs(distance)), { breaks: curveKnotParams(flat) });
+}
+function sampleCurve(c, from, to, n) {
+	const pts = [];
+	for (let i = 0; i <= n; i++) pts.push(evaluateCurve2d$1(c, from + (to - from) * i / n));
+	return pts;
+}
+/** Second derivative by central differences, kept inside [lo, hi] for clamped curves. */
+function secondDerivative(c, t, lo, hi) {
+	const h = 1e-4 * Math.max(hi - lo, 1e-9);
+	const mid = Math.min(hi - h, Math.max(lo + h, t));
+	const [ax, ay] = evaluateCurve2d$1(c, mid - h);
+	const [bx, by] = evaluateCurve2d$1(c, mid);
+	const [cx, cy] = evaluateCurve2d$1(c, mid + h);
+	return [(ax - 2 * bx + cx) / (h * h), (ay - 2 * by + cy) / (h * h)];
+}
+/**
+* Newton step for f(s, t) = |c1(s) - c2(t)|^2 / 2. The closest pair of two
+* disjoint curves has parallel tangents, so the curvature terms of the Hessian
+* are what make it converge; where the Hessian is not positive definite the
+* step falls back to Gauss-Newton, then to projecting c1(s) onto c2.
+*/
+function closestPairStep(c1, c2, s, t, box1, box2) {
+	const [px, py] = evaluateCurve2d$1(c1, s);
+	const [qx, qy] = evaluateCurve2d$1(c2, t);
+	const dx = px - qx;
+	const dy = py - qy;
+	const t1 = tangentCurve2d(c1, s);
+	const t2 = tangentCurve2d(c2, t);
+	const g1 = t1[0] * dx + t1[1] * dy;
+	const g2 = -(t2[0] * dx + t2[1] * dy);
+	const a11 = t1[0] * t1[0] + t1[1] * t1[1];
+	const a22 = t2[0] * t2[0] + t2[1] * t2[1];
+	const a12 = -(t1[0] * t2[0] + t1[1] * t2[1]);
+	const k1 = secondDerivative(c1, s, box1[0], box1[1]);
+	const k2 = secondDerivative(c2, t, box2[0], box2[1]);
+	const h11 = a11 + k1[0] * dx + k1[1] * dy;
+	const h22 = a22 - (k2[0] * dx + k2[1] * dy);
+	const detH = h11 * h22 - a12 * a12;
+	if (h11 > 0 && detH > 1e-12 * Math.abs(h11 * h22)) return [(-g1 * h22 + g2 * a12) / detH, (-g2 * h11 + g1 * a12) / detH];
+	const detGN = a11 * a22 - a12 * a12;
+	if (detGN > 1e-12 * a11 * a22) return [(-g1 * a22 + g2 * a12) / detGN, (-g2 * a11 + g1 * a12) / detGN];
+	if (a22 > 0) return [0, -g2 / a22];
+	return a11 > 0 ? [-g1 / a11, 0] : [0, 0];
+}
+/** Refine a seed pair, halving each step until it lowers the distance; returns the squared distance. */
+function refineClosestPair(c1, c2, seed, box1, box2) {
+	const clamp = (v, [lo, hi]) => Math.min(hi, Math.max(lo, v));
+	const distSq = (a, b) => {
+		const [px, py] = evaluateCurve2d$1(c1, a);
+		const [qx, qy] = evaluateCurve2d$1(c2, b);
+		return (px - qx) ** 2 + (py - qy) ** 2;
+	};
+	let [s, t] = seed;
+	let f = distSq(s, t);
+	for (let iter = 0; iter < 60 && f > 0; iter++) {
+		const [ds, dt] = closestPairStep(c1, c2, s, t, box1, box2);
+		let lambda = 1;
+		let ns = s;
+		let nt = t;
+		let nf = f;
+		for (; lambda > 1e-6 && nf >= f; lambda /= 2) {
+			ns = clamp(s + lambda * ds, box1);
+			nt = clamp(t + lambda * dt, box2);
+			nf = distSq(ns, nt);
+		}
+		if (nf >= f || ns === s && nt === t) break;
+		[s, t, f] = [
+			ns,
+			nt,
+			nf
+		];
+	}
+	return f;
+}
+/** Whether grid cell (i, j) is no larger than any of its eight neighbours. */
+function isGridMinimum(at, i, j, n) {
+	const d = at(i, j);
+	for (let ni = Math.max(0, i - 1); ni <= Math.min(n, i + 1); ni++) for (let nj = Math.max(0, j - 1); nj <= Math.min(n, j + 1); nj++) if (at(ni, nj) < d) return false;
+	return true;
+}
+/**
+* Minimum distance between c1 over [from1, to1] and c2 over [from2, to2]
+* (OCCT `Geom2dAPI_ExtremaCurveCurve`): every local minimum of a sampled
+* distance grid seeds a Gauss-Newton refinement.
+*/
+function distanceBetweenCurves2d$1(c1, c2, from1, to1, from2, to2) {
+	const n = 32;
+	const p1 = sampleCurve(c1, from1, to1, n);
+	const p2 = sampleCurve(c2, from2, to2, n);
+	const grid = /* @__PURE__ */ new Float64Array(1089);
+	for (let i = 0; i <= n; i++) for (let j = 0; j <= n; j++) {
+		const a = p1[i];
+		const b = p2[j];
+		grid[i * 33 + j] = (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2;
+	}
+	const at = (i, j) => grid[i * 33 + j] ?? Infinity;
+	const seeds = [];
+	let best = Infinity;
+	for (let i = 0; i <= n; i++) for (let j = 0; j <= n; j++) {
+		const d = at(i, j);
+		best = Math.min(best, d);
+		if (isGridMinimum(at, i, j, n)) seeds.push({
+			i,
+			j,
+			d
+		});
+	}
+	seeds.sort((x, y) => x.d - y.d);
+	const box1 = [Math.min(from1, to1), Math.max(from1, to1)];
+	const box2 = [Math.min(from2, to2), Math.max(from2, to2)];
+	for (const { i, j } of seeds.slice(0, 8)) {
+		const seed = [from1 + (to1 - from1) * i / n, from2 + (to2 - from2) * j / n];
+		best = Math.min(best, refineClosestPair(c1, c2, seed, box1, box2));
+	}
+	return Math.sqrt(best);
+}
 /**
 * Compute intersection points (and overlapping segments) between two 2D curves.
 * Handles analytic cases (line-line, line-circle, circle-circle) and falls back
@@ -740,10 +1541,7 @@ function intersectCurves2dFn(c1, c2, tolerance) {
 		points: intersectLineCircle(c2, b2, c1, b1, tolerance),
 		segments: []
 	};
-	if (b1.__bk2d === "circle" && b2.__bk2d === "circle") return {
-		points: intersectCircleCircle(c1, b1, c2, b2, tolerance),
-		segments: []
-	};
+	if (b1.__bk2d === "circle" && b2.__bk2d === "circle") return intersectCircleCircle(c1, b1, c2, b2, tolerance);
 	return numericalIntersect(c1, c2, tolerance, c1 === c2);
 }
 /** Unwrap trimmed wrappers to get the basis curve type. */
@@ -752,9 +1550,32 @@ function unwrapCurve(c) {
 	while (cur.__bk2d === "trimmed") cur = cur.basis;
 	return cur;
 }
-/** Check if parameter t is within the curve's domain. */
+/**
+* The interval a curve covers on its innermost basis's parameter. A trimmed wrapper's own
+* parameter runs 0..1, but the analytic solvers work on the unwrapped basis, so their
+* parameters must be bounded by this interval rather than by `curveBounds(c)`.
+*/
+function basisInterval(c) {
+	if (c.__bk2d !== "trimmed") return curveBounds(c);
+	const a = basisParam(c.basis, c.tStart);
+	const b = basisParam(c.basis, c.tEnd);
+	return {
+		first: Math.min(a, b),
+		last: Math.max(a, b)
+	};
+}
+function basisParam(c, t) {
+	let cur = c;
+	let s = t;
+	while (cur.__bk2d === "trimmed") {
+		s = cur.tStart + s * (cur.tEnd - cur.tStart);
+		cur = cur.basis;
+	}
+	return s;
+}
+/** Check if basis parameter t lies within the part of the basis that c covers. */
 function inDomain(c, t, tol) {
-	const b = curveBounds(c);
+	const b = basisInterval(c);
 	return t >= b.first - tol && t <= b.last + tol;
 }
 /** Find the parameter on curve c closest to point (px, py), searching near tGuess. */
@@ -830,7 +1651,7 @@ function intersectLineLine(c1, l1, c2, l2, tol) {
 		points: [],
 		segments: []
 	};
-	const b1 = curveBounds(c1);
+	const b1 = basisInterval(c1);
 	const b2 = curveBounds(c2);
 	const p2s = evaluateCurve2d$1(c2, b2.first);
 	const p2e = evaluateCurve2d$1(c2, b2.last);
@@ -871,42 +1692,83 @@ function intersectLineCircle(cLine, line, cCirc, circ, tol) {
 	}
 	return results;
 }
-function intersectConcentricArcs(c1, c2, tol) {
-	const b1 = curveBounds(c1);
-	const b2 = curveBounds(c2);
-	const isFullCircle1 = Math.abs(b1.last - b1.first - 2 * Math.PI) < 1e-10;
-	const isFullCircle2 = Math.abs(b2.last - b2.first - 2 * Math.PI) < 1e-10;
-	if (isFullCircle1 && isFullCircle2) return [];
-	if (isFullCircle1) return [evaluateCurve2d$1(c2, b2.first), evaluateCurve2d$1(c2, b2.last)];
-	if (isFullCircle2) return [evaluateCurve2d$1(c1, b1.first), evaluateCurve2d$1(c1, b1.last)];
-	const pts = [];
-	const checks = [
-		[c2, evaluateCurve2d$1(c1, b1.first)],
-		[c2, evaluateCurve2d$1(c1, b1.last)],
-		[c1, evaluateCurve2d$1(c2, b2.first)],
-		[c1, evaluateCurve2d$1(c2, b2.last)]
-	];
-	for (const [target, pt] of checks) {
-		const t = refineParam(target, pt[0], pt[1]);
-		if (t !== null) {
-			const [ex, ey] = evaluateCurve2d$1(target, t);
-			if ((ex - pt[0]) ** 2 + (ey - pt[1]) ** 2 < tol * tol * 100) pts.push(pt);
-		}
+/**
+* The counter-clockwise angular range [start, start + sweep] a circular curve covers,
+* and whether the curve itself runs counter-clockwise through it.
+*/
+function arcSpan(c, circ) {
+	const range = basisInterval(c);
+	const own = curveBounds(c);
+	const forward = basisParam(c, own.last) >= basisParam(c, own.first);
+	return {
+		start: circ.sense ? range.first : -range.last,
+		sweep: Math.min(range.last - range.first, 2 * Math.PI),
+		ccw: circ.sense === forward
+	};
+}
+/** The arc of `circ` from angle `from` counter-clockwise to `to`, traversed as `ccw` says. */
+function arcBetween(circ, from, to, ccw) {
+	const basis = makeCircle2d$1(circ.cx, circ.cy, circ.radius, ccw);
+	return ccw ? {
+		__bk2d: "trimmed",
+		basis,
+		tStart: from,
+		tEnd: to
+	} : {
+		__bk2d: "trimmed",
+		basis,
+		tStart: -to,
+		tEnd: -from
+	};
+}
+/**
+* Overlap of two arcs on the same circle: the shared stretches as segments oriented
+* along c1, and the places where the arcs only touch end to end as points.
+*/
+function intersectCoincidentArcs(c1, circ1, c2, circ2, tol) {
+	const turn = 2 * Math.PI;
+	const a = arcSpan(c1, circ1);
+	const b = arcSpan(c2, circ2);
+	const angleTol = tol / circ1.radius;
+	const isFull = (sweep) => turn - sweep <= angleTol;
+	const d = ((b.start - a.start) % turn + turn) % turn;
+	let windows;
+	if (isFull(b.sweep)) windows = [[0, a.sweep]];
+	else if (isFull(a.sweep)) windows = [[d, d + b.sweep]];
+	else windows = [[Math.max(0, d), Math.min(a.sweep, d + b.sweep)], [Math.max(0, d - turn), Math.min(a.sweep, d - turn + b.sweep)]];
+	const points = [];
+	const segments = [];
+	for (const [u, v] of windows) if (v - u > angleTol) segments.push(arcBetween(circ1, a.start + u, a.start + v, a.ccw));
+	else if (v - u > -angleTol) {
+		const angle = a.start + (u + v) / 2;
+		points.push([circ1.cx + circ1.radius * Math.cos(angle), circ1.cy + circ1.radius * Math.sin(angle)]);
 	}
-	const deduped = [];
-	for (const p of pts) if (!deduped.some(([ddx, ddy]) => (ddx - p[0]) ** 2 + (ddy - p[1]) ** 2 < tol * tol * 100)) deduped.push(p);
-	return deduped;
+	return {
+		points,
+		segments
+	};
 }
 function intersectCircleCircle(c1, circ1, c2, circ2, tol) {
 	const dx = circ2.cx - circ1.cx;
 	const dy = circ2.cy - circ1.cy;
 	const d = Math.sqrt(dx * dx + dy * dy);
+	if (d <= tol) {
+		if (Math.abs(circ1.radius - circ2.radius) > tol) return {
+			points: [],
+			segments: []
+		};
+		return intersectCoincidentArcs(c1, circ1, c2, circ2, tol);
+	}
+	return {
+		points: intersectCrossingCircles(c1, circ1, c2, circ2, tol, d),
+		segments: []
+	};
+}
+function intersectCrossingCircles(c1, circ1, c2, circ2, tol, d) {
+	const dx = circ2.cx - circ1.cx;
+	const dy = circ2.cy - circ1.cy;
 	if (d > circ1.radius + circ2.radius + tol) return [];
 	if (d < Math.abs(circ1.radius - circ2.radius) - tol) return [];
-	if (d < 1e-14) {
-		if (Math.abs(circ1.radius - circ2.radius) > tol) return [];
-		return intersectConcentricArcs(c1, c2, tol);
-	}
 	const a = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d * d) / (2 * d);
 	const h2 = circ1.radius * circ1.radius - a * a;
 	const h = Math.sqrt(Math.max(0, h2));
@@ -1046,61 +1908,136 @@ function createBBox2d() {
 		yMax: -Infinity
 	};
 }
-function addCurveToBBox(bbox, c, _tol) {
-	const basis = c.__bk2d === "trimmed" ? c.basis : c;
-	if (basis.__bk2d === "line") {
-		const bounds = curveBounds(c);
-		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-		const [x0, y0] = evaluateCurve2d$1(c, bounds.first);
-		const [x1, y1] = evaluateCurve2d$1(c, bounds.last);
-		bbox.xMin = Math.min(bbox.xMin, x0, x1);
-		bbox.yMin = Math.min(bbox.yMin, y0, y1);
-		bbox.xMax = Math.max(bbox.xMax, x0, x1);
-		bbox.yMax = Math.max(bbox.yMax, y0, y1);
-		return;
-	}
-	if (basis.__bk2d === "circle") {
-		const bounds = curveBounds(c);
-		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-		const { cx, cy, radius, sense } = basis;
-		const [x0, y0] = evaluateCurve2d$1(c, bounds.first);
-		const [x1, y1] = evaluateCurve2d$1(c, bounds.last);
-		let xMin = Math.min(x0, x1), xMax = Math.max(x0, x1);
-		let yMin = Math.min(y0, y1), yMax = Math.max(y0, y1);
-		const tStart = c.__bk2d === "trimmed" ? c.tStart : bounds.first;
-		const tEnd = c.__bk2d === "trimmed" ? c.tEnd : bounds.last;
-		for (let k = 0; k < 4; k++) {
-			const angle = k * Math.PI / 2;
-			const t = sense ? angle : -angle;
-			for (let wrap = 0; wrap <= 1; wrap++) {
-				const tt = t + wrap * 2 * Math.PI;
-				if (tt >= tStart - 1e-10 && tt <= tEnd + 1e-10) {
-					const ex = cx + radius * Math.cos(angle);
-					const ey = cy + radius * Math.sin(angle);
-					xMin = Math.min(xMin, ex);
-					xMax = Math.max(xMax, ex);
-					yMin = Math.min(yMin, ey);
-					yMax = Math.max(yMax, ey);
-					break;
-				}
-			}
-		}
-		bbox.xMin = Math.min(bbox.xMin, xMin);
-		bbox.yMin = Math.min(bbox.yMin, yMin);
-		bbox.xMax = Math.max(bbox.xMax, xMax);
-		bbox.yMax = Math.max(bbox.yMax, yMax);
+/** The first parameter congruent to `t` (mod 2*pi) inside [lo, hi], if any. */
+function periodicParamInRange(t, lo, hi) {
+	const period = 2 * Math.PI;
+	const tt = t + period * Math.ceil((lo - t) / period - 1e-12);
+	return tt <= hi + 1e-12 ? tt : null;
+}
+/**
+* Basis parameters where a conic reaches its axis-aligned extremes. For
+* C + a*cos(psi)*U + b*sin(psi)*V (U at angle phi), dx/dpsi = 0 at
+* tan(psi) = -b*sin(phi) / (a*cos(phi)) and dy/dpsi = 0 at
+* tan(psi) = b*cos(phi) / (a*sin(phi)), each plus pi.
+*/
+function conicExtremeParams(c) {
+	const [a, b, phi] = c.__bk2d === "circle" ? [
+		c.radius,
+		c.radius,
+		0
+	] : [
+		c.majorRadius,
+		c.minorRadius,
+		c.xDirAngle
+	];
+	const psiX = Math.atan2(-b * Math.sin(phi), a * Math.cos(phi));
+	const psiY = Math.atan2(b * Math.cos(phi), a * Math.sin(phi));
+	return [
+		psiX,
+		psiX + Math.PI,
+		psiY,
+		psiY + Math.PI
+	].map((psi) => c.sense ? psi : -psi);
+}
+function splitBezier1d(vals) {
+	const work = [...vals];
+	const n = work.length;
+	const left = [];
+	const right = [];
+	left.push(work[0]);
+	right.push(work[n - 1]);
+	for (let r = 1; r < n; r++) {
+		for (let i = 0; i < n - r; i++) work[i] = (work[i] + work[i + 1]) / 2;
+		left.push(work[0]);
+		right.push(work[n - 1 - r]);
+	}
+	return [left, right.reverse()];
+}
+/**
+* Widen `range` to the values a 1D Bezier takes. Its coefficients bound it
+* (convex hull), so a piece whose coefficients stay inside the range is done;
+* otherwise the piece is halved, adding the curve value at the split.
+*/
+function widenToBezier(vals, range, depth = 0) {
+	const lo = Math.min(...vals);
+	const hi = Math.max(...vals);
+	const tol = 1e-12 * (1 + Math.abs(range.min) + Math.abs(range.max));
+	if (lo >= range.min - tol && hi <= range.max + tol) return;
+	if (depth >= 60) {
+		range.min = Math.min(range.min, lo);
+		range.max = Math.max(range.max, hi);
 		return;
 	}
+	const [left, right] = splitBezier1d(vals);
+	const mid = right[0] ?? lo;
+	range.min = Math.min(range.min, mid);
+	range.max = Math.max(range.max, mid);
+	widenToBezier(left, range, depth + 1);
+	widenToBezier(right, range, depth + 1);
+}
+/** Add the exact extent of a Bezier or B-spline over [lo, hi], span by span. */
+function addPoleCurveExtent(bbox, c, lo, hi) {
+	const bs = asBSpline2d(c);
+	const first = bs.knots[0] ?? 0;
+	const last = bs.knots[bs.knots.length - 1] ?? 1;
+	const a = Math.max(first, lo);
+	const b = Math.min(last, hi);
+	if (b <= a) return;
+	const piece = a > first || b < last ? subBSpline2d(bs, a, b) : bs;
+	const x = {
+		min: bbox.xMin,
+		max: bbox.xMax
+	};
+	const y = {
+		min: bbox.yMin,
+		max: bbox.yMax
+	};
+	for (const seg of bezierSegments2d(piece)) for (const [range, axis] of [[x, 0], [y, 1]]) {
+		const vals = seg.map((pt) => pt[axis]);
+		const ends = [vals[0] ?? range.min, vals[vals.length - 1] ?? range.min];
+		range.min = Math.min(range.min, ...ends);
+		range.max = Math.max(range.max, ...ends);
+		widenToBezier(vals, range);
+	}
+	bbox.xMin = x.min;
+	bbox.xMax = x.max;
+	bbox.yMin = y.min;
+	bbox.yMax = y.max;
+}
+function addCurveToBBox(bbox, c, _tol) {
 	const bounds = curveBounds(c);
 	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-	const nSamples = 20;
-	const dt = (bounds.last - bounds.first) / nSamples;
-	for (let i = 0; i <= nSamples; i++) {
-		const [x, y] = evaluateCurve2d$1(c, bounds.first + i * dt);
-		if (x < bbox.xMin) bbox.xMin = x;
-		if (y < bbox.yMin) bbox.yMin = y;
-		if (x > bbox.xMax) bbox.xMax = x;
-		if (y > bbox.yMax) bbox.yMax = y;
+	const addPoint = ([x, y]) => {
+		bbox.xMin = Math.min(bbox.xMin, x);
+		bbox.yMin = Math.min(bbox.yMin, y);
+		bbox.xMax = Math.max(bbox.xMax, x);
+		bbox.yMax = Math.max(bbox.yMax, y);
+	};
+	addPoint(evaluateCurve2d$1(c, bounds.first));
+	addPoint(evaluateCurve2d$1(c, bounds.last));
+	const flat = flattenTrimmed(c);
+	const basis = flat.__bk2d === "trimmed" ? flat.basis : flat;
+	const basisBounds = curveBounds(basis);
+	const [from, to] = flat.__bk2d === "trimmed" ? [flat.tStart, flat.tEnd] : [basisBounds.first, basisBounds.last];
+	const lo = Math.min(from, to);
+	const hi = Math.max(from, to);
+	const add = (t) => {
+		addPoint(evaluateCurve2d$1(basis, t));
+	};
+	switch (basis.__bk2d) {
+		case "line": return;
+		case "circle":
+		case "ellipse":
+			for (const t of conicExtremeParams(basis)) {
+				const tt = periodicParamInRange(t, lo, hi);
+				if (tt !== null) add(tt);
+			}
+			return;
+		case "bezier":
+		case "bspline":
+			addPoleCurveExtent(bbox, basis, lo, hi);
+			return;
+		case "trimmed": return;
 	}
 }
 function evaluateBezier(poles, t) {
@@ -4255,26 +5192,13 @@ function makeBezier2d(points) {
 	return c2dWrap(makeBezier2d$1(points));
 }
 function makeBSpline2d(points, options) {
-	const poles = points;
-	const n = poles.length;
-	const degree = Math.max(1, Math.min(options?.degMax ?? 3, n - 1));
-	const knots = [0];
-	const mults = [degree + 1];
-	const nInternalKnots = n - degree - 1;
-	for (let i = 1; i <= nInternalKnots; i++) {
-		knots.push(i / (nInternalKnots + 1));
-		mults.push(1);
-	}
-	knots.push(1);
-	mults.push(degree + 1);
-	return c2dWrap({
-		__bk2d: "bspline",
-		poles,
-		knots,
-		multiplicities: mults,
-		degree,
-		isPeriodic: false
-	});
+	const pts = [];
+	for (const p of points) {
+		const prev = pts[pts.length - 1];
+		if (!prev || Math.hypot(p[0] - prev[0], p[1] - prev[1]) > 1e-12) pts.push([p[0], p[1]]);
+	}
+	if (pts.length < 2) throw new Error("occt-wasm: makeBSpline2d needs at least 2 distinct points");
+	return c2dWrap(interpolateBSpline2d(pts, options?.degMax ?? 3));
 }
 function evaluateCurve2d(curve, param) {
 	return evaluateCurve2d$1(c2d(curve), param);
@@ -4296,26 +5220,20 @@ function getCurve2dType(curve) {
 function trimCurve2d(curve, start, end) {
 	return c2dWrap({
 		__bk2d: "trimmed",
-		basis: c2d(curve),
+		basis: structuredClone(c2d(curve)),
 		tStart: start,
 		tEnd: end
 	});
 }
+function reverseCurve2d(curve) {
+	const c = c2d(curve);
+	Object.assign(c, reverseCurve2d$1(c));
+}
 function copyCurve2d(curve) {
 	return c2dWrap(JSON.parse(JSON.stringify(c2d(curve))));
 }
 function offsetCurve2d(curve, offset) {
-	const c = c2d(curve);
-	const bounds = curveBounds(c);
-	const pts = [];
-	for (let i = 0; i <= 20; i++) {
-		const t = bounds.first + (bounds.last - bounds.first) * i / 20;
-		const [px, py] = evaluateCurve2d$1(c, t);
-		const [tx, ty] = tangentCurve2d(c, t);
-		const len = Math.sqrt(tx * tx + ty * ty) || 1;
-		pts.push([px - ty / len * offset, py + tx / len * offset]);
-	}
-	return c2dWrap(makeBezier2d$1(pts.length <= 25 ? pts : pts.filter((_, i) => i % 2 === 0 || i === pts.length - 1)));
+	return c2dWrap(offsetCurve2d$1(c2d(curve), offset));
 }
 function translateCurve2d(curve, dx, dy) {
 	return c2dWrap(translateCurve2d$1(c2d(curve), dx, dy));
@@ -4335,8 +5253,7 @@ function mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
 /**
 * Directional affinity matching OCCT `gp_GTrsf2d::SetAffinity`: scales the
 * component perpendicular to the axis `(dx, dy)` through `(ox, oy)` by `ratio`,
-* leaving the parallel component fixed. Applied by sampling and refitting as a
-* Bezier, since occt-wasm has no native Geom2d transform.
+* leaving the parallel component fixed.
 */
 function affinityCurve2d(curve, ox, oy, dx, dy, ratio) {
 	const len = Math.sqrt(dx * dx + dy * dy);
@@ -4346,15 +5263,14 @@ function affinityCurve2d(curve, ox, oy, dx, dy, ratio) {
 	const a = 1 + k * px * px, b = k * px * py, d = k * py * px, e = 1 + k * py * py;
 	const tx = ox - a * ox - b * oy;
 	const ty = oy - d * ox - e * oy;
-	const c = c2d(curve);
-	const bounds = curveBounds(c);
-	const N = 20;
-	const pts = [];
-	for (let i = 0; i <= N; i++) {
-		const [qx, qy] = evaluateCurve2d$1(c, bounds.first + (bounds.last - bounds.first) * i / N);
-		pts.push([a * qx + b * qy + tx, d * qx + e * qy + ty]);
-	}
-	return c2dWrap(makeBezier2d$1(pts));
+	return c2dWrap(affineCurve2d(c2d(curve), {
+		a,
+		b,
+		c: d,
+		d: e,
+		tx,
+		ty
+	}));
 }
 function affinityTransform2d(curve, ox, oy, dx, dy, ratio) {
 	return affinityCurve2d(curve, ox, oy, dx, dy, ratio);
@@ -4499,103 +5415,46 @@ function projectPointOnCurve2d(curve, x, y) {
 	return projectOnBasis(c, bounds.first, bounds.last);
 }
 function distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
-	const n = 20;
-	let minDist = Infinity;
-	for (let i = 0; i <= n; i++) {
-		const t1 = p1Start + (p1End - p1Start) * (i / n);
-		const [x1, y1] = evaluateCurve2d$1(c2d(c1), t1);
-		for (let j = 0; j <= n; j++) {
-			const t2 = p2Start + (p2End - p2Start) * (j / n);
-			const [x2, y2] = evaluateCurve2d$1(c2d(c2), t2);
-			const d = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
-			if (d < minDist) minDist = d;
-		}
-	}
-	return minDist;
+	return distanceBetweenCurves2d$1(c2d(c1), c2d(c2), p1Start, p1End, p2Start, p2End);
 }
-function approximateCurve2dAsBSpline(curve, maxSegments) {
-	const cu = c2d(curve);
+/**
+* The exact B-spline of a Bezier or B-spline basis over its trim range, traversed
+* from `from` to `to`; null for an empty range.
+*/
+function trimmedPoleCurve(basis, from, to) {
+	if (from === to) return null;
+	const sub = subBSpline2d(asBSpline2d(basis), Math.min(from, to), Math.max(from, to));
+	if (from < to) return sub;
+	const reversed = reverseCurve2d$1(sub);
+	return reversed.__bk2d === "bspline" ? reversed : null;
+}
+/**
+* Degree <= 3 B-spline within `tolerance` of the curve (Geom2dConvert_ApproxCurve
+* with MaxDegree 3, as brepjs calls it); exact where the curve already is one.
+*/
+function approximateCurve2dAsBSpline(curve, tolerance, maxSegments) {
+	const cu = flattenTrimmed(c2d(curve));
+	const basis = cu.__bk2d === "trimmed" ? cu.basis : cu;
+	const poleCurve = basis.__bk2d === "bspline" || basis.__bk2d === "bezier" ? basis : null;
+	if (poleCurve && asBSpline2d(poleCurve).degree <= 3) {
+		if (cu.__bk2d !== "trimmed") return copyCurve2d(asBSpline2d(poleCurve));
+		const exact = trimmedPoleCurve(poleCurve, cu.tStart, cu.tEnd);
+		if (exact) return c2dWrap(exact);
+	}
+	if (cu.__bk2d === "line") return c2dWrap(asBSpline2d(makeBezier2d$1([evaluateCurve2d$1(cu, 0), evaluateCurve2d$1(cu, cu.len)])));
 	const bounds = curveBounds(cu);
-	const nPts = Math.min(Math.max(maxSegments + 1, 10), 100);
-	const poles = [];
-	for (let i = 0; i < nPts; i++) {
-		const t = bounds.first + (bounds.last - bounds.first) * i / (nPts - 1);
-		poles.push(evaluateCurve2d$1(cu, t));
-	}
-	const degree = Math.min(3, nPts - 1);
-	const n = poles.length;
-	const knots = [];
-	const mults = [];
-	const nInternalKnots = n - degree - 1;
-	knots.push(0);
-	mults.push(degree + 1);
-	for (let i = 1; i <= nInternalKnots; i++) {
-		knots.push(i / (nInternalKnots + 1));
-		mults.push(1);
-	}
-	knots.push(1);
-	mults.push(degree + 1);
-	return c2dWrap({
-		__bk2d: "bspline",
-		poles,
-		knots,
-		multiplicities: mults,
-		degree,
-		isPeriodic: false
-	});
+	return c2dWrap(fitBSpline2d((t) => evaluateCurve2d$1(cu, t), bounds.first, bounds.last, tolerance, {
+		maxSegments: Math.max(8, maxSegments),
+		breaks: curveKnotParams(cu)
+	}));
 }
 function decomposeBSpline2dToBeziers(curve) {
-	let cu = c2d(curve);
-	while (cu.__bk2d === "trimmed") cu = cu.basis;
-	if (cu.__bk2d !== "bspline") return [curve];
-	const poles = cu.poles;
-	const p = cu.degree;
-	const U = [];
-	for (let i = 0; i < cu.knots.length; i++) {
-		const knot = cu.knots[i] ?? 0;
-		const mult = cu.multiplicities[i] ?? 0;
-		for (let j = 0; j < mult; j++) U.push(knot);
-	}
-	const m = poles.length - 1 + p + 1;
-	if (p < 1 || U.length !== m + 1) return [c2dWrap(makeBezier2d$1(poles))];
-	const clone = (pt) => [pt[0], pt[1]];
-	const segments = [];
-	let a = p;
-	let b = p + 1;
-	let segPoles = [];
-	for (let i = 0; i <= p; i++) segPoles[i] = clone(poles[i]);
-	let nextPoles = [];
-	while (b < m) {
-		const i0 = b;
-		while (b < m && U[b + 1] === U[b]) b++;
-		const mult = b - i0 + 1;
-		if (mult < p) {
-			const numer = U[b] - U[a];
-			const alphas = [];
-			for (let j = p; j > mult; j--) alphas[j - mult - 1] = numer / (U[a + j] - U[a]);
-			const r = p - mult;
-			for (let j = 1; j <= r; j++) {
-				const save = r - j;
-				const s = mult + j;
-				for (let k = p; k >= s; k--) {
-					const alpha = alphas[k - s];
-					const cur = segPoles[k];
-					const prev = segPoles[k - 1];
-					segPoles[k] = [alpha * cur[0] + (1 - alpha) * prev[0], alpha * cur[1] + (1 - alpha) * prev[1]];
-				}
-				if (b < m) nextPoles[save] = clone(segPoles[p]);
-			}
-		}
-		segments.push(segPoles);
-		if (b < m) {
-			for (let i = p - mult; i <= p; i++) nextPoles[i] = clone(poles[b - p + i]);
-			segPoles = nextPoles;
-			nextPoles = [];
-			a = b;
-			b++;
-		}
-	}
-	return segments.map((sp) => c2dWrap(makeBezier2d$1(sp)));
+	const cu = flattenTrimmed(c2d(curve));
+	const basis = cu.__bk2d === "trimmed" ? cu.basis : cu;
+	if (basis.__bk2d !== "bspline") return [curve];
+	const piece = cu.__bk2d === "trimmed" ? trimmedPoleCurve(basis, cu.tStart, cu.tEnd) : basis;
+	if (!piece) return [curve];
+	return bezierSegments2d(piece).map((poles) => c2dWrap(makeBezier2d$1(poles)));
 }
 function createBoundingBox2d() {
 	return createBBox2d();
@@ -4678,78 +5537,174 @@ function splitCurve2d(curve, params) {
 	}
 	return result;
 }
-function liftCurve2dToPlane(k, Module, curve, planeOrigin, planeZ, planeX) {
-	const cu = c2d(curve);
-	const [ox, oy, oz] = planeOrigin;
-	const [zx, zy, zz] = planeZ;
-	const [xx, xy, xz] = planeX;
+function planeFrame(origin, z, x) {
+	const [ox, oy, oz] = origin;
+	const [zx, zy, zz] = z;
+	const [xx, xy, xz] = x;
 	const yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
-	const lift = (u, v) => [
-		ox + u * xx + v * yx,
-		oy + u * xy + v * yy,
-		oz + u * xz + v * yz
+	return {
+		point: (u, v) => [
+			ox + u * xx + v * yx,
+			oy + u * xy + v * yy,
+			oz + u * xz + v * yz
+		],
+		dir: (u, v) => [
+			u * xx + v * yx,
+			u * xy + v * yy,
+			u * xz + v * yz
+		],
+		normal: z
+	};
+}
+/** Lift an ellipse (or an arc of it over `range`) as an exact OCCT ellipse edge. */
+function liftEllipse(k, frame, basis, range) {
+	let e = basis;
+	let r = range;
+	if (r && r[1] < r[0]) {
+		e = {
+			...e,
+			sense: !e.sense
+		};
+		r = [-r[0], -r[1]];
+	}
+	let major = e.majorRadius;
+	let minor = e.minorRadius;
+	let angle = e.xDirAngle;
+	let shift = 0;
+	if (major < minor) {
+		[major, minor] = [minor, major];
+		angle += Math.PI / 2;
+		shift = e.sense ? -Math.PI / 2 : Math.PI / 2;
+	}
+	const n = frame.normal;
+	const normal = e.sense ? n : [
+		-n[0],
+		-n[1],
+		-n[2]
 	];
-	const bk2dType = cu.__bk2d;
-	if (bk2dType === "line") {
-		const bounds = curveBounds(cu);
-		const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
-		const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
-		const p1 = lift(u1, v1);
-		const p2 = lift(u2, v2);
-		return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-	}
-	if (bk2dType === "trimmed") {
-		const trimmed = cu;
-		if (trimmed.basis && trimmed.basis.__bk2d === "line") {
-			const [u1, v1] = evaluateCurve2d$1(cu, 0);
-			const [u2, v2] = evaluateCurve2d$1(cu, 1);
-			const p1 = lift(u1, v1);
-			const p2 = lift(u2, v2);
-			return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-		}
-		if (trimmed.basis && trimmed.basis.__bk2d === "circle") {
-			const bounds = curveBounds(cu);
-			const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
-			const [um, vm] = evaluateCurve2d$1(cu, (bounds.first + bounds.last) / 2);
-			const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
-			const p1 = lift(u1, v1);
-			const pm = lift(um, vm);
-			const p2 = lift(u2, v2);
-			return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+	const center = frame.point(e.cx, e.cy);
+	const xDir = frame.dir(Math.cos(angle), Math.sin(angle));
+	if (!r || r[1] - r[0] >= 2 * Math.PI - 1e-12) return makeEllipseEdge(k, center, normal, major, minor, xDir);
+	return makeEllipseArc(k, center, normal, major, minor, r[0] + shift, r[1] + shift, xDir);
+}
+function splitBezier(poles, t) {
+	const work = poles.map(([x, y]) => [x, y]);
+	const n = work.length;
+	const left = [];
+	const right = [];
+	left.push([...work[0]]);
+	right.push([...work[n - 1]]);
+	for (let r = 1; r < n; r++) {
+		for (let i = 0; i < n - r; i++) {
+			const a = work[i];
+			const b = work[i + 1];
+			work[i] = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 		}
+		left.push([...work[0]]);
+		right.push([...work[n - 1 - r]]);
 	}
-	if (bk2dType === "circle") {
-		const circleData = cu;
-		if (circleData.cx !== void 0 && circleData.radius !== void 0) {
-			const [pcx, pcy, pcz] = lift(circleData.cx, circleData.cy);
-			return handle("edge", k.makeCircleEdge(pcx, pcy, pcz, zx, zy, zz, circleData.radius));
-		}
-		const bounds = curveBounds(cu);
-		const [u1, v1] = evaluateCurve2d$1(cu, bounds.first);
-		const [um, vm] = evaluateCurve2d$1(cu, (bounds.first + bounds.last) / 2);
-		const [u2, v2] = evaluateCurve2d$1(cu, bounds.last);
-		const p1 = lift(u1, v1);
-		const pm = lift(um, vm);
-		const p2 = lift(u2, v2);
-		return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+	return [left, right.reverse()];
+}
+/** Poles of the Bezier restricted to [from, to] (either order), traversed from -> to. */
+function bezierSegmentPoles(poles, from, to) {
+	const lo = Math.min(from, to);
+	const hi = Math.max(from, to);
+	let seg = poles;
+	if (hi < 1) seg = splitBezier(seg, hi)[0];
+	if (lo > 0) seg = splitBezier(seg, hi > 0 ? lo / hi : 0)[1];
+	return from <= to ? seg : [...seg].reverse();
+}
+function liftBezier(k, Module, frame, poles) {
+	const vec = new Module.VectorDouble();
+	try {
+		for (const [u, v] of poles) for (const x of frame.point(u, v)) vec.push_back(x);
+		return handle("edge", k.makeBezierEdge(vec));
+	} finally {
+		vec.delete();
 	}
-	const bounds = curveBounds(cu);
-	const nSamples = 24;
-	const dt = (bounds.last - bounds.first) / nSamples;
-	const pts = [];
-	for (let i = 0; i <= nSamples; i++) {
-		const [u, v] = evaluateCurve2d$1(cu, bounds.first + i * dt);
-		const [px, py, pz] = lift(u, v);
-		pts.push(px, py, pz);
+}
+/** Lift a non-periodic B-spline exactly (an affine lift maps poles to poles). */
+function liftBSpline(k, Module, frame, c) {
+	if (!k.makeBSplineEdge || c.isPeriodic) return null;
+	const poles = new Module.VectorDouble();
+	const weights = new Module.VectorDouble();
+	const knots = new Module.VectorDouble();
+	const mults = new Module.VectorInt();
+	try {
+		for (const [u, v] of c.poles) for (const x of frame.point(u, v)) poles.push_back(x);
+		for (const knot of c.knots) knots.push_back(knot);
+		for (const m of c.multiplicities) mults.push_back(m);
+		return handle("edge", k.makeBSplineEdge(poles, weights, knots, mults, c.degree, false));
+	} finally {
+		poles.delete();
+		weights.delete();
+		knots.delete();
+		mults.delete();
 	}
+}
+function liftFitted(k, Module, frame, cu) {
+	const bounds = curveBounds(cu);
+	const bbox = createBBox2d();
+	addCurveToBBox(bbox, cu, 0);
+	const extent = Math.hypot(bbox.xMax - bbox.xMin, bbox.yMax - bbox.yMin);
+	const knots = curveKnotParams(cu);
+	const fit = fitBSpline2d((t) => evaluateCurve2d$1(cu, t), bounds.first, bounds.last, 1e-9 * Math.max(1, extent), { breaks: knots });
+	const exact = liftBSpline(k, Module, frame, fit);
+	if (exact) return exact;
+	const nSamples = Math.max(24, fit.poles.length);
+	const span = bounds.last - bounds.first;
+	const params = [];
+	for (let i = 0; i <= nSamples; i++) params.push(bounds.first + span * i / nSamples);
+	for (const t of knots) {
+		const nearest = bounds.first + span * Math.round((t - bounds.first) / span * nSamples) / nSamples;
+		if (Math.abs(t - nearest) > 1e-9 * span) params.push(t);
+	}
+	params.sort((a, b) => a - b);
+	const distinct = params.filter((t, i) => i === 0 || t - (params[i - 1] ?? t) > 1e-9 * span);
 	const vec = new Module.VectorDouble();
-	for (const p of pts) vec.push_back(p);
 	try {
+		for (const t of distinct) {
+			const [u, v] = evaluateCurve2d$1(cu, t);
+			for (const x of frame.point(u, v)) vec.push_back(x);
+		}
 		return handle("edge", k.interpolatePoints(vec, false));
 	} finally {
 		vec.delete();
 	}
 }
+function liftCurve2dToPlane(k, Module, curve, planeOrigin, planeZ, planeX) {
+	const cu = flattenTrimmed(c2d(curve));
+	const frame = planeFrame(planeOrigin, planeZ, planeX);
+	const trimmed = cu.__bk2d === "trimmed" ? cu : null;
+	const basis = trimmed ? trimmed.basis : cu;
+	const range = trimmed ? [trimmed.tStart, trimmed.tEnd] : null;
+	const bounds = curveBounds(cu);
+	switch (basis.__bk2d) {
+		case "line": {
+			const p1 = frame.point(...evaluateCurve2d$1(cu, bounds.first));
+			const p2 = frame.point(...evaluateCurve2d$1(cu, bounds.last));
+			return handle("edge", k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+		}
+		case "circle": {
+			if (!range || Math.abs(range[1] - range[0]) >= 2 * Math.PI - 1e-12) {
+				const [pcx, pcy, pcz] = frame.point(basis.cx, basis.cy);
+				const [zx, zy, zz] = planeZ;
+				return handle("edge", k.makeCircleEdge(pcx, pcy, pcz, zx, zy, zz, basis.radius));
+			}
+			const p1 = frame.point(...evaluateCurve2d$1(cu, bounds.first));
+			const pm = frame.point(...evaluateCurve2d$1(cu, (bounds.first + bounds.last) / 2));
+			const p2 = frame.point(...evaluateCurve2d$1(cu, bounds.last));
+			return handle("edge", k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+		}
+		case "ellipse": return liftEllipse(k, frame, basis, range);
+		case "bezier": return liftBezier(k, Module, frame, range ? bezierSegmentPoles(basis.poles, range[0], range[1]) : basis.poles);
+		case "bspline": {
+			const piece = range ? trimmedPoleCurve(basis, range[0], range[1]) : basis;
+			return piece && liftBSpline(k, Module, frame, piece) || liftFitted(k, Module, frame, cu);
+		}
+		case "trimmed": return liftFitted(k, Module, frame, cu);
+	}
+}
 function buildEdgeOnSurface(k, Module, curve, surface) {
 	const cu = c2d(curve);
 	const bounds = curveBounds(cu);
@@ -5831,8 +6786,8 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	makeBezier2d(points) {
 		return makeBezier2d(points);
 	}
-	makeBSpline2d(points, _options) {
-		return makeBSpline2d(points);
+	makeBSpline2d(points, options) {
+		return makeBSpline2d(points, options);
 	}
 	evaluateCurve2d(curve, param) {
 		return evaluateCurve2d(curve, param);
@@ -5849,7 +6804,9 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	trimCurve2d(curve, start, end) {
 		return trimCurve2d(curve, start, end);
 	}
-	reverseCurve2d(curve) {}
+	reverseCurve2d(curve) {
+		reverseCurve2d(curve);
+	}
 	copyCurve2d(curve) {
 		return copyCurve2d(curve);
 	}
@@ -5910,8 +6867,8 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
 		return distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End);
 	}
-	approximateCurve2dAsBSpline(curve, _tolerance, _continuity, maxSegments) {
-		return approximateCurve2dAsBSpline(curve, maxSegments);
+	approximateCurve2dAsBSpline(curve, tolerance, _continuity, maxSegments) {
+		return approximateCurve2dAsBSpline(curve, tolerance, maxSegments);
 	}
 	decomposeBSpline2dToBeziers(curve) {
 		return decomposeBSpline2dToBeziers(curve);
@@ -6139,12 +7096,24 @@ Object.defineProperty(exports, "mirrorAtPoint", {
 		return mirrorAtPoint;
 	}
 });
+Object.defineProperty(exports, "offsetCurve2d", {
+	enumerable: true,
+	get: function() {
+		return offsetCurve2d$1;
+	}
+});
 Object.defineProperty(exports, "quickHull", {
 	enumerable: true,
 	get: function() {
 		return quickHull;
 	}
 });
+Object.defineProperty(exports, "reverseCurve2d", {
+	enumerable: true,
+	get: function() {
+		return reverseCurve2d$1;
+	}
+});
 Object.defineProperty(exports, "rotateCurve2d", {
 	enumerable: true,
 	get: function() {