@ccpc/math 0.1.0

package/dist/discretize/internal/postprocess.js

@@ -0,0 +1,109 @@
+import { Precision } from '../../utils/precision';
+import { assertDiscretize, DISCRETIZE_ERROR_PREFIX } from '../discretize_errors';
+function cloneSample(sample) {
+    return { u: sample.u, p: sample.p.clone() };
+}
+function deduplicateAdjacent(samples, tol) {
+    if (samples.length <= 1)
+        return samples;
+    const deduped = [samples[0]];
+    for (let i = 1; i < samples.length; i++) {
+        const prev = deduped[deduped.length - 1];
+        const cur = samples[i];
+        if (prev.p.distanceTo(cur.p) <= tol)
+            continue;
+        deduped.push(cur);
+    }
+    return deduped;
+}
+function removeTrailingEndpoint(samples, endParam, endPoint, tol) {
+    while (samples.length > 1) {
+        const last = samples[samples.length - 1];
+        if (Math.abs(last.u - endParam) <= Precision.CURVE_PARAM_EPS || last.p.distanceTo(endPoint) <= tol) {
+            samples.pop();
+            continue;
+        }
+        break;
+    }
+}
+function ensureOpenEndIncluded(samples, endParam, endPoint, tol) {
+    const endSample = { u: endParam, p: endPoint.clone() };
+    if (samples.length === 0) {
+        samples.push(endSample);
+        return;
+    }
+    const last = samples[samples.length - 1];
+    if (Math.abs(last.u - endParam) <= Precision.CURVE_PARAM_EPS || last.p.distanceTo(endPoint) <= tol) {
+        samples[samples.length - 1] = endSample;
+        return;
+    }
+    if (endParam > last.u + Precision.CURVE_PARAM_EPS) {
+        samples.push(endSample);
+    }
+    else {
+        samples[samples.length - 1] = endSample;
+    }
+}
+function removeClosedDuplicateTail(samples, tol) {
+    while (samples.length > 1) {
+        const first = samples[0];
+        const last = samples[samples.length - 1];
+        if (first.p.distanceTo(last.p) <= tol) {
+            samples.pop();
+            continue;
+        }
+        break;
+    }
+}
+export function postprocessDiscretizeResult(curve, raw, options) {
+    const range = curve.getRange();
+    const startParam = range.start;
+    const endParam = range.end;
+    const startPoint = curve.pointAt(startParam);
+    const endPoint = curve.pointAt(endParam);
+    let samples = raw.samples.map(cloneSample);
+    if (samples.length === 0) {
+        samples = [{ u: startParam, p: startPoint.clone() }];
+    }
+    samples = deduplicateAdjacent(samples, options.effectivePointMergeTol);
+    samples[0] = { u: startParam, p: startPoint.clone() };
+    if (raw.closed) {
+        removeClosedDuplicateTail(samples, options.effectivePointMergeTol);
+    }
+    else if (options.includeEnd) {
+        ensureOpenEndIncluded(samples, endParam, endPoint, options.effectivePointMergeTol);
+    }
+    else {
+        removeTrailingEndpoint(samples, endParam, endPoint, options.effectivePointMergeTol);
+    }
+    if (samples.length === 0) {
+        samples.push({ u: startParam, p: startPoint.clone() });
+    }
+    const result = { samples, closed: raw.closed };
+    assertDiscretizeResult(curve, result, options);
+    return result;
+}
+export function assertDiscretizeResult(curve, result, options) {
+    assertDiscretize(result.samples.length > 0, DISCRETIZE_ERROR_PREFIX.convergence, 'empty discretize result');
+    for (let i = 1; i < result.samples.length; i++) {
+        const prev = result.samples[i - 1];
+        const cur = result.samples[i];
+        assertDiscretize(cur.u > prev.u, DISCRETIZE_ERROR_PREFIX.convergence, 'sample parameters must be strictly increasing');
+    }
+    const range = curve.getRange();
+    const start = range.start;
+    const end = range.end;
+    const first = result.samples[0];
+    assertDiscretize(Math.abs(first.u - start) <= Precision.CURVE_PARAM_EPS, DISCRETIZE_ERROR_PREFIX.convergence, 'first sample must match range start');
+    if (result.closed) {
+        if (result.samples.length > 1) {
+            const last = result.samples[result.samples.length - 1];
+            assertDiscretize(first.p.distanceTo(last.p) > options.effectivePointMergeTol, DISCRETIZE_ERROR_PREFIX.convergence, 'closed result must not duplicate head/tail points');
+        }
+        return;
+    }
+    if (!options.includeEnd)
+        return;
+    const last = result.samples[result.samples.length - 1];
+    assertDiscretize(Math.abs(last.u - end) <= Precision.CURVE_PARAM_EPS, DISCRETIZE_ERROR_PREFIX.convergence, 'last sample must match range end');
+}

