@ccpc/math 0.1.0 → 0.1.7

package/dist/discretize/internal/postprocess.js

@@ -1,109 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,10 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,115 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,86 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,40 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,34 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,24 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}