@metamesh/modeling 0.11.0 → 0.13.0

package/dist/geometry/svg/parser.js

@@ -1,50 +1,6 @@
-import { SaxesParser } from "saxes";
-import { complexity, emptyGeometry, invalid, rethrowAsInvalid, unsupported } from "./errors.js";
-import { multiplyMatrices, parseNumberSequence, parseTransform } from "./matrix.js";
+import { complexity, emptyGeometry, invalid } from "./errors.js";
 import { flattenSvgPath, SvgVertexBudget } from "./path.js";
-const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
-const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
-const MM_PER_PX = 25.4 / 96;
 const MAX_SVG_BYTES = 1024 * 1024;
-const MAX_XML_DEPTH = 64;
-const MAX_RENDERED_SHAPES = 10_000;
-const SUPPORTED_ELEMENTS = new Set(["svg", "g", "path", "rect", "circle", "ellipse", "polygon"]);
-const COMMON_ATTRIBUTES = new Set([
-    "class",
-    "display",
-    "fill",
-    "fill-opacity",
-    "fill-rule",
-    "id",
-    "opacity",
-    "stroke",
-    "stroke-opacity",
-    "stroke-width",
-    "style",
-    "transform",
-    "visibility",
-    "xmlns",
-]);
-const ELEMENT_ATTRIBUTES = {
-    circle: new Set(["cx", "cy", "r"]),
-    ellipse: new Set(["cx", "cy", "rx", "ry"]),
-    g: new Set(),
-    path: new Set(["d"]),
-    polygon: new Set(["points"]),
-    rect: new Set(["height", "rx", "ry", "width", "x", "y"]),
-    svg: new Set(["height", "preserveAspectRatio", "version", "viewBox", "width", "x", "y"]),
-};
-const STYLE_PROPERTIES = new Set([
-    "display",
-    "fill",
-    "fill-opacity",
-    "fill-rule",
-    "opacity",
-    "stroke",
-    "stroke-opacity",
-    "stroke-width",
-    "visibility",
-]);
 function utf8ByteLength(value) {
     let bytes = 0;
     for (let index = 0; index < value.length; index += 1) {
@@ -83,293 +39,6 @@ function parseOptions(options, operation) {
     }
     return { origin, resolution: options.resolution ?? {} };
 }
-function parseLength(value, operation) {
-    const match = /^\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*([A-Za-z%]*)\s*$/.exec(value);
-    if (match === null)
-        invalid(operation, `Invalid SVG length "${value}".`);
-    const scalar = Number(match[1]);
-    if (!Number.isFinite(scalar))
-        invalid(operation, "SVG lengths must be finite.");
-    switch ((match[2] ?? "").toLowerCase()) {
-        case "":
-        case "px":
-            return scalar;
-        case "mm":
-            return scalar / MM_PER_PX;
-        case "cm":
-            return (scalar * 10) / MM_PER_PX;
-        case "q":
-            return (scalar * 0.25) / MM_PER_PX;
-        case "in":
-            return scalar * 96;
-        case "pt":
-            return scalar * (96 / 72);
-        case "pc":
-            return scalar * 16;
-        case "%":
-            return unsupported(operation, "Percentage SVG lengths are not supported.");
-        default:
-            return unsupported(operation, `Unsupported SVG length unit "${match[2]}".`);
-    }
-}
-function parseRootPhysicalLength(value, fallbackPx, operation) {
-    return parseLength(value ?? String(fallbackPx), operation) * MM_PER_PX;
-}
-function parseViewBox(value, operation) {
-    if (value === undefined)
-        return null;
-    const numbers = parseNumberSequence(value, operation);
-    if (numbers.length !== 4)
-        invalid(operation, "viewBox must contain four numbers.");
-    const [minX = 0, minY = 0, width = 0, height = 0] = numbers;
-    if (width <= 0 || height <= 0)
-        invalid(operation, "viewBox width and height must be positive.");
-    return { height, minX, minY, width };
-}
-function viewBoxMatrix(viewBox, viewportWidth, viewportHeight, preserveAspectRatio, operation) {
-    const setting = preserveAspectRatio?.trim() || "xMidYMid meet";
-    if (setting === "none") {
-        const sx = viewportWidth / viewBox.width;
-        const sy = viewportHeight / viewBox.height;
-        return [sx, 0, 0, sy, -viewBox.minX * sx, -viewBox.minY * sy];
-    }
-    const match = /^(x(?:Min|Mid|Max)Y(?:Min|Mid|Max))(?:\s+(meet|slice))?$/.exec(setting);
-    if (match === null)
-        invalid(operation, `Invalid preserveAspectRatio value "${setting}".`);
-    const scaleX = viewportWidth / viewBox.width;
-    const scaleY = viewportHeight / viewBox.height;
-    if (match[2] === "slice") {
-        unsupported(operation, 'preserveAspectRatio="slice" requires viewport clipping, which is outside the fill-only SVG subset.');
-    }
-    const scale = Math.min(scaleX, scaleY);
-    const spareX = viewportWidth - viewBox.width * scale;
-    const spareY = viewportHeight - viewBox.height * scale;
-    const align = match[1] ?? "xMidYMid";
-    const offsetX = align.startsWith("xMin") ? 0 : align.startsWith("xMid") ? spareX / 2 : spareX;
-    const offsetY = align.endsWith("YMin") ? 0 : align.endsWith("YMid") ? spareY / 2 : spareY;
-    return [scale, 0, 0, scale, offsetX - viewBox.minX * scale, offsetY - viewBox.minY * scale];
-}
-function rootViewport(attributes, operation) {
-    const width = parseRootPhysicalLength(attributes.width, 300, operation);
-    const height = parseRootPhysicalLength(attributes.height, 150, operation);
-    if (width <= 0 || height <= 0)
-        invalid(operation, "SVG viewport dimensions must be positive.");
-    const viewBox = parseViewBox(attributes.viewBox, operation);
-    const downMatrix = viewBox === null
-        ? [MM_PER_PX, 0, 0, MM_PER_PX, 0, 0]
-        : viewBoxMatrix(viewBox, width, height, attributes.preserveAspectRatio, operation);
-    const yUp = [1, 0, 0, -1, 0, height];
-    return {
-        matrix: multiplyMatrices(yUp, downMatrix),
-        viewport: { height, width },
-    };
-}
-function nestedSvgMatrix(attributes, operation) {
-    const x = parseLength(attributes.x ?? "0", operation);
-    const y = parseLength(attributes.y ?? "0", operation);
-    const viewBox = parseViewBox(attributes.viewBox, operation);
-    if (viewBox === null)
-        return [1, 0, 0, 1, x, y];
-    const width = parseLength(attributes.width ?? String(viewBox.width), operation);
-    const height = parseLength(attributes.height ?? String(viewBox.height), operation);
-    if (width <= 0 || height <= 0)
-        invalid(operation, "Nested SVG dimensions must be positive.");
-    return multiplyMatrices([1, 0, 0, 1, x, y], viewBoxMatrix(viewBox, width, height, attributes.preserveAspectRatio, operation));
-}
-function attributeMap(tag, operation) {
-    const attributes = {};
-    const allowed = ELEMENT_ATTRIBUTES[tag.local] ?? new Set();
-    for (const attribute of Object.values(tag.attributes)) {
-        if (attribute.uri !== "" && attribute.uri !== XMLNS_NAMESPACE) {
-            unsupported(operation, `Namespaced attribute "${attribute.name}" is not supported.`);
-        }
-        const name = attribute.local === "" ? attribute.name : attribute.local;
-        if (/^on/i.test(name))
-            unsupported(operation, "SVG event handler attributes are not supported.");
-        if (name === "class")
-            unsupported(operation, "Class-based SVG styling is not supported.");
-        if (!COMMON_ATTRIBUTES.has(name) &&
-            !allowed.has(name) &&
-            !name.startsWith("data-") &&
-            !name.startsWith("aria-") &&
-            name !== "role") {
-            unsupported(operation, `Attribute "${name}" is not supported on <${tag.local}>.`);
-        }
-        attributes[name] = attribute.value;
-    }
-    return attributes;
-}
-function parseInlineStyle(value, operation) {
-    if (value === undefined || value.trim() === "")
-        return {};
-    const properties = {};
-    for (const declaration of value.split(";")) {
-        if (declaration.trim() === "")
-            continue;
-        const separator = declaration.indexOf(":");
-        if (separator <= 0)
-            invalid(operation, "Malformed inline SVG style declaration.");
-        const property = declaration.slice(0, separator).trim().toLowerCase();
-        const propertyValue = declaration.slice(separator + 1).trim();
-        if (!STYLE_PROPERTIES.has(property) ||
-            propertyValue === "" ||
-            /!\s*important/i.test(propertyValue)) {
-            unsupported(operation, `Inline SVG style property "${property}" is not supported.`);
-        }
-        properties[property] = propertyValue;
-    }
-    return properties;
-}
-function parseOpacity(value, operation) {
-    const percentage = value.trim().endsWith("%");
-    const scalar = Number(percentage ? value.trim().slice(0, -1) : value);
-    if (!Number.isFinite(scalar))
-        invalid(operation, `Invalid SVG opacity "${value}".`);
-    const normalized = percentage ? scalar / 100 : scalar;
-    return Math.min(1, Math.max(0, normalized));
-}
-function property(attributes, styles, name) {
-    return styles[name] ?? attributes[name];
-}
-function resolvePaint(parent, attributes, operation) {
-    const styles = parseInlineStyle(attributes.style, operation);
-    const inherited = (name, fallback) => {
-        const value = property(attributes, styles, name);
-        return value === undefined || value.trim() === "inherit" ? fallback : value.trim();
-    };
-    const displayValue = property(attributes, styles, "display")?.trim() ?? "inline";
-    if (displayValue !== "none" && displayValue !== "inline" && displayValue !== "block") {
-        unsupported(operation, `display="${displayValue}" is not supported.`);
-    }
-    const visibilityValue = inherited("visibility", parent.visibility);
-    if (visibilityValue !== "visible" &&
-        visibilityValue !== "hidden" &&
-        visibilityValue !== "collapse") {
-        unsupported(operation, `visibility="${visibilityValue}" is not supported.`);
-    }
-    const fillRuleValue = inherited("fill-rule", parent.fillRule);
-    if (fillRuleValue !== "nonzero" && fillRuleValue !== "evenodd") {
-        invalid(operation, `Invalid fill-rule "${fillRuleValue}".`);
-    }
-    const fill = inherited("fill", parent.fill);
-    const stroke = inherited("stroke", parent.stroke);
-    if (/url\s*\(|^(?:context-fill|context-stroke|var\s*\()/i.test(fill)) {
-        unsupported(operation, "Referenced or context-dependent SVG fill paint is not supported.");
-    }
-    if (/url\s*\(|^(?:context-fill|context-stroke|var\s*\()/i.test(stroke)) {
-        unsupported(operation, "Referenced or context-dependent SVG stroke paint is not supported.");
-    }
-    const ownOpacity = property(attributes, styles, "opacity");
-    const fillOpacity = inherited("fill-opacity", String(parent.fillOpacity));
-    const strokeOpacity = inherited("stroke-opacity", String(parent.strokeOpacity));
-    const strokeWidth = inherited("stroke-width", String(parent.strokeWidth));
-    return {
-        display: parent.display && displayValue !== "none",
-        fill,
-        fillOpacity: parseOpacity(fillOpacity, operation),
-        fillRule: fillRuleValue,
-        opacity: parent.opacity * (ownOpacity === undefined ? 1 : parseOpacity(ownOpacity, operation)),
-        stroke,
-        strokeOpacity: parseOpacity(strokeOpacity, operation),
-        strokeWidth: parseLength(strokeWidth, operation),
-        visibility: visibilityValue === "visible" ? "visible" : "hidden",
-    };
-}
-function rendered(paint) {
-    return paint.display && paint.visibility === "visible" && paint.opacity > 0;
-}
-function fillVisible(paint) {
-    const fill = paint.fill.trim().toLowerCase();
-    return rendered(paint) && paint.fillOpacity > 0 && fill !== "none" && fill !== "transparent";
-}
-function assertNoVisibleStroke(paint, operation) {
-    if (rendered(paint) &&
-        paint.strokeOpacity > 0 &&
-        paint.strokeWidth > 0 &&
-        !["none", "transparent"].includes(paint.stroke.trim().toLowerCase())) {
-        unsupported(operation, "Visible SVG strokes are not supported; expand the stroke to a fill first.");
-    }
-}
-function requireAttribute(attributes, name, operation) {
-    const value = attributes[name];
-    if (value === undefined || value.trim() === "") {
-        invalid(operation, `<${operation}> requires a non-empty ${name} attribute.`);
-    }
-    return value;
-}
-function pathForShape(name, attributes, operation) {
-    switch (name) {
-        case "path":
-            return requireAttribute(attributes, "d", operation);
-        case "polygon": {
-            const points = parseNumberSequence(requireAttribute(attributes, "points", operation), operation);
-            if (points.length % 2 !== 0)
-                invalid(operation, "Polygon points must contain x/y pairs.");
-            if (points.length < 6)
-                return null;
-            const commands = [`M ${points[0]} ${points[1]}`];
-            for (let index = 2; index < points.length; index += 2) {
-                commands.push(`L ${points[index]} ${points[index + 1]}`);
-            }
-            commands.push("Z");
-            return commands.join(" ");
-        }
-        case "circle": {
-            const cx = parseLength(attributes.cx ?? "0", operation);
-            const cy = parseLength(attributes.cy ?? "0", operation);
-            const radius = parseLength(requireAttribute(attributes, "r", operation), operation);
-            if (radius < 0)
-                invalid(operation, "Circle radius cannot be negative.");
-            if (radius === 0)
-                return null;
-            return `M ${cx - radius} ${cy} A ${radius} ${radius} 0 1 0 ${cx + radius} ${cy} A ${radius} ${radius} 0 1 0 ${cx - radius} ${cy} Z`;
-        }
-        case "ellipse": {
-            const cx = parseLength(attributes.cx ?? "0", operation);
-            const cy = parseLength(attributes.cy ?? "0", operation);
-            const rx = parseLength(requireAttribute(attributes, "rx", operation), operation);
-            const ry = parseLength(requireAttribute(attributes, "ry", operation), operation);
-            if (rx < 0 || ry < 0)
-                invalid(operation, "Ellipse radii cannot be negative.");
-            if (rx === 0 || ry === 0)
-                return null;
-            return `M ${cx - rx} ${cy} A ${rx} ${ry} 0 1 0 ${cx + rx} ${cy} A ${rx} ${ry} 0 1 0 ${cx - rx} ${cy} Z`;
-        }
-        case "rect": {
-            const x = parseLength(attributes.x ?? "0", operation);
-            const y = parseLength(attributes.y ?? "0", operation);
-            const width = parseLength(requireAttribute(attributes, "width", operation), operation);
-            const height = parseLength(requireAttribute(attributes, "height", operation), operation);
-            if (width < 0 || height < 0)
-                invalid(operation, "Rectangle dimensions cannot be negative.");
-            if (width === 0 || height === 0)
-                return null;
-            const rawRx = attributes.rx === undefined ? undefined : parseLength(attributes.rx, operation);
-            const rawRy = attributes.ry === undefined ? undefined : parseLength(attributes.ry, operation);
-            if ((rawRx ?? 0) < 0 || (rawRy ?? 0) < 0)
-                invalid(operation, "Rectangle radii cannot be negative.");
-            const rx = Math.min(rawRx ?? rawRy ?? 0, width / 2);
-            const ry = Math.min(rawRy ?? rawRx ?? 0, height / 2);
-            if (rx === 0 || ry === 0) {
-                return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
-            }
-            return [
-                `M ${x + rx} ${y}`,
-                `H ${x + width - rx}`,
-                `A ${rx} ${ry} 0 0 1 ${x + width} ${y + ry}`,
-                `V ${y + height - ry}`,
-                `A ${rx} ${ry} 0 0 1 ${x + width - rx} ${y + height}`,
-                `H ${x + rx}`,
-                `A ${rx} ${ry} 0 0 1 ${x} ${y + height - ry}`,
-                `V ${y + ry}`,
-                `A ${rx} ${ry} 0 0 1 ${x + rx} ${y}`,
-                "Z",
-            ].join(" ");
-        }
-        default:
-            return null;
-    }
-}
 function geometryBounds(groups, operation) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
@@ -427,110 +96,3 @@ export function parseSvgPath(pathData, options = {}) {
         emptyGeometry(operation, "SVG path contains no filled geometry.");
     return freezeGeometry([{ contours, fillRule }], null, origin, operation);
 }
-/**
- * Parses the supported, fill-only SVG document subset without DOM or browser dependencies.
- * Centering is deferred until the adapter has resolved and unioned all fills.
- */
-export function parseSvgDocument(svg, options = {}) {
-    const operation = "svgSection";
-    validateInputSize(svg, operation);
-    if (/&(?:#\d+|#x[\da-f]+|[A-Za-z_:][\w:.-]*);/i.test(svg)) {
-        unsupported(operation, "SVG entity references are not supported.");
-    }
-    const { origin, resolution } = parseOptions(options, operation);
-    const groups = [];
-    const frames = [];
-    const budget = new SvgVertexBudget(options.limits);
-    let viewport = null;
-    let renderedShapes = 0;
-    let sawRoot = false;
-    const parser = new SaxesParser({ xmlns: true });
-    parser.on("doctype", () => unsupported(operation, "SVG doctypes are not supported."));
-    parser.on("processinginstruction", () => unsupported(operation, "SVG processing instructions are not supported."));
-    parser.on("cdata", () => unsupported(operation, "SVG CDATA sections are not supported."));
-    parser.on("text", (text) => {
-        if (/\S/.test(text))
-            unsupported(operation, "Text content is not supported in fill-only SVG.");
-    });
-    parser.on("opentag", (tag) => {
-        if (frames.length >= MAX_XML_DEPTH) {
-            complexity(operation, `SVG nesting exceeds ${MAX_XML_DEPTH} levels.`, {
-                maxDepth: MAX_XML_DEPTH,
-            });
-        }
-        if (tag.uri !== "" && tag.uri !== SVG_NAMESPACE) {
-            unsupported(operation, `Element namespace "${tag.uri}" is not supported.`);
-        }
-        const name = tag.local;
-        if (!SUPPORTED_ELEMENTS.has(name)) {
-            unsupported(operation, `SVG element <${name}> is not supported.`);
-        }
-        if (!sawRoot && name !== "svg")
-            invalid(operation, "The document root must be an <svg> element.");
-        const attributes = attributeMap(tag, operation);
-        const parent = frames.at(-1);
-        const parentPaint = parent?.paint ?? {
-            display: true,
-            fill: "black",
-            fillOpacity: 1,
-            fillRule: "nonzero",
-            opacity: 1,
-            stroke: "none",
-            strokeOpacity: 1,
-            strokeWidth: 1,
-            visibility: "visible",
-        };
-        const paint = resolvePaint(parentPaint, attributes, operation);
-        const explicitTransform = parseTransform(attributes.transform, operation);
-        let matrix;
-        if (!sawRoot) {
-            const root = rootViewport(attributes, operation);
-            viewport = root.viewport;
-            matrix = multiplyMatrices(root.matrix, explicitTransform);
-            sawRoot = true;
-        }
-        else if (name === "svg") {
-            if (parent === undefined)
-                invalid(operation, "Nested SVG has no parent coordinate system.");
-            matrix = multiplyMatrices(parent.matrix, multiplyMatrices(explicitTransform, nestedSvgMatrix(attributes, operation)));
-        }
-        else {
-            if (parent === undefined)
-                invalid(operation, "SVG element has no root coordinate system.");
-            matrix = multiplyMatrices(parent.matrix, explicitTransform);
-        }
-        const frame = { matrix, name, paint };
-        frames.push(frame);
-        if (name === "svg" || name === "g")
-            return;
-        assertNoVisibleStroke(paint, operation);
-        if (!fillVisible(paint))
-            return;
-        renderedShapes += 1;
-        if (renderedShapes > MAX_RENDERED_SHAPES) {
-            complexity(operation, `SVG exceeds ${MAX_RENDERED_SHAPES} rendered shapes.`, {
-                maxShapes: MAX_RENDERED_SHAPES,
-            });
-        }
-        const pathData = pathForShape(name, attributes, operation);
-        if (pathData === null)
-            return;
-        const contours = flattenSvgPath(pathData, matrix, resolution, budget, operation);
-        if (contours.length > 0)
-            groups.push({ contours, fillRule: paint.fillRule });
-    });
-    parser.on("closetag", () => {
-        frames.pop();
-    });
-    try {
-        parser.write(svg).close();
-    }
-    catch (error) {
-        rethrowAsInvalid(operation, error);
-    }
-    if (!sawRoot)
-        invalid(operation, "SVG document is empty.");
-    if (frames.length !== 0)
-        invalid(operation, "SVG document has unclosed elements.");
-    return freezeGeometry(groups, viewport, origin, operation);
-}

package/dist/geometry/svg-import.js

@@ -1,6 +1,6 @@
 import { SaxesParser } from "saxes";
 import { GeometryError } from "./errors.js";
-import { regionArea, signedAreaLoop2 } from "./regions.js";
+import { regionArea, signedContourArea } from "./regions.js";
 import { resolveCircularSegments, resolveGeometryResolution, } from "./resolution.js";
 import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
 import { strokePathMultiPolygon } from "./stroke-path.js";
@@ -413,8 +413,8 @@ function transformMultiPolygon(value, matrix) {
     })));
 }
 function polygonArea(polygon) {
-    return (Math.abs(signedAreaLoop2(polygon.outer)) -
-        polygon.holes.reduce((total, hole) => total + Math.abs(signedAreaLoop2(hole)), 0));
+    return (Math.abs(signedContourArea(polygon.outer)) -
+        polygon.holes.reduce((total, hole) => total + Math.abs(signedContourArea(hole)), 0));
 }
 function loopEdgeLengths(loop) {
     return loop.map((point, index) => {

package/dist/geometry/sweeps/sweep-closed.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../errors.js";
 import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
-import { validateTriangleMesh } from "../mesh.js";
+import { validateTriangleMesh } from "../mesh/mesh.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
 import { resolveSweepScales } from "./options.js";
 import { computeSweepFrames, validateSweepOptions } from "./orientation.js";

package/dist/geometry/sweeps/sweep-mesh.js

@@ -7,7 +7,7 @@ import { buildOpenSweepMesh } from "./sweep-open.js";
  *
  * @example Sweep point data along a bent path
  * ```ts
- * const profile = rectangleLoop({ size: [6, 3] });
+ * const profile = rectangleContour({ size: [6, 3] });
  * sweepMesh(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
  *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
  * });

package/dist/geometry/sweeps/sweep-open.js

@@ -1,6 +1,6 @@
-import { triangulateLoop2 } from "../loft.js";
+import { triangulateContour } from "../loft/loft.js";
 import { add3, rotateAroundAxis3, scale3 } from "../math/vector3.js";
-import { validateTriangleMesh } from "../mesh.js";
+import { validateTriangleMesh } from "../mesh/mesh.js";
 import { resolveSweepScales } from "./options.js";
 import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
 import { planSweepStations, refineSweepStations } from "./stations.js";
@@ -29,7 +29,7 @@ export const buildOpenSweepMesh = (profile, path, options = {}) => {
         frames = refined.frames;
         twists = refined.twists;
     }
-    const caps = triangulateLoop2(profile);
+    const caps = triangulateContour(profile);
     const ringVertexCount = profile.length;
     const sideVertexCount = path.length * ringVertexCount;
     const positions = new Float32Array(sideVertexCount * 3);

package/dist/geometry/sweeps/validation.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../errors.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
-import { normalizeLoop2 } from "../regions.js";
+import { normalizeContour } from "../regions.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 import { resolveGeometryTolerance } from "../tolerance.js";
 /** @internal Normalizes simple profiles before cap triangulation or side construction. */
@@ -26,7 +26,7 @@ export function normalizeSweepProfile(profile, operation, limits = {}) {
             });
         }
     }
-    return normalizeLoop2(profile, true);
+    return normalizeContour(profile, true);
 }
 /** @internal Cleans redundant path samples and validates finite, non-degenerate centered tangents. */
 export function normalizeSweepPath(path, closed, operation, limits = {}) {

package/dist/geometry/text-fitting.js

@@ -0,0 +1,85 @@
+import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
+import { boundsSize, fitBounds } from "./bounds.js";
+import { GeometryError } from "./errors.js";
+function fail(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "fitTextLayout" });
+}
+/**
+ * Uniformly fits visible text ink inside finite XY bounds, centering it on the target.
+ * Transforms retained vector paths before sampling, so later textSection/sampleTextContours
+ * resolution remains in final millimetres. Logical advances scale without translation;
+ * line count is unchanged. The input layout is preserved.
+ *
+ * @param layout - Prepared nonempty vector text with positive visible width and height.
+ * @param target - Positioned available bounds in millimetres; both extents must be positive.
+ * @param options - Optional positive maximum scale; use 1 to shrink only.
+ * @returns A deeply immutable layout with transformed paths, ink bounds, and physical metrics.
+ * @throws GeometryError for invisible, degenerate, malformed, nonfinite, or oversized text.
+ */
+export function fitTextLayout(layout, target, options = {}) {
+    if (typeof layout !== "object" ||
+        layout === null ||
+        !Array.isArray(layout.paths) ||
+        layout.paths.length === 0 ||
+        layout.paths.length > 1000 ||
+        typeof layout.metrics !== "object" ||
+        layout.metrics === null ||
+        layout.metrics.bounds === null)
+        fail("Prepared text needs visible outlines and ink bounds, with at most 1000 paths.");
+    if (boundsSize(layout.metrics.bounds).some((extent) => extent <= 0))
+        fail("Prepared text needs positive visible width and height.");
+    const fit = fitBounds(layout.metrics.bounds, target, options);
+    const { scale, position: [x, y], } = fit;
+    let bytes = 0, outputBytes = 0, commands = 0;
+    const paths = layout.paths.map((path) => {
+        if (typeof path !== "string")
+            fail("Prepared text paths must be strings.");
+        bytes += path.length;
+        if (bytes > 1024 * 1024)
+            fail("Prepared text paths exceed 1 MiB.");
+        let parsed;
+        try {
+            parsed = new SVGPathData(path);
+        }
+        catch {
+            return fail("Prepared text contains invalid path data.");
+        }
+        commands += parsed.commands.length;
+        if (commands > 32000)
+            fail("Prepared text exceeds 32000 path commands.");
+        parsed.transform(SVGPathDataTransformer.MATRIX(scale, 0, 0, scale, x, y));
+        if (parsed.commands.some((command) => Object.values(command).some((value) => typeof value === "number" && !Number.isFinite(value))))
+            fail("Fitted text coordinates must be finite.");
+        const encoded = parsed.encode();
+        outputBytes += encoded.length;
+        if (outputBytes > 1024 * 1024)
+            fail("Fitted text paths exceed 1 MiB.");
+        return encoded;
+    });
+    if (paths.every((path) => path === ""))
+        fail("Prepared text needs visible outlines.");
+    const scaled = (value) => {
+        const result = value * scale;
+        if (!Number.isFinite(result))
+            fail("Fitted text metrics must be finite.");
+        return result;
+    };
+    const metrics = layout.metrics;
+    if (!Array.isArray(metrics.advance) ||
+        metrics.advance.length !== 2 ||
+        !Number.isSafeInteger(metrics.lineCount) ||
+        metrics.lineCount < 1)
+        fail("Prepared text needs a logical XY advance and a positive line count.");
+    return Object.freeze({
+        paths: Object.freeze(paths),
+        metrics: Object.freeze({
+            bounds: fit.bounds,
+            advance: Object.freeze([scaled(metrics.advance[0]), scaled(metrics.advance[1])]),
+            logicalWidth: scaled(metrics.logicalWidth),
+            ascent: scaled(metrics.ascent),
+            descent: scaled(metrics.descent),
+            lineHeight: scaled(metrics.lineHeight),
+            lineCount: metrics.lineCount,
+        }),
+    });
+}

package/dist/geometry/tolerance.js

@@ -18,8 +18,8 @@ const positiveFinite = (value, label) => {
  * Resolves comparison tolerances for a characteristic model scale.
  *
  * The effective linear tolerance is `max(absolute, relative * abs(scale))`.
- * Supplying a scale of zero therefore retains the absolute floor. The function
- * returns a new frozen value with finite distance and area thresholds and never mutates `options`.
+ * A zero scale retains the absolute floor. Returns a new frozen value with finite distance and
+ * area thresholds without mutating `options`.
  *
  * @param scale - Finite characteristic size in model units.
  * @param options - Optional policy overrides.

package/dist/geometry/transform-geometry.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "./errors.js";
-import { normalizeLoop2, normalizeRegion2, signedAreaLoop2 } from "./regions.js";
+import { normalizeContour, normalizeRegion, signedContourArea } from "./regions.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
 import { applyTransformPoint3, validateTransform3 } from "./transform3.js";
 /** Applies an affine transform to a 3D path without mutating its points. */
@@ -27,15 +27,15 @@ export function transformPath2(path, transform, tolerance = {}) {
  *
  * Reflections reverse the point order automatically through normalization.
  */
-export function transformLoop2(loop, transform, tolerance = {}) {
-    const counterClockwise = signedAreaLoop2(loop) > 0;
-    const normalized = normalizeLoop2(loop, counterClockwise, tolerance);
-    return normalizeLoop2(transformPath2(normalized, transform, tolerance), counterClockwise, tolerance);
+export function transformContour(loop, transform, tolerance = {}) {
+    const counterClockwise = signedContourArea(loop) > 0;
+    const normalized = normalizeContour(loop, counterClockwise, tolerance);
+    return normalizeContour(transformPath2(normalized, transform, tolerance), counterClockwise, tolerance);
 }
 /** Transforms an explicit outer/hole region with reflection-safe winding correction. */
-export function transformRegion2(region, transform, tolerance = {}) {
-    return normalizeRegion2(region.map((polygon) => ({
-        holes: polygon.holes.map((hole) => transformLoop2(hole, transform, tolerance)),
-        outer: transformLoop2(polygon.outer, transform, tolerance),
+export function transformRegion(region, transform, tolerance = {}) {
+    return normalizeRegion(region.map((polygon) => ({
+        holes: polygon.holes.map((hole) => transformContour(hole, transform, tolerance)),
+        outer: transformContour(polygon.outer, transform, tolerance),
     })), tolerance);
 }