package/dist/discretize/internal/sampling_utils.d.ts

@@ -0,0 +1,8 @@
+import { Vec2 } from '../../core/vec2';
+import type { Curve2 } from '../../curves/curve2';
+export declare const CHORD_CHECK_FRACTIONS: readonly [0.25, 0.5, 0.75];
+export declare function lerpNumber(a: number, b: number, t: number): number;
+export declare function distancePointToSegment(point: Vec2, segStart: Vec2, segEnd: Vec2): number;
+export declare function tangentTurnAbs(curve: Curve2, u0: number, u1: number): number;
+export declare function maxChordDeviationAtFractions(curve: Curve2, u0: number, u1: number, p0: Vec2, p1: Vec2, fractions?: readonly [0.25, 0.5, 0.75]): number;
+//# sourceMappingURL=sampling_utils.d.ts.map

package/dist/discretize/internal/sampling_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling_utils.d.ts","sourceRoot":"","sources":["../../../src/discretize/internal/sampling_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,eAAO,MAAM,qBAAqB,4BAA6B,CAAA;AAE/D,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAEzD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,UAW/E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAOnE;AAED,wBAAgB,4BAA4B,CACxC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,IAAI,EACR,SAAS,6BAAwB,UAYpC"}

package/dist/discretize/internal/sampling_utils.js

@@ -0,0 +1,36 @@
+import { Precision } from '../../utils/precision';
+export const CHORD_CHECK_FRACTIONS = [0.25, 0.5, 0.75];
+export function lerpNumber(a, b, t) {
+    return a + (b - a) * t;
+}
+export function distancePointToSegment(point, segStart, segEnd) {
+    const edge = segEnd.subtracted(segStart);
+    const lenSq = edge.lenSq();
+    if (lenSq <= Precision.CURVE_LENGTH_EPS * Precision.CURVE_LENGTH_EPS) {
+        return point.distanceTo(segStart);
+    }
+    const rel = point.subtracted(segStart);
+    const t = Math.max(0, Math.min(1, rel.dot(edge) / lenSq));
+    const proj = segStart.added(edge.scaled(t));
+    return point.distanceTo(proj);
+}
+export function tangentTurnAbs(curve, u0, u1) {
+    const t0 = curve.tangentAt(u0);
+    const t1 = curve.tangentAt(u1);
+    if (t0.lenSq() <= Precision.CURVE_NEWTON_EPS || t1.lenSq() <= Precision.CURVE_NEWTON_EPS) {
+        return 0;
+    }
+    return Math.abs(t0.angleTo(t1));
+}
+export function maxChordDeviationAtFractions(curve, u0, u1, p0, p1, fractions = CHORD_CHECK_FRACTIONS) {
+    let maxDeviation = 0;
+    for (const fraction of fractions) {
+        const um = lerpNumber(u0, u1, fraction);
+        const pm = curve.pointAt(um);
+        const deviation = distancePointToSegment(pm, p0, p1);
+        if (deviation > maxDeviation) {
+            maxDeviation = deviation;
+        }
+    }
+    return maxDeviation;
+}

package/dist/discretize/register_builtin_strategies.d.ts

@@ -0,0 +1,3 @@
+import { DiscretizeStrategyRegistry } from './strategy_registry';
+export declare function registerBuiltinDiscretizeStrategies(registry: DiscretizeStrategyRegistry): void;
+//# sourceMappingURL=register_builtin_strategies.d.ts.map

