@metamesh/modeling 0.12.0 → 0.13.0

package/dist/geometry/profiles/profiles.js

@@ -2,17 +2,17 @@ import { GeometryError } from "../errors.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { assertPrimitiveOptions } from "../primitive-resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
-export { rectangleLoop } from "./rectangle.js";
+export { rectangleContour } from "./rectangle.js";
 /**
  * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
  *
  * @example Explicit circular point data
  * ```ts
- * circleLoop({ diameter: 20, segments: 32 });
+ * circleContour({ diameter: 20, segments: 32 });
  * ```
  */
-export const circleLoop = (options) => {
-    const operation = "circleLoop";
+export const circleContour = (options) => {
+    const operation = "circleContour";
     assertPrimitiveOptions(options, operation);
     if ((options.radius === undefined) === (options.diameter === undefined)) {
         throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or diameter.", {
@@ -44,11 +44,11 @@ export const circleLoop = (options) => {
  *
  * @example Hexagon sized to its faces
  * ```ts
- * regularPolygonLoop({ radius: 10, sides: 6, sizing: "face" });
+ * regularPolygonContour({ radius: 10, sides: 6, sizing: "face" });
  * ```
  */
-export const regularPolygonLoop = (options) => {
-    const operation = "regularPolygonLoop";
+export const regularPolygonContour = (options) => {
+    const operation = "regularPolygonContour";
     const { radius, sides, rotationDegrees = 0, sizing = "vertex" } = options;
     requireFiniteProfileValues([radius, rotationDegrees], operation);
     if (!(radius > 0)) {
@@ -72,11 +72,11 @@ export const regularPolygonLoop = (options) => {
  *
  * @example Five-point outline
  * ```ts
- * starLoop(12, 5, 6);
+ * starContour(12, 5, 6);
  * ```
  */
-export const starLoop = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
-    const operation = "starLoop";
+export const starContour = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
+    const operation = "starContour";
     requireFiniteProfileValues([outerRadius, innerRadius], operation);
     if (!(outerRadius > 0) || !(innerRadius > 0) || innerRadius >= outerRadius) {
         throw new GeometryError("INVALID_ARGUMENT", "Star radii must be positive, with the inner radius smaller than the outer.", { operation });

package/dist/geometry/profiles/rectangle.js

@@ -65,7 +65,7 @@ export function rectangleCornerSegments(corner, limits) {
     const selected = resolveModelingLimits(limits);
     const exact = corner.segments ?? corner.resolution?.circularSegments;
     if (exact !== undefined && Number.isSafeInteger(exact) && exact >= 3)
-        assertSamplingCount(exact, "rectangleLoop", selected.maxCircularSegments);
+        assertSamplingCount(exact, "rectangleContour", selected.maxCircularSegments);
     if (corner.radius === 0 &&
         corner.segments === undefined &&
         corner.resolution?.circularSegments === undefined)
@@ -83,11 +83,11 @@ export function rectangleCornerSegments(corner, limits) {
  *
  * @example Rounded rectangle outline
  * ```ts
- * rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
  * ```
  */
-export function rectangleLoop(options) {
-    const { width, height, corners, limits } = resolveRectangle(options, "rectangleLoop");
+export function rectangleContour(options) {
+    const { width, height, corners, limits } = resolveRectangle(options, "rectangleContour");
     const counts = corners.map((corner) => {
         if (corner.kind === "square")
             return 1;
@@ -95,9 +95,9 @@ export function rectangleLoop(options) {
             const intervals = rectangleCornerSegments(corner, limits);
             return corner.radius > 0 ? intervals + 1 : 1;
         }
-        return edgeTreatmentPointCount(corner, "rectangleLoop", { limits });
+        return edgeTreatmentPointCount(corner, "rectangleContour", { limits });
     });
-    requireProfileVertexCount(counts.reduce((sum, count) => sum + count, 0), 3, "rectangleLoop", limits);
+    requireProfileVertexCount(counts.reduce((sum, count) => sum + count, 0), 3, "rectangleContour", limits);
     const x = width / 2, y = height / 2;
     const vertices = [
         [x, y],
@@ -131,7 +131,7 @@ export function rectangleLoop(options) {
         }
         const samples = corner.kind === "square"
             ? [[0, 0]]
-            : sampleEdgeTreatment(corner, "rectangleLoop", { limits });
+            : sampleEdgeTreatment(corner, "rectangleContour", { limits });
         for (const [a, b] of samples)
             points.push([
                 vertices[index][0] + incoming[index][0] * a + outgoing[index][0] * b,

package/dist/geometry/profiles/shapes.js

@@ -7,33 +7,33 @@ import { requireFiniteProfileValues, requireProfileVertexCount } from "./validat
  *
  * @example Ellipse by full dimensions
  * ```ts
- * ellipseLoop({ size: [30, 20] });
+ * ellipseContour({ size: [30, 20] });
  * ```
  */
-export function ellipseLoop(options) {
-    assertPrimitiveOptions(options, "ellipseLoop");
+export function ellipseContour(options) {
+    assertPrimitiveOptions(options, "ellipseContour");
     if ((options.radius === undefined) === (options.size === undefined)) {
         throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or size tuple.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
     const dimensions = options.radius ?? options.size;
     if (!Array.isArray(dimensions) || dimensions.length !== 2) {
         throw new GeometryError("INVALID_ARGUMENT", "Ellipse dimensions must be an exact XY tuple.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
     const factor = options.radius === undefined ? 0.5 : 1;
     const radiusX = dimensions[0] * factor;
     const radiusY = dimensions[1] * factor;
-    requireFiniteProfileValues([radiusX, radiusY], "ellipseLoop");
+    requireFiniteProfileValues([radiusX, radiusY], "ellipseContour");
     if (![radiusX, radiusY].every((value) => Number.isFinite(value) && value > 0)) {
         throw new GeometryError("INVALID_ARGUMENT", "Ellipse radii must be finite and positive.", {
-            operation: "ellipseLoop",
+            operation: "ellipseContour",
         });
     }
-    const segments = resolveCircularPrimitiveSegments(Math.max(radiusX, radiusY), options, "ellipseLoop");
-    requireProfileVertexCount(segments, 3, "ellipseLoop", options.limits);
+    const segments = resolveCircularPrimitiveSegments(Math.max(radiusX, radiusY), options, "ellipseContour");
+    requireProfileVertexCount(segments, 3, "ellipseContour", options.limits);
     return Object.freeze(Array.from({ length: segments }, (_, index) => {
         const angle = (index * Math.PI * 2) / segments;
         return Object.freeze([radiusX * Math.cos(angle), radiusY * Math.sin(angle)]);

package/dist/geometry/profiles/side-profile.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { normalizeContour } from "../regions.js";
 import { resolveGeometryResolution } from "../resolution.js";
 import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
 import { requireProfileVertexCount } from "./validation.js";
@@ -135,3 +136,39 @@ export function sampleSideProfile(curve, options = {}) {
     }
     return Object.freeze(output);
 }
+/**
+ * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
+ * Adds horizontal bottom/top edges at the endpoint heights, retaining axis endpoints once.
+ * Returns a counterclockwise filled-boundary contour without a repeated seam vertex.
+ * Radii must be nonnegative; the result must enclose nonzero area without touching itself.
+ * This is a solid-body closure, not a hollow-wall or mounting-bore construction.
+ */
+export function closeToAxis(side, limits) {
+    const operation = "closeToAxis";
+    const arrayShape = Array.isArray(side);
+    if (!arrayShape || side.length < 2)
+        throw new GeometryError("INVALID_ARGUMENT", "A side outline needs at least two points.", {
+            operation,
+        });
+    requireProfileVertexCount(side.length, 2, operation, limits);
+    for (let index = 0; index < side.length; index++) {
+        const point = side[index];
+        const pointShape = Array.isArray(point) && point.length === 2;
+        if (!pointShape ||
+            !point.every(Number.isFinite) ||
+            point[0] < 0 ||
+            (index > 0 && point[1] <= side[index - 1][1]))
+            throw new GeometryError("INVALID_ARGUMENT", "Side points require finite nonnegative radii and strictly increasing heights.", { operation });
+    }
+    const first = side[0];
+    const last = side.at(-1);
+    requireProfileVertexCount(side.length + Number(first[0] !== 0) + Number(last[0] !== 0), 3, operation, limits);
+    const contour = [];
+    if (first[0] !== 0)
+        contour.push([0, first[1]]);
+    for (const point of side)
+        contour.push(point);
+    if (last[0] !== 0)
+        contour.push([0, last[1]]);
+    return normalizeContour(contour, true);
+}

package/dist/geometry/regions.js

@@ -28,7 +28,7 @@ const coordinateScale = (loop) => {
     return Math.max(maxX - minX, maxY - minY);
 };
 /** Returns the signed area of a non-duplicated loop; positive means CCW. */
-export function signedAreaLoop2(loop) {
+export function signedContourArea(loop) {
     if (loop.length === 0)
         return 0;
     const origin = loop[0];
@@ -48,7 +48,7 @@ export function signedAreaLoop2(loop) {
     return (twiceArea + correction) / 2;
 }
 /** Returns true when a point lies inside or on the boundary of a loop. */
-export function loopContainsPoint(loop, point) {
+export function contourContainsPoint(loop, point) {
     let inside = false;
     for (let index = 0, previous = loop.length - 1; index < loop.length; previous = index++) {
         const a = loop[index];
@@ -128,7 +128,7 @@ const boundedSegments = (loop, epsilon) => loop.map((a, index) => {
 const consumeIntersectionCandidate = (budget) => {
     budget.candidates += 1;
     if (budget.candidates > MAX_INTERSECTION_CANDIDATES) {
-        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion2", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
+        throw new GeometryError("COMPLEXITY_LIMIT", "Region validation exceeds the 2000000 intersection-candidate work limit.", { operation: "normalizeRegion", details: { maximumCandidates: MAX_INTERSECTION_CANDIDATES } });
     }
 };
 const boundedIntersections = (segments, epsilon, budget, sameLoop) => {
@@ -170,7 +170,7 @@ const loopsIntersect = (a, b, epsilon, budget) => a === b ||
  * result must be simple and have non-zero area. Previously validated immutable results may be
  * returned unchanged when their winding and tolerance policy match.
  */
-export function normalizeLoop2(input, counterClockwise, tolerance = {}) {
+export function normalizeContour(input, counterClockwise, tolerance = {}) {
     return normalizeLoopWithBudget(input, counterClockwise, tolerance, { candidates: 0 });
 }
 const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) => {
@@ -199,7 +199,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
     if (boundedIntersections(boundedSegments(cleaned, resolved.linear), resolved.linear, budget, true)) {
         throw new GeometryError("SELF_INTERSECTION", "A loop must not self-intersect.");
     }
-    const area = signedAreaLoop2(cleaned);
+    const area = signedContourArea(cleaned);
     if (!Number.isFinite(area)) {
         throw new GeometryError("NON_FINITE_VALUE", "Loop area must be finite.");
     }
@@ -223,7 +223,7 @@ const normalizeLoopWithBudget = (input, counterClockwise, tolerance, budget) =>
  * within its exterior and boundaries may not intersect. Previously validated immutable results
  * may be returned unchanged under the same tolerance policy.
  */
-export function normalizePolygon2(polygon, tolerance = {}) {
+export function normalizePolygon(polygon, tolerance = {}) {
     return normalizePolygonWithBudget(polygon, tolerance, { candidates: 0 });
 }
 const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
@@ -236,7 +236,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
     const epsilon = resolveGeometryTolerance(scale, policy).linear;
     for (let index = 0; index < holes.length; index += 1) {
         const hole = holes[index];
-        if (!loopContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
+        if (!contourContainsPoint(outer, hole[0]) || loopsIntersect(outer, hole, epsilon, budget)) {
             throw new GeometryError("INVALID_TOPOLOGY", "Every hole must lie inside its exterior.");
         }
     }
@@ -254,8 +254,8 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
             if (!boundsOverlap(previous, current, 2 * epsilon))
                 continue;
             if (loopsIntersect(previous.loop, current.loop, epsilon, budget) ||
-                loopContainsPoint(previous.loop, current.loop[0]) ||
-                loopContainsPoint(current.loop, previous.loop[0])) {
+                contourContainsPoint(previous.loop, current.loop[0]) ||
+                contourContainsPoint(current.loop, previous.loop[0])) {
                 throw new GeometryError("INVALID_TOPOLOGY", "Polygon holes must be disjoint.");
             }
         }
@@ -273,7 +273,7 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
  * Validates a disjoint explicit region and returns immutable normalized data.
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
-export function normalizeRegion2(region, tolerance = {}) {
+export function normalizeRegion(region, tolerance = {}) {
     const policy = resolveGeometryTolerance(1, tolerance);
     if (samePolicy(normalizedRegions.get(region), policy))
         return region;
@@ -284,8 +284,8 @@ export function normalizeRegion2(region, tolerance = {}) {
     }
     const budget = { candidates: 0 };
     const polygons = region.map((polygon) => normalizePolygonWithBudget(polygon, policy, budget));
-    const containsFilledPoint = (polygon, point) => loopContainsPoint(polygon.outer, point) &&
-        !polygon.holes.some((hole) => loopContainsPoint(hole, point));
+    const containsFilledPoint = (polygon, point) => contourContainsPoint(polygon.outer, point) &&
+        !polygon.holes.some((hole) => contourContainsPoint(hole, point));
     // Broad phase preserves exact contact semantics while avoiding pairwise loop
     // walks for separated polygons (for example many disconnected QR modules).
     const bounded = polygons
@@ -336,7 +336,7 @@ export function normalizeRegion2(region, tolerance = {}) {
  * Returns the total filled area of a normalized region in square millimetres.
  *
  * Each polygon contributes its outer-loop area minus the areas of its holes. An empty region has
- * zero area. Call {@link normalizeRegion2} first when input winding or topology is not already
+ * zero area. Call {@link normalizeRegion} first when input winding or topology is not already
  * canonical.
  *
  * @param region - Normalized disjoint polygons with CCW outers and clockwise holes.
@@ -344,8 +344,8 @@ export function normalizeRegion2(region, tolerance = {}) {
  */
 export function regionArea(region) {
     return region.reduce((total, polygon) => total +
-        Math.abs(signedAreaLoop2(polygon.outer)) -
-        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0), 0);
+        Math.abs(signedContourArea(polygon.outer)) -
+        polygon.holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedContourArea(hole)), 0), 0);
 }
 /** Returns finite axis-aligned bounds for a non-empty region. */
 export function regionBounds(region) {

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

@@ -1,10 +1,10 @@
 import { GeometryError } from "../errors.js";
-import { triangulateLoop2 } from "../loft.js";
-import { validateTriangleMesh } from "../mesh.js";
+import { triangulateContour } from "../loft/loft.js";
+import { validateTriangleMesh } from "../mesh/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 { normalizeContour } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 const AXIS_EPSILON = 1e-10;
 /**
@@ -52,7 +52,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
         maximumRadius = Math.max(maximumRadius, radius);
     }
-    profile = normalizeLoop2(profile, true);
+    profile = normalizeContour(profile, true);
     const circularSegments = resolveCircularPrimitiveSegments(maximumRadius, options, "revolveMesh");
     const closed = degrees === 360;
     const segments = closed
@@ -117,7 +117,7 @@ export const revolveMesh = (profile, options = {}) => {
         }
     }
     if (!closed) {
-        const cap = triangulateLoop2(profile);
+        const cap = triangulateContour(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];

package/dist/geometry/stroke-path.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "./errors.js";
 import { unionPolygonGeometry } from "./polygon-clipping.js";
-import { normalizeRegion2 } from "./regions.js";
+import { normalizeRegion } from "./regions.js";
 import { resolveCircularSegments } from "./resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
@@ -139,7 +139,7 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
     return result;
 }
 function regionFromMultiPolygon(value) {
-    return normalizeRegion2(value.map((polygon) => ({
+    return normalizeRegion(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])),
     })));

package/dist/geometry/svg/errors.js

@@ -2,9 +2,6 @@ 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 });
 }

package/dist/geometry/svg/fill.js

@@ -1,5 +1,5 @@
 import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { normalizeRegion, signedContourArea } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 /** Private clipping stage with the selected execution's immutable allocation ceiling. */
 export function createBoundedSvgClipping(maximumVertices) {
@@ -52,12 +52,12 @@ export function createBoundedSvgClipping(maximumVertices) {
             if (outer === undefined)
                 return total;
             return (total +
-                Math.abs(signedAreaLoop2(outer)) -
-                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0));
+                Math.abs(signedContourArea(outer)) -
+                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedContourArea(hole)), 0));
         }, 0);
     }
     function coverageHasMultiplicity(rings, union) {
-        const summedArea = rings.reduce((total, points) => total + Math.abs(signedAreaLoop2(points)), 0);
+        const summedArea = rings.reduce((total, points) => total + Math.abs(signedContourArea(points)), 0);
         const tolerance = Math.max(1, summedArea) * 1e-9;
         return Math.abs(summedArea - multiPolygonArea(union)) > tolerance;
     }
@@ -141,10 +141,10 @@ export function createBoundedSvgClipping(maximumVertices) {
             return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
         }
         const positive = rings
-            .filter((points) => signedAreaLoop2(points) >= 0)
+            .filter((points) => signedContourArea(points) >= 0)
             .map((points) => [ring(points)]);
         const negative = rings
-            .filter((points) => signedAreaLoop2(points) < 0)
+            .filter((points) => signedContourArea(points) < 0)
             .map((points) => [ring(points)]);
         if (positive.length === 0)
             return boundedUnion([negative], "negative fill output");
@@ -156,7 +156,7 @@ export function createBoundedSvgClipping(maximumVertices) {
         return differingCoverage(positive, negative);
     }
     function regionFromMultiPolygon(value) {
-        return normalizeRegion2(value.map((polygon) => ({
+        return normalizeRegion(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])),
         })));

package/dist/geometry/svg/index.js

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

package/dist/geometry/svg/matrix.js

@@ -1,5 +1,3 @@
-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],
@@ -16,115 +14,3 @@ export function transformPoint(matrix, point) {
         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;
-}