@metamesh/modeling 0.0.0-bootstrap.0 → 0.6.0

package/dist/geometry/revolve/revolve-mesh.js

@@ -0,0 +1,123 @@
+import { GeometryError } from "../errors.js";
+import { triangulateLoop2 } from "../loft.js";
+import { validateTriangleMesh } from "../mesh.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
+import { writeMeshVertex } from "../numeric.js";
+import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
+import { normalizeLoop2 } from "../regions.js";
+import { assertSamplingCount } from "../sampling-limits.js";
+const AXIS_EPSILON = 1e-10;
+/**
+ * Revolves a non-duplicated closed `[radius, z]` profile around +Z.
+ *
+ * The profile is ordered counter-clockwise when radius points right and Z
+ * points up. Angular and profile seams wrap by index. A profile point on the
+ * axis is emitted once and joined as a triangle fan, avoiding coincident seam
+ * vertices and zero-area quads. Profile edges that lie entirely on the axis
+ * collapse to the solid's interior and are intentionally omitted.
+ * Profile coordinates must fit finite Float32 mesh storage.
+ *
+ * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
+ * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
+ * @returns A closed indexed triangle mesh revolved counter-clockwise around +Z.
+ */
+export const revolveMesh = (profile, options = {}) => {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Revolution options require an object.", {
+            operation: "revolveMesh",
+        });
+    const degrees = options.revolveDegrees ?? 360;
+    if (!Number.isFinite(degrees) || degrees <= 0 || degrees > 360)
+        throw new GeometryError("INVALID_ARGUMENT", "revolveDegrees must be in (0, 360].", {
+            operation: "revolveMesh",
+        });
+    if (profile.length < 3) {
+        throw new Error("A revolved profile needs at least three points.");
+    }
+    const limits = resolveModelingLimits(options.limits);
+    assertSamplingCount(profile.length, "revolveMesh", limits.maxProfilePoints);
+    let maximumRadius = 0;
+    for (const [radius, z] of profile) {
+        if (!Number.isFinite(radius) || !Number.isFinite(z) || radius < 0) {
+            throw new Error("Revolved profile coordinates must be finite and radii non-negative.");
+        }
+        if (!Number.isFinite(Math.fround(radius)) || !Number.isFinite(Math.fround(z))) {
+            throw new GeometryError("NON_FINITE_VALUE", "Revolved profile coordinates exceed finite Float32 mesh storage.", { operation: "revolveMesh" });
+        }
+        maximumRadius = Math.max(maximumRadius, radius);
+    }
+    profile = normalizeLoop2(profile, true);
+    const circularSegments = resolveCircularPrimitiveSegments(maximumRadius, options, "revolveMesh");
+    const closed = degrees === 360;
+    const segments = closed
+        ? circularSegments
+        : Math.max(1, Math.ceil((circularSegments * degrees) / 360));
+    const rings = closed ? segments : segments + 1;
+    const vertexCount = profile.reduce((count, [radius]) => count + (radius <= AXIS_EPSILON ? 1 : rings), 0);
+    const triangleCount = profile.reduce((count, [radius], index) => {
+        const currentOnAxis = radius <= AXIS_EPSILON;
+        const nextOnAxis = profile[(index + 1) % profile.length][0] <= AXIS_EPSILON;
+        return (count +
+            (currentOnAxis && nextOnAxis ? 0 : currentOnAxis || nextOnAxis ? segments : segments * 2));
+    }, 0) + (closed ? 0 : (profile.length - 2) * 2);
+    assertMeshAllocationWithinLimits(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, "revolveMesh", limits);
+    const vertexIndices = profile.map(([radius]) => radius <= AXIS_EPSILON ? new Uint32Array(1) : new Uint32Array(rings));
+    const positions = new Float32Array(vertexCount * 3);
+    let vertex = 0;
+    for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+        const [radius, z] = profile[profileIndex];
+        const indices = vertexIndices[profileIndex];
+        if (radius <= AXIS_EPSILON) {
+            indices[0] = vertex;
+            writeMeshVertex(positions, vertex++ * 3, [0, 0, z], "revolveMesh");
+            continue;
+        }
+        for (let segment = 0; segment < rings; segment += 1) {
+            const angle = (segment * degrees * Math.PI) / 180 / segments;
+            indices[segment] = vertex;
+            writeMeshVertex(positions, vertex++ * 3, [radius * Math.cos(angle), radius * Math.sin(angle), z], "revolveMesh");
+        }
+    }
+    const indices = new Uint32Array(triangleCount * 3);
+    let cursor = 0;
+    const triangle = (a, b, c) => {
+        indices[cursor++] = a;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+    };
+    for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+        const following = (profileIndex + 1) % profile.length;
+        const currentRadius = profile[profileIndex][0];
+        const followingRadius = profile[following][0];
+        const current = vertexIndices[profileIndex];
+        const next = vertexIndices[following];
+        const currentOnAxis = currentRadius <= AXIS_EPSILON;
+        const nextOnAxis = followingRadius <= AXIS_EPSILON;
+        if (currentOnAxis && nextOnAxis) {
+            continue;
+        }
+        for (let segment = 0; segment < segments; segment += 1) {
+            const nextSegment = closed ? (segment + 1) % segments : segment + 1;
+            if (currentOnAxis) {
+                triangle(current[0], next[nextSegment], next[segment]);
+            }
+            else if (nextOnAxis) {
+                triangle(current[segment], current[nextSegment], next[0]);
+            }
+            else {
+                triangle(current[segment], current[nextSegment], next[nextSegment]);
+                triangle(current[segment], next[nextSegment], next[segment]);
+            }
+        }
+    }
+    if (!closed) {
+        const cap = triangulateLoop2(profile);
+        const at = (profileIndex, station) => vertexIndices[profileIndex][profile[profileIndex][0] <= AXIS_EPSILON ? 0 : station];
+        for (let offset = 0; offset < cap.length; offset += 3) {
+            const a = cap[offset], b = cap[offset + 1], c = cap[offset + 2];
+            triangle(at(a, 0), at(b, 0), at(c, 0));
+            triangle(at(a, segments), at(c, segments), at(b, segments));
+        }
+    }
+    return validateTriangleMesh({ positions, indices });
+};