package/dist/discretize/register_builtin_strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register_builtin_strategies.d.ts","sourceRoot":"","sources":["../../src/discretize/register_builtin_strategies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAA;AAMhE,wBAAgB,mCAAmC,CAAC,QAAQ,EAAE,0BAA0B,QAKvF"}

package/dist/discretize/register_builtin_strategies.js

@@ -0,0 +1,10 @@
+import { bsplineDiscretizeStrategy } from './strategies/bspline_strategy';
+import { circleDiscretizeStrategy } from './strategies/circle_strategy';
+import { ellipseDiscretizeStrategy } from './strategies/ellipse_strategy';
+import { lineDiscretizeStrategy } from './strategies/line_strategy';
+export function registerBuiltinDiscretizeStrategies(registry) {
+    registry.register(lineDiscretizeStrategy);
+    registry.register(circleDiscretizeStrategy);
+    registry.register(ellipseDiscretizeStrategy);
+    registry.register(bsplineDiscretizeStrategy);
+}

package/dist/discretize/strategies/bspline_strategy.d.ts

@@ -0,0 +1,4 @@
+import { BSpline2 } from '../../curves/bspline2';
+import type { DiscretizeResult, ResolvedDiscretizeOptions } from '../discretize_types';
+export declare function discretizeBSplineCurve(curve: BSpline2, options: ResolvedDiscretizeOptions): DiscretizeResult;
+//# sourceMappingURL=bspline_strategy.d.ts.map

package/dist/discretize/strategies/bspline_strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bspline_strategy.d.ts","sourceRoot":"","sources":["../../../src/discretize/strategies/bspline_strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAGhD,OAAO,KAAK,EAAE,gBAAgB,EAAkB,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAqHtG,wBAAgB,sBAAsB,CAClC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,yBAAyB,GACnC,gBAAgB,CA2BlB"}

package/dist/discretize/strategies/bspline_strategy.js

