@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/geometry/svg/parser.js

@@ -0,0 +1,536 @@
+import { SaxesParser } from "saxes";
+import { complexity, emptyGeometry, invalid, rethrowAsInvalid, unsupported } from "./errors.js";
+import { multiplyMatrices, parseNumberSequence, parseTransform } from "./matrix.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) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x7f)
+            bytes += 1;
+        else if (code <= 0x7ff)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index += 1;
+            }
+            else
+                bytes += 3;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function validateInputSize(value, operation) {
+    const bytes = utf8ByteLength(value);
+    if (bytes > MAX_SVG_BYTES) {
+        complexity(operation, `SVG input exceeds ${MAX_SVG_BYTES} UTF-8 bytes.`, {
+            actualBytes: bytes,
+            maxBytes: MAX_SVG_BYTES,
+        });
+    }
+}
+function parseOptions(options, operation) {
+    const origin = options.origin ?? "center";
+    if (origin !== "center" && origin !== "document") {
+        invalid(operation, 'origin must be either "center" or "document".');
+    }
+    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;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const group of groups) {
+        for (const contour of group.contours) {
+            for (const point of contour) {
+                minX = Math.min(minX, point[0]);
+                minY = Math.min(minY, point[1]);
+                maxX = Math.max(maxX, point[0]);
+                maxY = Math.max(maxY, point[1]);
+            }
+        }
+    }
+    if (!Number.isFinite(minX))
+        emptyGeometry(operation, "SVG contains no filled geometry.");
+    return { max: [maxX, maxY], min: [minX, minY] };
+}
+function freezeGeometry(groups, viewport, origin, operation) {
+    const frozenGroups = groups.map((group) => Object.freeze({
+        contours: Object.freeze(group.contours.map((contour) => Object.freeze(contour.map((point) => Object.freeze([point[0], point[1]]))))),
+        fillRule: group.fillRule,
+    }));
+    const bounds = geometryBounds(frozenGroups, operation);
+    const translation = [0, 0];
+    return Object.freeze({
+        bounds: Object.freeze({
+            max: Object.freeze(bounds.max),
+            min: Object.freeze(bounds.min),
+        }),
+        groups: Object.freeze(frozenGroups),
+        placement: Object.freeze({ origin, translation: Object.freeze(translation) }),
+        viewport: viewport === null ? null : Object.freeze({ ...viewport }),
+    });
+}
+/**
+ * Parses one SVG path-data string into deterministic millimetre, Y-up fill contours.
+ * Centering is deferred until the adapter has resolved and unioned all fills.
+ */
+export function parseSvgPath(pathData, options = {}) {
+    const operation = "svgPathSection";
+    validateInputSize(pathData, operation);
+    const { origin, resolution } = parseOptions(options, operation);
+    const fillRule = options.fillRule ?? "nonzero";
+    if (fillRule !== "nonzero" && fillRule !== "evenodd") {
+        invalid(operation, 'fillRule must be either "nonzero" or "evenodd".');
+    }
+    const scale = options.scale ?? 1;
+    if (!Number.isFinite(scale) || scale <= 0)
+        invalid(operation, "scale must be finite and positive.");
+    const budget = new SvgVertexBudget(options.limits);
+    const contours = flattenSvgPath(pathData, [scale, 0, 0, -scale, 0, 0], resolution, budget, operation);
+    if (contours.length === 0)
+        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);
+}