package/dist/geometry/sampling-limits.js

@@ -0,0 +1,29 @@
+import { GeometryError } from "./errors.js";
+/** Conservative defaults; trusted callers can supply larger explicit ceilings. */
+export const defaultGeometrySamplingLimits = Object.freeze({
+    maxPathPoints: 100_000,
+    maxProfilePoints: 100_000,
+    maxSweepProfilePoints: 4_096,
+    maxCircularSegments: 512,
+});
+/** Resolves finite positive safe-integer allocation ceilings without ambient state. */
+export function resolveGeometrySamplingLimits(overrides = {}) {
+    if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides))
+        throw new GeometryError("INVALID_ARGUMENT", "Sampling limits must be an object.", {
+            operation: "geometrySamplingLimits",
+        });
+    const result = { ...defaultGeometrySamplingLimits, ...overrides };
+    for (const key of Object.keys(defaultGeometrySamplingLimits)) {
+        if (!Number.isSafeInteger(result[key]) || result[key] < (key === "maxCircularSegments" ? 3 : 1))
+            throw new GeometryError("INVALID_ARGUMENT", `${key} must be a positive safe integer${key === "maxCircularSegments" ? " of at least three" : ""}.`, { operation: "geometrySamplingLimits" });
+    }
+    return Object.freeze(result);
+}
+/** @internal Checks predictable allocations before constructing arrays or evaluating callbacks. */
+export function assertSamplingCount(count, operation, maximum, message = `Sampling requires ${count} items; the configured ceiling and array capacity allow ${Math.min(maximum, 0xffff_ffff)}.`) {
+    if (!Number.isSafeInteger(count) || count < 0 || count > maximum || count > 0xffff_ffff)
+        throw new GeometryError("COMPLEXITY_LIMIT", message, {
+            operation,
+            details: { requiredCount: count, allowedCount: Math.min(maximum, 0xffff_ffff) },
+        });
+}

package/dist/geometry/stroke-path.js