@@ -0,0 +1,115 @@
+import { Precision } from '../../utils/precision';
+import { throwDiscretizeConvergenceError, throwDiscretizeOverflowError } from '../discretize_errors';
+import { maxChordDeviationAtFractions, tangentTurnAbs } from '../internal/sampling_utils';
+function getContinuityBreaks(curve) {
+    const knots = curve.expandedKnots;
+    const degree = curve.degree;
+    const range = curve.getRange();
+    const breaks = [];
+    for (let i = 0; i < knots.length;) {
+        const knot = knots[i];
+        let multiplicity = 1;
+        i++;
+        while (i < knots.length && Math.abs(knots[i] - knot) <= Precision.CURVE_PARAM_EPS) {
+            multiplicity++;
+            i++;
+        }
+        if (multiplicity >= degree && knot > range.start + Precision.CURVE_PARAM_EPS && knot < range.end - Precision.CURVE_PARAM_EPS) {
+            breaks.push(knot);
+        }
+    }
+    return breaks;
+}
+function buildInitialSegments(curve, options) {
+    const range = curve.getRange();
+    const span = range.length();
+    const boundaries = new Set([range.start, range.end, ...getContinuityBreaks(curve)]);
+    for (let i = 1; i < options.minSegments; i++) {
+        boundaries.add(range.start + (span * i) / options.minSegments);
+    }
+    const sorted = [...boundaries].sort((a, b) => a - b);
+    const segments = [];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const u0 = sorted[i];
+        const u1 = sorted[i + 1];
+        if (u1 - u0 <= Precision.CURVE_PARAM_EPS)
+            continue;
+        segments.push({
+            u0,
+            u1,
+            p0: curve.pointAt(u0),
+            p1: curve.pointAt(u1),
+        });
+    }
+    return segments;
+}
+function shouldSplitSegment(curve, segment, options) {
+    const chordLength = segment.p0.distanceTo(segment.p1);
+    const deviation = maxChordDeviationAtFractions(curve, segment.u0, segment.u1, segment.p0, segment.p1);
+    const turn = tangentTurnAbs(curve, segment.u0, segment.u1);
+    const violateMaxLength = chordLength > options.maxSegmentLength;
+    const violateChord = deviation > options.effectiveChordTol;
+    const violateTurn = turn > options.angleTolRad;
+    if (!violateMaxLength && !violateChord && !violateTurn)
+        return 'ok';
+    if (chordLength <= options.minSegmentLengthInternal) {
+        return 'blocked';
+    }
+    return 'split';
+}
+function refineSegments(curve, initialSegments, options) {
+    const segments = [...initialSegments];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const verdict = shouldSplitSegment(curve, segment, options);
+        if (verdict === 'ok')
+            continue;
+        if (verdict === 'blocked') {
+            throwDiscretizeOverflowError('bspline strategy cannot satisfy constraints within internal segment limit');
+        }
+        if (segments.length >= options.maxSegments) {
+            throwDiscretizeOverflowError('bspline strategy exceeds maxSegments constraints');
+        }
+        const mid = (segment.u0 + segment.u1) * 0.5;
+        if (Math.abs(mid - segment.u0) <= Precision.CURVE_PARAM_EPS || Math.abs(segment.u1 - mid) <= Precision.CURVE_PARAM_EPS) {
+            throwDiscretizeConvergenceError('bspline strategy failed to converge');
+        }
+        const pm = curve.pointAt(mid);
+        segments.splice(i, 1, { u0: segment.u0, u1: mid, p0: segment.p0, p1: pm }, { u0: mid, u1: segment.u1, p0: pm, p1: segment.p1 });
+        i--;
+    }
+    return segments;
+}
+function toSamples(segments) {
+    const samples = [{ u: segments[0].u0, p: segments[0].p0.clone() }];
+    for (const segment of segments) {
+        samples.push({ u: segment.u1, p: segment.p1.clone() });
+    }
+    return samples;
+}
+export function discretizeBSplineCurve(curve, options) {
+    const range = curve.getRange();
+    const span = range.length();
+    const curveLen = curve.length();
+    if (curveLen <= Precision.CURVE_LENGTH_EPS || span <= Precision.CURVE_PARAM_EPS) {
+        return {
+            closed: false,
+            samples: [{ u: range.start, p: curve.pointAt(range.start) }],
+        };
+    }
+    const initialSegments = buildInitialSegments(curve, options);
+    if (initialSegments.length === 0) {
+        return {
+            closed: false,
+            samples: [{ u: range.start, p: curve.pointAt(range.start) }],
+        };
+    }
+    if (initialSegments.length > options.maxSegments) {
+        throwDiscretizeOverflowError('bspline strategy exceeds maxSegments constraints');
+    }
+    const refined = refineSegments(curve, initialSegments, options);
+    return {
+        closed: false,
+        samples: toSamples(refined),
+    };
+}

package/dist/discretize/strategies/circle_strategy.d.ts

@@ -0,0 +1,7 @@
+import { Arc2 } from '../../curves/arc2';
+import { Circle2 } from '../../curves/circle2';
+import type { DiscretizeResult, ResolvedDiscretizeOptions } from '../discretize_types';
+type CircleLikeCurve = Circle2 | Arc2;
+export declare function discretizeCircleLikeCurve(curve: CircleLikeCurve, options: ResolvedDiscretizeOptions): DiscretizeResult;
+export {};
+//# sourceMappingURL=circle_strategy.d.ts.map

package/dist/discretize/strategies/circle_strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle_strategy.d.ts","sourceRoot":"","sources":["../../../src/discretize/strategies/circle_strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAG9C,OAAO,KAAK,EAAE,gBAAgB,EAAkB,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAEtG,KAAK,eAAe,GAAG,OAAO,GAAG,IAAI,CAAA;AAwBrC,wBAAgB,yBAAyB,CACrC,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,yBAAyB,GACnC,gBAAgB,CAoClB"}

package/dist/discretize/strategies/circle_strategy.js

@@ -0,0 +1,55 @@
+import { Circle2 } from '../../curves/circle2';
+import { Precision } from '../../utils/precision';
+import { throwDiscretizeOverflowError } from '../discretize_errors';
+function dThetaByChord(radius, chordTol) {
+    const ratio = 1 - chordTol / radius;
+    if (ratio <= -1)
+        return Math.PI * 2;
+    const clamped = Math.min(1, Math.max(-1, ratio));
+    return 2 * Math.acos(clamped);
+}
+function buildCircleLikeSamples(curve, segmentCount, closed) {
+    const range = curve.getRange();
+    const start = range.start;
+    const span = range.length();
+    const steps = closed ? segmentCount : segmentCount + 1;
+    const samples = [];
+    for (let i = 0; i < steps; i++) {
+        const t = i / segmentCount;
+        const u = start + span * t;
+        samples.push({ u, p: curve.pointAt(u) });
+    }
+    return samples;
+}
+export function discretizeCircleLikeCurve(curve, options) {
+    const range = curve.getRange();
+    const sweep = range.length();
+    const radius = curve.radius;
+    const totalLen = curve.length();
+    const closed = curve instanceof Circle2 || Math.abs(sweep - Math.PI * 2) <= Precision.CURVE_PARAM_EPS;
+    if (totalLen <= Precision.CURVE_LENGTH_EPS || sweep <= Precision.CURVE_PARAM_EPS) {
+        return {
+            closed,
+            samples: [{ u: range.start, p: curve.pointAt(range.start) }],
+        };
+    }
+    const maxByInternal = Math.max(1, Math.floor(totalLen / options.minSegmentLengthInternal));
+    const dThetaChord = dThetaByChord(radius, options.effectiveChordTol);
+    const dThetaAngle = options.angleTolRad;
+    const dThetaLength = options.maxSegmentLength === Number.POSITIVE_INFINITY
+        ? Number.POSITIVE_INFINITY
+        : options.maxSegmentLength / radius;
+    const dTheta = Math.max(Precision.CURVE_PARAM_EPS, Math.min(dThetaChord, dThetaAngle, dThetaLength));
+    const requiredSegments = Math.max(1, Math.ceil(sweep / dTheta));
+    if (requiredSegments > options.maxSegments || requiredSegments > maxByInternal) {
+        throwDiscretizeOverflowError('circle strategy exceeds maxSegments constraints');
+    }
+    const segmentCount = Math.max(requiredSegments, options.minSegments);
+    if (segmentCount > options.maxSegments || segmentCount > maxByInternal) {
+        throwDiscretizeOverflowError('circle strategy exceeds maxSegments constraints');
+    }
+    return {
+        closed,
+        samples: buildCircleLikeSamples(curve, segmentCount, closed),
+    };
+}

package/dist/discretize/strategies/ellipse_strategy.d.ts

@@ -0,0 +1,7 @@
+import { Ellipse2 } from '../../curves/ellipse2';
+import { EllipseArc2 } from '../../curves/ellipse_arc2';
+import type { DiscretizeResult, ResolvedDiscretizeOptions } from '../discretize_types';
+type EllipseLikeCurve = Ellipse2 | EllipseArc2;
+export declare function discretizeEllipseLikeCurve(curve: EllipseLikeCurve, options: ResolvedDiscretizeOptions): DiscretizeResult;
+export {};
+//# sourceMappingURL=ellipse_strategy.d.ts.map

package/dist/discretize/strategies/ellipse_strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse_strategy.d.ts","sourceRoot":"","sources":["../../../src/discretize/strategies/ellipse_strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAGvD,OAAO,KAAK,EAAE,gBAAgB,EAAkB,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAGtG,KAAK,gBAAgB,GAAG,QAAQ,GAAG,WAAW,CAAA;AAyF9C,wBAAgB,0BAA0B,CACtC,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,yBAAyB,GACnC,gBAAgB,CA2BlB"}

package/dist/discretize/strategies/ellipse_strategy.js