@@ -0,0 +1,181 @@
+import { GeometryError } from "./errors.js";
+import { unionPolygonGeometry } from "./polygon-clipping.js";
+import { normalizeRegion2 } from "./regions.js";
+import { resolveCircularSegments } from "./resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+const DEFAULT_MITER_LIMIT = 4;
+function fail(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokePathRegion" });
+}
+function ring(points) {
+    const result = points.map(([x, y]) => [x, y]);
+    const first = result[0];
+    const last = result.at(-1);
+    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
+        result.push([...first]);
+    }
+    return result;
+}
+function ellipsePoints(center, radius, segments) {
+    return Array.from({ length: segments }, (_, index) => {
+        const angle = (index * Math.PI * 2) / segments;
+        return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
+    });
+}
+function circlePolygon(center, radius, segments) {
+    return [ring(ellipsePoints(center, radius, segments))];
+}
+function cornerPolygon(previous, point, next, halfWidth, join) {
+    const incomingLength = Math.hypot(point[0] - previous[0], point[1] - previous[1]);
+    const outgoingLength = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const incoming = [
+        (point[0] - previous[0]) / incomingLength,
+        (point[1] - previous[1]) / incomingLength,
+    ];
+    const outgoing = [
+        (next[0] - point[0]) / outgoingLength,
+        (next[1] - point[1]) / outgoingLength,
+    ];
+    const turn = incoming[0] * outgoing[1] - incoming[1] * outgoing[0];
+    if (Math.abs(turn) <= Number.EPSILON * 8)
+        return undefined;
+    const side = turn > 0 ? -1 : 1;
+    const before = [-incoming[1] * halfWidth * side, incoming[0] * halfWidth * side];
+    const after = [-outgoing[1] * halfWidth * side, outgoing[0] * halfWidth * side];
+    const points = [point, [point[0] + before[0], point[1] + before[1]]];
+    const denominator = 1 + incoming[0] * outgoing[0] + incoming[1] * outgoing[1];
+    // The outer offset-line intersection has radius halfWidth / cos(turnAngle / 2).
+    // Apply SVG's miter ratio before division so sharp reversals cannot create an unbounded tip.
+    if (join === "miter" && denominator >= 2 / DEFAULT_MITER_LIMIT ** 2) {
+        points.push([
+            point[0] + (before[0] + after[0]) / denominator,
+            point[1] + (before[1] + after[1]) / denominator,
+        ]);
+    }
+    points.push([point[0] + after[0], point[1] + after[1]]);
+    return [ring(points)];
+}
+/** Removes consecutive points that cannot define a visible stroke segment at model scale. */
+function deduplicatePath(path, closed, width) {
+    const scale = Math.max(width, ...path.flatMap(([x, y]) => [Math.abs(x), Math.abs(y)]));
+    const tolerance = resolveGeometryTolerance(scale).linear;
+    const points = [];
+    for (const point of path) {
+        const previous = points.at(-1);
+        if (previous === undefined ||
+            Math.hypot(point[0] - previous[0], point[1] - previous[1]) > tolerance) {
+            points.push(point);
+        }
+    }
+    if (closed && points.length > 1) {
+        const first = points[0];
+        const last = points.at(-1);
+        if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= tolerance)
+            points.pop();
+    }
+    return Object.freeze(points);
+}
+/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
+export function strokePathMultiPolygon(path, options, circularSegments) {
+    const closed = options.closed ?? false;
+    const cap = options.cap ?? "butt";
+    const join = options.join ?? "miter";
+    const half = options.width / 2;
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    assertSamplingCount(path.length, "strokePathRegion", limits.maxPathPoints);
+    assertSamplingCount(circularSegments, "strokePathRegion", limits.maxCircularSegments);
+    const normalizedPath = deduplicatePath(path, closed, options.width);
+    if (normalizedPath.length < (closed ? 3 : 2))
+        return [];
+    const polygons = [];
+    const segmentCount = closed ? normalizedPath.length : normalizedPath.length - 1;
+    const joinCount = closed ? normalizedPath.length : Math.max(0, normalizedPath.length - 2);
+    const constructionVertices = segmentCount * 4 +
+        joinCount * (join === "round" ? circularSegments : join === "miter" ? 4 : 3) +
+        (!closed && cap === "round" ? 2 * circularSegments : 0);
+    assertSamplingCount(constructionVertices, "strokePathRegion", limits.maxProfilePoints);
+    for (let index = 0; index < segmentCount; index += 1) {
+        let start = normalizedPath[index];
+        let end = normalizedPath[(index + 1) % normalizedPath.length];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+        const tangent = [(end[0] - start[0]) / length, (end[1] - start[1]) / length];
+        if (!closed && cap === "square") {
+            if (index === 0)
+                start = [start[0] - tangent[0] * half, start[1] - tangent[1] * half];
+            if (index === segmentCount - 1) {
+                end = [end[0] + tangent[0] * half, end[1] + tangent[1] * half];
+            }
+        }
+        const normal = [-tangent[1] * half, tangent[0] * half];
+        polygons.push([
+            ring([
+                [start[0] + normal[0], start[1] + normal[1]],
+                [end[0] + normal[0], end[1] + normal[1]],
+                [end[0] - normal[0], end[1] - normal[1]],
+                [start[0] - normal[0], start[1] - normal[1]],
+            ]),
+        ]);
+    }
+    if (join === "round") {
+        const joinPoints = closed ? normalizedPath : normalizedPath.slice(1, -1);
+        polygons.push(...joinPoints.map((point) => circlePolygon(point, half, circularSegments)));
+    }
+    else {
+        const first = closed ? 0 : 1;
+        const end = closed ? normalizedPath.length : normalizedPath.length - 1;
+        for (let index = first; index < end; index += 1) {
+            const corner = cornerPolygon(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
+            if (corner !== undefined)
+                polygons.push(corner);
+        }
+    }
+    if (!closed && cap === "round") {
+        polygons.push(circlePolygon(normalizedPath[0], half, circularSegments), circlePolygon(normalizedPath.at(-1), half, circularSegments));
+    }
+    const result = unionPolygonGeometry(polygons);
+    const outputVertices = result.reduce((count, polygon) => count + polygon.reduce((total, contour) => total + Math.max(0, contour.length - 1), 0), 0);
+    assertSamplingCount(outputVertices, "strokePathRegion", limits.maxProfilePoints);
+    return result;
+}
+function regionFromMultiPolygon(value) {
+    return normalizeRegion2(value.map((polygon) => ({
+        outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
+        holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
+    })));
+}
+/**
+ * Converts a sampled millimetre path into the filled region covered by a centered stroke.
+ *
+ * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
+ * effective path must still contain visible length. Round caps and joins use deterministic physical
+ * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
+ * intersection, falling back to bevels above SVG's default miter limit of 4.
+ */
+export function strokePathRegion(path, options) {
+    const closed = options.closed ?? false;
+    if (!Number.isFinite(options.width) || options.width <= 0) {
+        return fail("Stroke width must be finite and greater than zero.");
+    }
+    if (path.length < (closed ? 3 : 2)) {
+        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
+    }
+    if (!path.every((point) => Number.isFinite(point[0]) && Number.isFinite(point[1]))) {
+        return fail("Stroke path coordinates must be finite.");
+    }
+    const cap = options.cap ?? "butt";
+    const join = options.join ?? "miter";
+    if (!["butt", "round", "square"].includes(cap)) {
+        return fail("Stroke cap must be butt, round, or square.");
+    }
+    if (!["bevel", "miter", "round"].includes(join)) {
+        return fail("Stroke join must be bevel, miter, or round.");
+    }
+    const circularSegments = cap === "round" || join === "round"
+        ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
+        : 3;
+    const result = strokePathMultiPolygon(path, { ...options, cap, closed, join }, circularSegments);
+    if (result.length === 0)
+        return fail("The sampled stroke path has no visible length.");
+    return regionFromMultiPolygon(result);
+}

package/dist/geometry/svg/errors.js

@@ -0,0 +1,23 @@
+import { GeometryError } from "../errors.js";
+export function invalid(operation, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+}
+export function unsupported(operation, message) {
+    throw new GeometryError("UNSUPPORTED_RUNTIME", message, { operation });
+}
+export function emptyGeometry(operation, message) {
+    throw new GeometryError("DEGENERATE_GEOMETRY", message, { operation });
+}
+export function complexity(operation, message, details) {
+    throw new GeometryError("COMPLEXITY_LIMIT", message, {
+        operation,
+        ...(details === undefined ? {} : { details }),
+    });
+}
+export function rethrowAsInvalid(operation, error) {
+    if (error instanceof GeometryError) {
+        throw error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    invalid(operation, `Invalid SVG input: ${detail}`);
+}

package/dist/geometry/svg/fill.js

@@ -0,0 +1,172 @@
+import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
+import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { assertSamplingCount } from "../sampling-limits.js";
+/** Private clipping stage with the selected execution's immutable allocation ceiling. */
+export function createBoundedSvgClipping(maximumVertices) {
+    function ring(points) {
+        const result = points.map(([x, y]) => [x, y]);
+        const first = result[0];
+        const last = result.at(-1);
+        if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1]))
+            result.push([...first]);
+        return result;
+    }
+    function ringVertexCount(value) {
+        const first = value[0];
+        const last = value.at(-1);
+        const repeatedSeam = first !== undefined && last !== undefined && first[0] === last[0] && first[1] === last[1];
+        return value.length - (repeatedSeam ? 1 : 0);
+    }
+    function multiPolygonVertexCount(value) {
+        return value.reduce((total, polygon) => total + polygon.reduce((polygonTotal, path) => polygonTotal + ringVertexCount(path), 0), 0);
+    }
+    function assertExpandedVertexCount(vertices, stage) {
+        assertSamplingCount(vertices, "preflightSvgRegion", maximumVertices, `SVG ${stage} exceeds ${maximumVertices} expanded vertices (requires ${vertices}).`);
+    }
+    function boundedMultiPolygon(value, stage) {
+        assertExpandedVertexCount(multiPolygonVertexCount(value), stage);
+        return value;
+    }
+    function boundedUnion(values, stage) {
+        const nonEmpty = values.filter((value) => value.length > 0);
+        assertExpandedVertexCount(nonEmpty.reduce((total, value) => total + multiPolygonVertexCount(value), 0), `${stage} input`);
+        return boundedMultiPolygon(unionPolygonGeometry(nonEmpty), stage);
+    }
+    function boundedXor(values, stage) {
+        const nonEmpty = values.filter((value) => value.length > 0);
+        assertExpandedVertexCount(nonEmpty.reduce((total, value) => total + multiPolygonVertexCount(value), 0), `${stage} input`);
+        return boundedMultiPolygon(xorPolygonGeometry(nonEmpty), stage);
+    }
+    function unionAll(polygons) {
+        return boundedUnion(polygons, "union output");
+    }
+    function intersectGeometry(left, right) {
+        if (left.length === 0 || right.length === 0)
+            return [];
+        assertExpandedVertexCount(multiPolygonVertexCount(left) + multiPolygonVertexCount(right), "intersection input");
+        return boundedMultiPolygon(polygonClipping.intersection(left, right), "intersection output");
+    }
+    function multiPolygonArea(value) {
+        return value.reduce((total, polygon) => {
+            const [outer, ...holes] = polygon;
+            if (outer === undefined)
+                return total;
+            return (total +
+                Math.abs(signedAreaLoop2(outer)) -
+                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0));
+        }, 0);
+    }
+    function coverageHasMultiplicity(rings, union) {
+        const summedArea = rings.reduce((total, points) => total + Math.abs(signedAreaLoop2(points)), 0);
+        const tolerance = Math.max(1, summedArea) * 1e-9;
+        return Math.abs(summedArea - multiPolygonArea(union)) > tolerance;
+    }
+    function addCoverageBits(left, right) {
+        const output = [];
+        let carry = [];
+        const inputBits = Math.max(left.length, right.length);
+        for (let index = 0; index < inputBits || carry.length > 0; index += 1) {
+            const inputs = [left[index] ?? [], right[index] ?? [], carry].filter((geometry) => geometry.length > 0);
+            if (inputs.length === 0) {
+                output.push([]);
+                carry = [];
+            }
+            else if (inputs.length === 1) {
+                output.push(inputs[0]);
+                carry = [];
+            }
+            else if (inputs.length === 2) {
+                output.push(boundedXor(inputs, "nonzero coverage XOR"));
+                carry = intersectGeometry(inputs[0], inputs[1]);
+            }
+            else {
+                output.push(boundedXor(inputs, "nonzero coverage XOR"));
+                carry = boundedUnion([
+                    intersectGeometry(inputs[0], inputs[1]),
+                    intersectGeometry(inputs[0], inputs[2]),
+                    intersectGeometry(inputs[1], inputs[2]),
+                ], "nonzero coverage carry");
+            }
+        }
+        return output;
+    }
+    function coverageBits(polygons) {
+        let level = polygons.map((polygon) => [
+            boundedUnion([[polygon]], "nonzero coverage seed"),
+        ]);
+        while (level.length > 1) {
+            const next = [];
+            for (let index = 0; index < level.length; index += 2) {
+                const left = level[index];
+                const right = level[index + 1];
+                next.push(right === undefined ? left : addCoverageBits(left, right));
+            }
+            level = next;
+        }
+        return level[0] ?? [];
+    }
+    function differingCoverage(positive, negative) {
+        const positiveUnion = boundedUnion([positive.slice()], "positive winding union");
+        const negativeUnion = boundedUnion([negative.slice()], "negative winding union");
+        if (intersectGeometry(positiveUnion, negativeUnion).length === 0) {
+            return boundedUnion([positiveUnion, negativeUnion], "disconnected winding union");
+        }
+        const positiveBits = coverageHasMultiplicity(positive.map((polygon) => polygon[0] ?? []), positiveUnion)
+            ? coverageBits(positive)
+            : [positiveUnion];
+        const negativeBits = coverageHasMultiplicity(negative.map((polygon) => polygon[0] ?? []), negativeUnion)
+            ? coverageBits(negative)
+            : [negativeUnion];
+        const differingBits = [];
+        for (let index = 0; index < Math.max(positiveBits.length, negativeBits.length); index += 1) {
+            const positiveBit = positiveBits[index] ?? [];
+            const negativeBit = negativeBits[index] ?? [];
+            if (positiveBit.length === 0)
+                differingBits.push(negativeBit);
+            else if (negativeBit.length === 0)
+                differingBits.push(positiveBit);
+            else
+                differingBits.push(boundedXor([positiveBit, negativeBit], "winding difference XOR"));
+        }
+        return boundedUnion(differingBits, "winding difference union");
+    }
+    function fillGeometry(subpaths, fillRule) {
+        const rings = subpaths
+            .filter((subpath) => subpath.points.length >= 3)
+            .map((subpath) => subpath.points);
+        if (rings.length === 0)
+            return [];
+        const polygons = rings.map((points) => [ring(points)]);
+        if (fillRule === "evenodd") {
+            return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
+        }
+        const positive = rings
+            .filter((points) => signedAreaLoop2(points) >= 0)
+            .map((points) => [ring(points)]);
+        const negative = rings
+            .filter((points) => signedAreaLoop2(points) < 0)
+            .map((points) => [ring(points)]);
+        if (positive.length === 0)
+            return boundedUnion([negative], "negative fill output");
+        if (negative.length === 0)
+            return boundedUnion([positive], "positive fill output");
+        // Compare the binary coverage counts instead of choosing one global exterior winding. This
+        // preserves disconnected opposite-winding components and nested islands while still cancelling
+        // precisely where positive and negative nonzero winding counts match.
+        return differingCoverage(positive, negative);
+    }
+    function regionFromMultiPolygon(value) {
+        return normalizeRegion2(value.map((polygon) => ({
+            outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
+            holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
+        })));
+    }
+    return {
+        assertExpandedVertexCount,
+        boundedMultiPolygon,
+        fillGeometry,
+        multiPolygonVertexCount,
+        regionFromMultiPolygon,
+        unionAll,
+    };
+}