@@ -0,0 +1,86 @@
+import { Ellipse2 } from '../../curves/ellipse2';
+import { Precision } from '../../utils/precision';
+import { throwDiscretizeConvergenceError, throwDiscretizeOverflowError } from '../discretize_errors';
+import { maxChordDeviationAtFractions, tangentTurnAbs } from '../internal/sampling_utils';
+function shouldSplitSegment(curve, segment, options) {
+    const chordLength = segment.p0.distanceTo(segment.p1);
+    const deviation = maxChordDeviationAtFractions(curve, segment.u0, segment.u1, segment.p0, segment.p1);
+    const turn = tangentTurnAbs(curve, segment.u0, segment.u1);
+    const violateMaxLength = chordLength > options.maxSegmentLength;
+    const violateChord = deviation > options.effectiveChordTol;
+    const violateTurn = turn > options.angleTolRad;
+    if (!violateMaxLength && !violateChord && !violateTurn)
+        return 'ok';
+    if (chordLength <= options.minSegmentLengthInternal) {
+        return 'blocked';
+    }
+    return 'split';
+}
+function buildInitialSegments(curve, segmentCount) {
+    const range = curve.getRange();
+    const start = range.start;
+    const span = range.length();
+    const segments = [];
+    for (let i = 0; i < segmentCount; i++) {
+        const u0 = start + (span * i) / segmentCount;
+        const u1 = start + (span * (i + 1)) / segmentCount;
+        segments.push({
+            u0,
+            u1,
+            p0: curve.pointAt(u0),
+            p1: curve.pointAt(u1),
+        });
+    }
+    return segments;
+}
+function refineAdaptiveSegments(curve, initialSegments, options) {
+    const segments = [...initialSegments];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const verdict = shouldSplitSegment(curve, segment, options);
+        if (verdict === 'ok')
+            continue;
+        if (verdict === 'blocked') {
+            throwDiscretizeOverflowError('ellipse strategy cannot satisfy constraints within internal segment limit');
+        }
+        if (segments.length >= options.maxSegments) {
+            throwDiscretizeOverflowError('ellipse strategy exceeds maxSegments constraints');
+        }
+        const mid = (segment.u0 + segment.u1) * 0.5;
+        if (Math.abs(mid - segment.u0) <= Precision.CURVE_PARAM_EPS || Math.abs(segment.u1 - mid) <= Precision.CURVE_PARAM_EPS) {
+            throwDiscretizeConvergenceError('ellipse strategy failed to converge');
+        }
+        const pm = curve.pointAt(mid);
+        segments.splice(i, 1, { u0: segment.u0, u1: mid, p0: segment.p0, p1: pm }, { u0: mid, u1: segment.u1, p0: pm, p1: segment.p1 });
+        i--;
+    }
+    return segments;
+}
+function segmentsToSamples(segments) {
+    const samples = [{ u: segments[0].u0, p: segments[0].p0.clone() }];
+    for (const segment of segments) {
+        samples.push({ u: segment.u1, p: segment.p1.clone() });
+    }
+    return samples;
+}
+export function discretizeEllipseLikeCurve(curve, options) {
+    const range = curve.getRange();
+    const span = range.length();
+    const curveLen = curve.length();
+    const closed = curve instanceof Ellipse2 || Math.abs(span - Math.PI * 2) <= Precision.CURVE_PARAM_EPS;
+    if (curveLen <= Precision.CURVE_LENGTH_EPS || span <= Precision.CURVE_PARAM_EPS) {
+        return {
+            closed,
+            samples: [{ u: range.start, p: curve.pointAt(range.start) }],
+        };
+    }
+    const initialSegmentCount = Math.max(1, options.minSegments);
+    if (initialSegmentCount > options.maxSegments) {
+        throwDiscretizeOverflowError('ellipse strategy exceeds maxSegments constraints');
+    }
+    const segments = refineAdaptiveSegments(curve, buildInitialSegments(curve, initialSegmentCount), options);
+    return {
+        closed,
+        samples: segmentsToSamples(segments),
+    };
+}

package/dist/discretize/strategies/line_strategy.d.ts

@@ -0,0 +1,4 @@
+import { Line2 } from '../../curves/line2';
+import type { DiscretizeResult, ResolvedDiscretizeOptions } from '../discretize_types';
+export declare function discretizeLineCurve(curve: Line2, options: ResolvedDiscretizeOptions): DiscretizeResult;
+//# sourceMappingURL=line_strategy.d.ts.map

package/dist/discretize/strategies/line_strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line_strategy.d.ts","sourceRoot":"","sources":["../../../src/discretize/strategies/line_strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE1C,OAAO,KAAK,EAAE,gBAAgB,EAAkB,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAetG,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,yBAAyB,GACnC,gBAAgB,CA8BlB"}

package/dist/discretize/strategies/line_strategy.js

@@ -0,0 +1,40 @@
+import { Precision } from '../../utils/precision';
+import { throwDiscretizeOverflowError } from '../discretize_errors';
+function buildUniformLineSamples(curve, segmentCount) {
+    const range = curve.getRange();
+    const start = range.start;
+    const span = range.length();
+    const samples = [];
+    for (let i = 0; i <= segmentCount; i++) {
+        const u = start + (span * i) / segmentCount;
+        samples.push({ u, p: curve.pointAt(u) });
+    }
+    return samples;
+}
+export function discretizeLineCurve(curve, options) {
+    const curveLen = curve.length();
+    const range = curve.getRange();
+    if (curveLen <= Precision.CURVE_LENGTH_EPS || range.length() <= Precision.CURVE_PARAM_EPS) {
+        return {
+            closed: false,
+            samples: [{ u: range.start, p: curve.pointAt(range.start) }],
+        };
+    }
+    const requiredByMaxLen = options.maxSegmentLength === Number.POSITIVE_INFINITY
+        ? 1
+        : Math.max(1, Math.ceil(curveLen / options.maxSegmentLength));
+    const maxByInternal = Math.max(1, Math.floor(curveLen / options.minSegmentLengthInternal));
+    if (requiredByMaxLen > options.maxSegments || requiredByMaxLen > maxByInternal) {
+        throwDiscretizeOverflowError('line strategy exceeds maxSegments constraints');
+    }
+    const segmentCount = options.minSegmentsExplicit
+        ? Math.max(requiredByMaxLen, options.minSegments)
+        : requiredByMaxLen;
+    if (segmentCount > options.maxSegments || segmentCount > maxByInternal) {
+        throwDiscretizeOverflowError('line strategy exceeds maxSegments constraints');
+    }
+    return {
+        closed: false,
+        samples: buildUniformLineSamples(curve, segmentCount),
+    };
+}

package/dist/discretize/strategy_registry.d.ts

@@ -0,0 +1,9 @@
+import type { Curve2 } from '../curves/curve2';
+import type { DiscretizeStrategy } from './discretize_types';
+export declare class DiscretizeStrategyRegistry {
+    private _entries;
+    private _nextOrder;
+    register<T extends Curve2>(strategy: DiscretizeStrategy<T>): void;
+    resolve(curve: Curve2): DiscretizeStrategy<Curve2> | null;
+}
+//# sourceMappingURL=strategy_registry.d.ts.map

package/dist/discretize/strategy_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy_registry.d.ts","sourceRoot":"","sources":["../../src/discretize/strategy_registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAO5D,qBAAa,0BAA0B;IACnC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,UAAU,CAAI;IAEf,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAc1D,OAAO,CAAC,KAAK,EAAE,MAAM;CAe/B"}

package/dist/discretize/strategy_registry.js