package/dist/geometry/svg/index.js

@@ -0,0 +1 @@
+export { parseSvgDocument, parseSvgPath } from "./parser.js";

package/dist/geometry/svg/matrix.js

@@ -0,0 +1,130 @@
+import { invalid } from "./errors.js";
+export const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+export function multiplyMatrices(left, right) {
+    return [
+        left[0] * right[0] + left[2] * right[1],
+        left[1] * right[0] + left[3] * right[1],
+        left[0] * right[2] + left[2] * right[3],
+        left[1] * right[2] + left[3] * right[3],
+        left[0] * right[4] + left[2] * right[5] + left[4],
+        left[1] * right[4] + left[3] * right[5] + left[5],
+    ];
+}
+export function transformPoint(matrix, point) {
+    return [
+        matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
+        matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
+    ];
+}
+const NUMBER_PATTERN = /[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/g;
+/** Parses compact SVG number sequences while rejecting unconsumed syntax. */
+export function parseNumberSequence(value, operation) {
+    const numbers = [];
+    let end = 0;
+    NUMBER_PATTERN.lastIndex = 0;
+    for (let match = NUMBER_PATTERN.exec(value); match !== null; match = NUMBER_PATTERN.exec(value)) {
+        const separator = value.slice(end, match.index);
+        if (!/^[\s,]*$/.test(separator) ||
+            (separator.match(/,/g)?.length ?? 0) > 1 ||
+            (numbers.length === 0 && separator.includes(","))) {
+            invalid(operation, `Invalid numeric syntax near "${separator}".`);
+        }
+        const parsed = Number(match[0]);
+        if (!Number.isFinite(parsed)) {
+            invalid(operation, "SVG numeric values must be finite.");
+        }
+        numbers.push(parsed);
+        end = match.index + match[0].length;
+    }
+    if (!/^\s*$/.test(value.slice(end))) {
+        invalid(operation, "Invalid trailing numeric syntax.");
+    }
+    if (numbers.length === 0 && value.trim() !== "") {
+        invalid(operation, `Expected a numeric value, received "${value}".`);
+    }
+    return numbers;
+}
+function transformFor(name, values, operation) {
+    switch (name) {
+        case "matrix":
+            if (values.length !== 6)
+                invalid(operation, "matrix() requires six numbers.");
+            return values;
+        case "translate":
+            if (values.length < 1 || values.length > 2) {
+                invalid(operation, "translate() requires one or two numbers.");
+            }
+            return [1, 0, 0, 1, values[0] ?? 0, values[1] ?? 0];
+        case "scale": {
+            if (values.length < 1 || values.length > 2) {
+                invalid(operation, "scale() requires one or two numbers.");
+            }
+            const sx = values[0] ?? 1;
+            return [sx, 0, 0, values[1] ?? sx, 0, 0];
+        }
+        case "rotate": {
+            if (values.length !== 1 && values.length !== 3) {
+                invalid(operation, "rotate() requires an angle, optionally followed by a center.");
+            }
+            const radians = ((values[0] ?? 0) * Math.PI) / 180;
+            const rotation = [
+                Math.cos(radians),
+                Math.sin(radians),
+                -Math.sin(radians),
+                Math.cos(radians),
+                0,
+                0,
+            ];
+            if (values.length === 1)
+                return rotation;
+            const cx = values[1] ?? 0;
+            const cy = values[2] ?? 0;
+            return multiplyMatrices(multiplyMatrices([1, 0, 0, 1, cx, cy], rotation), [
+                1,
+                0,
+                0,
+                1,
+                -cx,
+                -cy,
+            ]);
+        }
+        case "skewX": {
+            if (values.length !== 1)
+                invalid(operation, "skewX() requires one angle.");
+            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
+            if (!Number.isFinite(tangent))
+                invalid(operation, "skewX() produced a non-finite matrix.");
+            return [1, 0, tangent, 1, 0, 0];
+        }
+        case "skewY": {
+            if (values.length !== 1)
+                invalid(operation, "skewY() requires one angle.");
+            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
+            if (!Number.isFinite(tangent))
+                invalid(operation, "skewY() produced a non-finite matrix.");
+            return [1, tangent, 0, 1, 0, 0];
+        }
+        default:
+            invalid(operation, `Unsupported SVG transform "${name}".`);
+    }
+}
+/** Parses an SVG transform list using standard post-multiplication order. */
+export function parseTransform(value, operation) {
+    if (value === undefined || value.trim() === "")
+        return IDENTITY_MATRIX;
+    const callPattern = /([A-Za-z]+)\s*\(([^()]*)\)/g;
+    let result = IDENTITY_MATRIX;
+    let end = 0;
+    for (let match = callPattern.exec(value); match !== null; match = callPattern.exec(value)) {
+        if (!/^[\s,]*$/.test(value.slice(end, match.index))) {
+            invalid(operation, "Malformed SVG transform list.");
+        }
+        const values = parseNumberSequence(match[2] ?? "", operation);
+        result = multiplyMatrices(result, transformFor(match[1] ?? "", values, operation));
+        end = match.index + match[0].length;
+    }
+    if (end === 0 || !/^\s*$/.test(value.slice(end))) {
+        invalid(operation, "Malformed SVG transform list.");
+    }
+    return result;
+}