@@ -0,0 +1,34 @@
+import { throwDiscretizeOptionsError } from './discretize_errors';
+export class DiscretizeStrategyRegistry {
+    constructor() {
+        this._entries = [];
+        this._nextOrder = 0;
+    }
+    register(strategy) {
+        if (strategy.ctor) {
+            const duplicated = this._entries.some((entry) => entry.strategy.ctor === strategy.ctor);
+            if (duplicated) {
+                throwDiscretizeOptionsError(`duplicated strategy constructor registration: ${strategy.id}`);
+            }
+        }
+        this._entries.push({
+            order: this._nextOrder++,
+            strategy: strategy,
+        });
+    }
+    resolve(curve) {
+        const ctorMatches = this._entries.filter((entry) => entry.strategy.ctor === curve.constructor);
+        if (ctorMatches.length > 1) {
+            throwDiscretizeOptionsError('ambiguous strategy constructor match');
+        }
+        if (ctorMatches.length === 1) {
+            return ctorMatches[0].strategy;
+        }
+        const guardMatches = this._entries
+            .filter((entry) => entry.strategy.canHandle(curve))
+            .sort((a, b) => a.order - b.order);
+        if (guardMatches.length === 0)
+            return null;
+        return guardMatches[0].strategy;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export { Vec2 } from './core/vec2';
+export { Mat3 } from './core/mat3';
+export { Box2 } from './core/box2';
+export { Coord2D } from './core/coord2d';
+export { GeomBase } from './core/geom_base';
+export { MathConst } from './constants/math_const';
+export { Curve2 } from './curves/curve2';
+export { Interval } from './curves/interval';
+export { PeriodInterval } from './curves/period_interval';
+export { CircleCurve2 } from './curves/circle_curve2';
+export { EllipseCurve2 } from './curves/ellipse_curve2';
+export { Line2 } from './curves/line2';
+export { Circle2 } from './curves/circle2';
+export { Arc2 } from './curves/arc2';
+export { Ellipse2 } from './curves/ellipse2';
+export { EllipseArc2 } from './curves/ellipse_arc2';
+export { BSpline2 } from './curves/bspline2';
+export type { IBSpline2Options } from './curves/bspline2';
+export { Precision } from './utils/precision';
+export { MathUtils } from './utils/math_utils';
+export { MathError } from './utils/math_error';
+export { DiscretizeEngine } from './discretize/discretize_engine';
+export { DiscretizeOptions } from './discretize/discretize_options';
+export { intersectCurveCurve, intersectCurveSelf } from './intersections';
+export type { CurveXInfo } from './intersections';
+export { GeomMgr, geomMgr, RegisterGeom } from './serialize/geom_mgr';
+export type { IDumpable, ILoadable } from './serialize/geom_mgr';
+export type { IDB, IDBVec2, IDBMat3, IDBBox2, IDBCoord2D, IDBLine2, IDBCircle2, IDBArc2, IDBEllipse2, IDBEllipseArc2, IDBBSpline2, } from './serialize/dump_types';
+export type { IVec2, IClosestPointResult } from './types/type_define';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC5C,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAEnE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACzE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACrE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChE,YAAY,EACR,GAAG,EACH,OAAO,EACP,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,UAAU,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,WAAW,GACd,MAAM,wBAAwB,CAAA;AAE/B,YAAY,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,24 @@
+export { Vec2 } from './core/vec2';
+export { Mat3 } from './core/mat3';
+export { Box2 } from './core/box2';
+export { Coord2D } from './core/coord2d';
+export { GeomBase } from './core/geom_base';
+export { MathConst } from './constants/math_const';
+export { Curve2 } from './curves/curve2';
+export { Interval } from './curves/interval';
+export { PeriodInterval } from './curves/period_interval';
+export { CircleCurve2 } from './curves/circle_curve2';
+export { EllipseCurve2 } from './curves/ellipse_curve2';
+export { Line2 } from './curves/line2';
+export { Circle2 } from './curves/circle2';
+export { Arc2 } from './curves/arc2';
+export { Ellipse2 } from './curves/ellipse2';
+export { EllipseArc2 } from './curves/ellipse_arc2';
+export { BSpline2 } from './curves/bspline2';
+export { Precision } from './utils/precision';
+export { MathUtils } from './utils/math_utils';
+export { MathError } from './utils/math_error';
+export { DiscretizeEngine } from './discretize/discretize_engine';
+export { DiscretizeOptions } from './discretize/discretize_options';
+export { intersectCurveCurve, intersectCurveSelf } from './intersections';
+export { GeomMgr, geomMgr, RegisterGeom } from './serialize/geom_mgr';

package/dist/intersections/analytic_x_algorithm.d.ts

@@ -0,0 +1,10 @@
+import type { Curve2 } from '../curves/curve2';
+import type { CurveXInfo } from './types';
+export declare class AnalyticXAlgorithm {
+    private readonly map;
+    private readonly retryMap;
+    intersect(c1: Curve2, c2: Curve2): CurveXInfo[];
+    private shouldRetry;
+    private boxesLikelyIntersect;
+}
+//# sourceMappingURL=analytic_x_algorithm.d.ts.map

package/dist/intersections/analytic_x_algorithm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytic_x_algorithm.d.ts","sourceRoot":"","sources":["../../src/intersections/analytic_x_algorithm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAyB9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAoBnB;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAQxB;IAEM,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IA2BtD,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,oBAAoB;CAM/B"}