@faicad/faijs 0.32.2 → 0.33.1

package/dist/primitives/svg/svg-path.js

@@ -0,0 +1,776 @@
+// ─── SVG 元素提取（将 <rect>/<circle>/… 转为 <path d>） ───
+/**
+ * 从 SVG 字符串中提取所有图形元素的 path `d` 属性。
+ *
+ * 支持：<path>, <rect>, <circle>, <ellipse>, <line>, <polyline>, <polygon>。
+ * 使用正则提取，无 DOMParser 依赖（可在 Web Worker / Node 中运行）。
+ *
+ * @param svgString - the raw SVG markup to extract paths from.
+ * @returns an array of path `d` strings.
+ */
+export function extractSvgPaths(svgString) {
+    const paths = [];
+    extractPathDAttributes(svgString, paths);
+    extractRectPaths(svgString, paths);
+    extractCirclePaths(svgString, paths);
+    extractEllipsePaths(svgString, paths);
+    extractLinePaths(svgString, paths);
+    extractPolylinePaths(svgString, paths, false);
+    extractPolylinePaths(svgString, paths, true);
+    return paths;
+}
+function extractPathDAttributes(svg, out) {
+    const re = /<path\b[^>]*\bd\s*=\s*(?:"([^"]*)"|'([^']*)')[^>]*>/gi;
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const d = m[1] ?? m[2];
+        if (d)
+            out.push(d);
+    }
+}
+function extractRectPaths(svg, out) {
+    const re = /<rect\b([^>]*)\/?>/gi;
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const attrs = parseAttrs(m[1] ?? '');
+        const x = parseFloat(attrs.x ?? '0');
+        const y = parseFloat(attrs.y ?? '0');
+        const w = parseFloat(attrs.width ?? '0');
+        const h = parseFloat(attrs.height ?? '0');
+        const rx = parseFloat(attrs.rx ?? '0');
+        const ry = parseFloat(attrs.ry ?? '0');
+        if (w <= 0 || h <= 0)
+            continue;
+        const rectTransform = attrs.transform ? parseSvgTransform(attrs.transform) : undefined;
+        if (rectTransform) {
+            const corners = [
+                [x, y], [x + w, y], [x + w, y + h], [x, y + h],
+            ];
+            const tc = corners.map(([cx, cy]) => [
+                rectTransform[0] * cx + rectTransform[2] * cy + rectTransform[4],
+                rectTransform[1] * cx + rectTransform[3] * cy + rectTransform[5],
+            ]);
+            let d = `M ${tc[0][0]},${tc[0][1]}`;
+            for (let i = 1; i < tc.length; i++)
+                d += ` L ${tc[i][0]},${tc[i][1]}`;
+            out.push(d + ' Z');
+        }
+        else if (rx > 0 || ry > 0) {
+            const r = Math.min(rx || ry, w / 2, h / 2);
+            out.push(rectToPathRounded(x, y, w, h, r));
+        }
+        else {
+            out.push(`M ${x},${y} h ${w} v ${h} h ${-w} Z`);
+        }
+    }
+}
+function rectToPathRounded(x, y, w, h, r) {
+    return [
+        `M ${x + r},${y}`,
+        `h ${w - 2 * r}`,
+        `A ${r},${r} 0 0 1 ${x + w},${y + r}`,
+        `v ${h - 2 * r}`,
+        `A ${r},${r} 0 0 1 ${x + w - r},${y + h}`,
+        `h ${-(w - 2 * r)}`,
+        `A ${r},${r} 0 0 1 ${x},${y + h - r}`,
+        `v ${-(h - 2 * r)}`,
+        `A ${r},${r} 0 0 1 ${x + r},${y}`,
+        'Z',
+    ].join(' ');
+}
+function extractCirclePaths(svg, out) {
+    const re = /<circle\b([^>]*)\/?>/gi;
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const attrs = parseAttrs(m[1] ?? '');
+        const cx = parseFloat(attrs.cx ?? '0');
+        const cy = parseFloat(attrs.cy ?? '0');
+        const r = parseFloat(attrs.r ?? '0');
+        if (r <= 0)
+            continue;
+        out.push(`M ${cx - r},${cy} A ${r},${r} 0 1 0 ${cx + r},${cy} A ${r},${r} 0 1 0 ${cx - r},${cy} Z`);
+    }
+}
+function extractEllipsePaths(svg, out) {
+    const re = /<ellipse\b([^>]*)\/?>/gi;
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const attrs = parseAttrs(m[1] ?? '');
+        const cx = parseFloat(attrs.cx ?? '0');
+        const cy = parseFloat(attrs.cy ?? '0');
+        const rx = parseFloat(attrs.rx ?? '0');
+        const ry = parseFloat(attrs.ry ?? '0');
+        if (rx <= 0 || ry <= 0)
+            continue;
+        out.push(`M ${cx - rx},${cy} A ${rx},${ry} 0 1 0 ${cx + rx},${cy} A ${rx},${ry} 0 1 0 ${cx - rx},${cy} Z`);
+    }
+}
+function extractLinePaths(svg, out) {
+    const re = /<line\b([^>]*)\/?>/gi;
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const attrs = parseAttrs(m[1] ?? '');
+        const x1 = parseFloat(attrs.x1 ?? '0');
+        const y1 = parseFloat(attrs.y1 ?? '0');
+        const x2 = parseFloat(attrs.x2 ?? '0');
+        const y2 = parseFloat(attrs.y2 ?? '0');
+        out.push(`M ${x1},${y1} L ${x2},${y2}`);
+    }
+}
+function extractPolylinePaths(svg, out, closed) {
+    const tag = closed ? 'polygon' : 'polyline';
+    const re = new RegExp(`<${tag}\\b([^>]*)\\/??>`, 'gi');
+    let m;
+    while ((m = re.exec(svg)) !== null) {
+        const attrs = parseAttrs(m[1] ?? '');
+        const pointsStr = attrs.points ?? '';
+        const nums = pointsStr.split(/[\s,]+/).filter((s) => s.length > 0).map(Number);
+        if (nums.length < 4)
+            continue;
+        let d = `M ${nums[0]},${nums[1]}`;
+        for (let i = 2; i + 1 < nums.length; i += 2) {
+            d += ` L ${nums[i]},${nums[i + 1]}`;
+        }
+        if (closed)
+            d += ' Z';
+        out.push(d);
+    }
+}
+function parseAttrs(attrStr) {
+    const attrs = {};
+    const re = /(\w[\w-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    let m;
+    while ((m = re.exec(attrStr)) !== null) {
+        attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? '';
+    }
+    return attrs;
+}
+// ─── SVG path 分词（d 属性 → 命令序列） ───
+/**
+ * 将 SVG path `d` 属性拆分为命令序列。
+ *
+ * 支持完整命令集：M/L/H/V/C/S/Q/T/A/Z（含相对形式小写）。
+ * 每个 token 保留命令字与已解析的数值参数（多参数组由消费方按命令语义切分）。
+ *
+ * @param d - the SVG path `d` attribute value.
+ * @returns the token list.
+ */
+export function tokenizeSvgPath(d) {
+    const tokens = [];
+    const re = /([MmLlHhVvCcSsQqTtAaZz])([^MmLlHhVvCcSsQqTtAaZz]*)/g;
+    let match;
+    while ((match = re.exec(d)) !== null) {
+        const command = match[1] ?? '';
+        const argStr = (match[2] ?? '').trim();
+        const args = [];
+        if (argStr) {
+            const numRe = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+            let numMatch;
+            while ((numMatch = numRe.exec(argStr)) !== null) {
+                args.push(parseFloat(numMatch[0]));
+            }
+        }
+        tokens.push({ command, args });
+    }
+    return tokens;
+}
+// ─── SVG transform 处理 ───
+/**
+ * 解析 SVG transform 字符串（仅支持 matrix 形式）。
+ * @param transformStr - 形如 `matrix(a,b,c,d,e,f)` 的变换字符串。
+ * @returns 六元仿射矩阵 [a,b,c,d,e,f]，非 matrix 形式返回 undefined。
+ */
+export function parseSvgTransform(transformStr) {
+    const m = transformStr.match(/matrix\s*\(\s*([-\d.eE+]+)\s*,\s*([-\d.eE+]+)\s*,\s*([-\d.eE+]+)\s*,\s*([-\d.eE+]+)\s*,\s*([-\d.eE+]+)\s*,\s*([-\d.eE+]+)\s*\)/);
+    if (m) {
+        return [parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]), parseFloat(m[4]), parseFloat(m[5]), parseFloat(m[6])];
+    }
+    return undefined;
+}
+/**
+ * 从 SVG 字符串中提取 `<g transform="matrix(...)">` 的变换矩阵。
+ * @param svgString - SVG 文档字符串。
+ * @returns 首个 `<g>` 的 matrix 变换（六元数组），无匹配返回 undefined。
+ */
+export function extractGroupTransform(svgString) {
+    const m = svgString.match(/<g\b[^>]*\btransform\s*=\s*(?:"([^"]*)"|'([^']*)')[^>]*>/i);
+    if (m) {
+        return parseSvgTransform(m[1] ?? m[2] ?? '');
+    }
+    return undefined;
+}
+/** 对 SVG 坐标点（Y-down）应用 2D 仿射矩阵。 */
+function applySvgTransform(p, gt) {
+    return {
+        x: gt[0] * p.x + gt[2] * p.y + gt[4],
+        y: gt[1] * p.x + gt[3] * p.y + gt[5],
+    };
+}
+// ─── 曲线几何（折线化用） ───
+/** 三次贝塞尔采样（与 three `CubicBezierCurve.getPoint` 同公式）。 */
+function cubicAt(p0, p1, p2, p3, t) {
+    const mt = 1 - t;
+    const a = mt * mt * mt;
+    const b = 3 * mt * mt * t;
+    const c = 3 * mt * t * t;
+    const d = t * t * t;
+    return {
+        x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+        y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,
+    };
+}
+/** 二次贝塞尔采样。 */
+function quadAt(p0, p1, p2, t) {
+    const mt = 1 - t;
+    return {
+        x: mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x,
+        y: mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y,
+    };
+}
+/** 三点外接圆（p0/p1/p2 共线时返回 null）。 */
+function circumcircle(p0, p1, p2) {
+    const d = 2 * (p0.x * (p1.y - p2.y) + p1.x * (p2.y - p0.y) + p2.x * (p0.y - p1.y));
+    if (Math.abs(d) < 1e-12)
+        return null;
+    const p0sq = p0.x * p0.x + p0.y * p0.y;
+    const p1sq = p1.x * p1.x + p1.y * p1.y;
+    const p2sq = p2.x * p2.x + p2.y * p2.y;
+    const cx = (p0sq * (p1.y - p2.y) + p1sq * (p2.y - p0.y) + p2sq * (p0.y - p1.y)) / d;
+    // 注意 cy 取 x 差分（与 cx 取 y 差分对称）。标准外接圆圆心公式的 y 分量为
+    // (p0sq·(p2.x−p1.x) + p1sq·(p0.x−p2.x) + p2sq·(p1.x−p0.x)) / D；
+    // 旧写法把三项整体取了相反数（得 −uy），导致圆心纵坐标翻转、采样弧绕错心、
+    // 闭合多边形有向面积自相抵消≈0，进而 svgPathToContours 把所有圆弧 SVG（圆/环/
+    // 圆角矩形）误判为“无闭合轮廓”而丢弃。
+    const cy = (p0sq * (p2.x - p1.x) + p1sq * (p0.x - p2.x) + p2sq * (p1.x - p0.x)) / d;
+    return { cx, cy, r: Math.hypot(p0.x - cx, p0.y - cy) };
+}
+/** 角度归一化到 (-π, π]。 */
+function normAngle(a) {
+    let x = a;
+    while (x > Math.PI)
+        x -= Math.PI * 2;
+    while (x <= -Math.PI)
+        x += Math.PI * 2;
+    return x;
+}
+/**
+ * SVG arc 参数 → sagitta 中点 → 三点圆弧（与 brep 链 `arcMidPoint` 同算法）。
+ * @returns 三点圆弧的中间点（SVG 坐标，Y-down）。
+ */
+function arcMidPoint(fromX, fromY, toX, toY, rx, ry, largeArc, sweepFlag) {
+    const r = Math.max(rx, ry);
+    const dx = toX - fromX;
+    const dy = toY - fromY;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const halfChord = dist / 2;
+    const sagitta = halfChord < r ? r - Math.sqrt(r * r - halfChord * halfChord) : r;
+    const sign = (largeArc !== sweepFlag ? 1 : -1) * (sweepFlag ? 1 : -1);
+    const nx = -dy / dist;
+    const ny = dx / dist;
+    const midX = (fromX + toX) / 2 + sign * sagitta * nx;
+    const midY = (fromY + toY) / 2 + sign * sagitta * ny;
+    return { x: midX, y: midY };
+}
+/** 三点圆弧按圆心角线性采样（从 start 经 mid 到 end，方向自动判定）。 */
+function sampleArcThrough(start, mid, end, segments) {
+    const c = circumcircle(start, mid, end);
+    if (!c) {
+        // 退化（共线）：直接取终点
+        return [end];
+    }
+    const a0 = Math.atan2(start.y - c.cy, start.x - c.cx);
+    const a1 = Math.atan2(mid.y - c.cy, mid.x - c.cx);
+    const a2 = Math.atan2(end.y - c.cy, end.x - c.cx);
+    const d1 = normAngle(a1 - a0);
+    const d2 = normAngle(a2 - a1);
+    let span;
+    if (d1 * d2 >= 0) {
+        span = d1 + d2;
+    }
+    else {
+        // 跨 ±π 边界：把中点的角度展开到与起点同侧后再算
+        span = d1 + d2 + (d1 > 0 ? Math.PI * 2 : -Math.PI * 2);
+    }
+    const out = [];
+    for (let i = 1; i <= segments; i++) {
+        const t = i / segments;
+        const a = a0 + span * t;
+        out.push({ x: c.cx + c.r * Math.cos(a), y: c.cy + c.r * Math.sin(a) });
+    }
+    return out;
+}
+// ─── 子路径折线化（d → 采样点集） ───
+/**
+ * 将 SVG path `d` 折线化为闭合/开放子路径的点集。
+ *
+ * - 直线（M/L/H/V）直接取点；
+ * - 三次（C/S）与二次（Q/T）贝塞尔按 `curveSegments` 段采样（与 three
+ *   `Shape.getPoints(curveSegments)` 的段数语义一致）；
+ * - 弧（A）用 sagitta 三点圆弧近似后按 `curveSegments` 段采样；
+ * - `M` 前隐式闭合（opentype/常见导出器不写 `Z` 的情形）、`Z` 显式闭合。
+ *
+ * 输出为 **SVG 原始坐标（Y-down）**；不翻转。未闭合子路径 `closed=false`。
+ *
+ * @param d - the SVG path `d` attribute.
+ * @param curveSegments - per-curve sampling segments (default 6, aligned with the editor text path).
+ * @returns the flattened subpaths.
+ */
+export function parsePathToSubpaths(d, curveSegments = 6) {
+    const tokens = tokenizeSvgPath(d);
+    const subpaths = [];
+    let cx = 0;
+    let cy = 0;
+    let sx = 0;
+    let sy = 0;
+    let prevControlX = 0;
+    let prevControlY = 0;
+    let lastCmd = '';
+    let lastPt = null;
+    let subpathStart = null;
+    let current = [];
+    function flush(closed) {
+        if (current.length === 0)
+            return;
+        subpaths.push({
+            points: current,
+            bbox: computeBBox(current),
+            signedArea: computeSignedArea(current),
+            closed,
+        });
+        current = [];
+    }
+    for (const { command, args } of tokens) {
+        const isRelative = command === command.toLowerCase();
+        const cmd = command.toUpperCase();
+        switch (cmd) {
+            case 'M': {
+                if (current.length > 0)
+                    flush(false);
+                let i = 0;
+                while (i + 1 < args.length) {
+                    const x = (isRelative ? cx : 0) + (args[i] ?? 0);
+                    const y = (isRelative ? cy : 0) + (args[i + 1] ?? 0);
+                    if (i === 0) {
+                        sx = x;
+                        sy = y;
+                        subpathStart = { x, y };
+                        current.push({ x, y });
+                    }
+                    else {
+                        const curr = { x, y };
+                        current.push(curr);
+                    }
+                    lastPt = { x, y };
+                    cx = x;
+                    cy = y;
+                    i += 2;
+                }
+                break;
+            }
+            case 'L': {
+                let i = 0;
+                while (i + 1 < args.length) {
+                    const x = (isRelative ? cx : 0) + (args[i] ?? 0);
+                    const y = (isRelative ? cy : 0) + (args[i + 1] ?? 0);
+                    current.push({ x, y });
+                    lastPt = { x, y };
+                    cx = x;
+                    cy = y;
+                    i += 2;
+                }
+                break;
+            }
+            case 'H': {
+                for (const arg of args) {
+                    const x = isRelative ? cx + arg : arg;
+                    current.push({ x, y: cy });
+                    lastPt = { x, y: cy };
+                    cx = x;
+                }
+                break;
+            }
+            case 'V': {
+                for (const arg of args) {
+                    const y = isRelative ? cy + arg : arg;
+                    current.push({ x: cx, y });
+                    lastPt = { x: cx, y };
+                    cy = y;
+                }
+                break;
+            }
+            case 'C': {
+                let i = 0;
+                while (i + 5 < args.length) {
+                    const ox = isRelative ? cx : 0;
+                    const oy = isRelative ? cy : 0;
+                    const p0 = lastPt ?? { x: ox, y: oy };
+                    const cp1 = { x: ox + (args[i] ?? 0), y: oy + (args[i + 1] ?? 0) };
+                    const cp2 = { x: ox + (args[i + 2] ?? 0), y: oy + (args[i + 3] ?? 0) };
+                    const endPt = { x: ox + (args[i + 4] ?? 0), y: oy + (args[i + 5] ?? 0) };
+                    for (let s = 1; s <= curveSegments; s++) {
+                        current.push(cubicAt(p0, cp1, cp2, endPt, s / curveSegments));
+                    }
+                    prevControlX = cp2.x;
+                    prevControlY = cp2.y;
+                    lastPt = endPt;
+                    cx = endPt.x;
+                    cy = endPt.y;
+                    i += 6;
+                }
+                break;
+            }
+            case 'S': {
+                let i = 0;
+                while (i + 3 < args.length) {
+                    const ox = isRelative ? cx : 0;
+                    const oy = isRelative ? cy : 0;
+                    const p0 = lastPt ?? { x: ox, y: oy };
+                    const cp1x = lastCmd === 'C' || lastCmd === 'S' ? 2 * cx - prevControlX : cx;
+                    const cp1y = lastCmd === 'C' || lastCmd === 'S' ? 2 * cy - prevControlY : cy;
+                    const cp2 = { x: ox + (args[i] ?? 0), y: oy + (args[i + 1] ?? 0) };
+                    const endPt = { x: ox + (args[i + 2] ?? 0), y: oy + (args[i + 3] ?? 0) };
+                    for (let s = 1; s <= curveSegments; s++) {
+                        current.push(cubicAt(p0, { x: cp1x, y: cp1y }, cp2, endPt, s / curveSegments));
+                    }
+                    prevControlX = cp2.x;
+                    prevControlY = cp2.y;
+                    lastPt = endPt;
+                    cx = endPt.x;
+                    cy = endPt.y;
+                    lastCmd = 'S';
+                    i += 4;
+                }
+                break;
+            }
+            case 'Q': {
+                let i = 0;
+                while (i + 3 < args.length) {
+                    const ox = isRelative ? cx : 0;
+                    const oy = isRelative ? cy : 0;
+                    const p0 = lastPt ?? { x: ox, y: oy };
+                    const cp = { x: ox + (args[i] ?? 0), y: oy + (args[i + 1] ?? 0) };
+                    const endPt = { x: ox + (args[i + 2] ?? 0), y: oy + (args[i + 3] ?? 0) };
+                    for (let s = 1; s <= curveSegments; s++) {
+                        current.push(quadAt(p0, cp, endPt, s / curveSegments));
+                    }
+                    prevControlX = cp.x;
+                    prevControlY = cp.y;
+                    lastPt = endPt;
+                    cx = endPt.x;
+                    cy = endPt.y;
+                    i += 4;
+                }
+                break;
+            }
+            case 'T': {
+                let i = 0;
+                while (i + 1 < args.length) {
+                    const ox = isRelative ? cx : 0;
+                    const oy = isRelative ? cy : 0;
+                    const p0 = lastPt ?? { x: ox, y: oy };
+                    const cpx = lastCmd === 'Q' || lastCmd === 'T' ? 2 * cx - prevControlX : cx;
+                    const cpy = lastCmd === 'Q' || lastCmd === 'T' ? 2 * cy - prevControlY : cy;
+                    const endPt = { x: ox + (args[i] ?? 0), y: oy + (args[i + 1] ?? 0) };
+                    for (let s = 1; s <= curveSegments; s++) {
+                        current.push(quadAt(p0, { x: cpx, y: cpy }, endPt, s / curveSegments));
+                    }
+                    prevControlX = cpx;
+                    prevControlY = cpy;
+                    lastPt = endPt;
+                    cx = endPt.x;
+                    cy = endPt.y;
+                    lastCmd = 'T';
+                    i += 2;
+                }
+                break;
+            }
+            case 'A': {
+                let i = 0;
+                while (i + 6 < args.length) {
+                    const rx = Math.abs(args[i] ?? 0);
+                    const ry = Math.abs(args[i + 1] ?? 0);
+                    const largeArc = (args[i + 3] ?? 0) !== 0;
+                    const sweepFlag = (args[i + 4] ?? 0) !== 0;
+                    const x = (isRelative ? cx : 0) + (args[i + 5] ?? 0);
+                    const y = (isRelative ? cy : 0) + (args[i + 6] ?? 0);
+                    const from = lastPt ?? { x: cx, y: cy };
+                    if (rx === 0 || ry === 0) {
+                        // 退化为直线
+                        const endPt = { x, y };
+                        current.push(endPt);
+                        lastPt = endPt;
+                    }
+                    else {
+                        const dx = x - cx;
+                        const dy = y - cy;
+                        const dist = Math.sqrt(dx * dx + dy * dy);
+                        const endPt = { x, y };
+                        if (dist < 1e-10) {
+                            // 完整圆 → 两段半圆（与 brep 链一致）
+                            const r = Math.max(rx, ry);
+                            const sweep = sweepFlag ? 1 : -1;
+                            const mid1 = { x: cx - sweep * r, y: cy + sweep * r };
+                            const opposite = { x: cx, y: cy + 2 * sweep * r };
+                            const mid2 = { x: cx + sweep * r, y: cy + sweep * r };
+                            current.push(...sampleArcThrough(from, mid1, opposite, curveSegments));
+                            current.push(...sampleArcThrough(opposite, mid2, from, curveSegments));
+                        }
+                        else {
+                            const mid = arcMidPoint(cx, cy, x, y, rx, ry, largeArc, sweepFlag);
+                            current.push(...sampleArcThrough(from, mid, endPt, curveSegments));
+                        }
+                        lastPt = endPt;
+                    }
+                    cx = x;
+                    cy = y;
+                    i += 7;
+                }
+                break;
+            }
+            case 'Z': {
+                // 闭合：若终点 ≠ 起点则补闭合点
+                if (subpathStart && lastPt &&
+                    (Math.abs(subpathStart.x - lastPt.x) > 1e-9 ||
+                        Math.abs(subpathStart.y - lastPt.y) > 1e-9)) {
+                    current.push({ x: subpathStart.x, y: subpathStart.y });
+                }
+                flush(true);
+                lastPt = subpathStart;
+                cx = sx;
+                cy = sy;
+                break;
+            }
+        }
+        if (cmd !== 'S' && cmd !== 'T') {
+            lastCmd = cmd;
+        }
+    }
+    if (current.length > 0)
+        flush(false);
+    return subpaths;
+}
+/**
+ * 计算点集的轴对齐包围盒。
+ * @param points - 二维点集（SvgPoint2 结构）。
+ * @returns { minX, minY, maxX, maxY } 包围盒。
+ */
+export function computeBBox(points) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const p of points) {
+        if (p.x < minX)
+            minX = p.x;
+        if (p.y < minY)
+            minY = p.y;
+        if (p.x > maxX)
+            maxX = p.x;
+        if (p.y > maxY)
+            maxY = p.y;
+    }
+    return { minX, minY, maxX, maxY };
+}
+/**
+ * Shoelace 有符号面积（SVG 坐标系，Y-down；正/负语义与翻转无关紧要，仅比较绝对值）。
+ * @param points - 闭合子路径的顶点序列（首尾不重复亦可，按环序求和）。
+ * @returns 有符号面积（×0.5），点数 < 3 返回 0。
+ */
+export function computeSignedArea(points) {
+    const n = points.length;
+    if (n < 3)
+        return 0;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        area += points[i].x * points[j].y - points[j].x * points[i].y;
+    }
+    return area / 2;
+}
+/**
+ * 射线法判断点是否在多边形内部（含边界视为内部由交点奇偶决定）。
+ * @param pt - 待测点。
+ * @param polygon - 多边形顶点序列（环序）。
+ * @returns true 当且仅当点在多边形内部。
+ */
+export function pointInPolygon(pt, polygon) {
+    const n = polygon.length;
+    if (n < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = polygon[i].x;
+        const yi = polygon[i].y;
+        const xj = polygon[j].x;
+        const yj = polygon[j].y;
+        const intersect = ((yi > pt.y) !== (yj > pt.y)) &&
+            (pt.x < (xj - xi) * (pt.y - yi) / (yj - yi + 1e-12) + xi);
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+/**
+ * 计算点集的算术平均中心（质心近似，仅用于嵌套分类的层级判断）。
+ * @param points - 二维点集。
+ * @returns 平均中心点。
+ */
+export function polygonCentroid(points) {
+    let cx = 0;
+    let cy = 0;
+    for (const p of points) {
+        cx += p.x;
+        cy += p.y;
+    }
+    return { x: cx / points.length, y: cy / points.length };
+}
+/**
+ * 判断 inner 包围盒是否被 outer 包围盒完全包含（用于子路径嵌套层级预筛）。
+ * @param outer - 外层包围盒。
+ * @param inner - 内层包围盒。
+ * @returns true 当且仅当 inner 落在 outer 内部。
+ */
+export function bboxContains(outer, inner) {
+    return inner.minX >= outer.minX && inner.maxX <= outer.maxX &&
+        inner.minY >= outer.minY && inner.maxY <= outer.maxY;
+}
+// ─── 孔洞分类（共享核心：点集版与 brep 链 wire 版同源） ───
+/**
+ * 嵌套分类核心：将闭合子路径分组为外轮廓 + 孔洞（evenodd 语义）。
+ *
+ * 算法：
+ * 1. 按有符号面积绝对值降序排（大轮廓优先）
+ * 2. 对每条子路径 A，找到直接包含它的最小外轮廓 B（bbox 包含 + 质心射线法）
+ * 3. 按嵌套深度奇偶分组：深度 0 为外轮廓、深度 1 为孔、深度 2 为「孔中岛」
+ *    （岛是独立的第二层外轮廓，potrace 等导出器会把落在孔洞区域内的装饰子路径
+ *    输出为独立闭合子路径，单层模型会将其丢弃导致该区域被错误镂空）、
+ *    深度 3 为岛的孔，依此类推。
+ *
+ * 返回索引分组（sorted 序），由调用方组装为自己的数据结构。
+ *
+ * @param subpaths - the closed subpaths to classify (any type with points/bbox/signedArea).
+ * @returns the nested groups referencing indices into the sorted array.
+ */
+export function classifyNested(subpaths) {
+    const sorted = [...subpaths].sort((a, b) => Math.abs(b.signedArea) - Math.abs(a.signedArea));
+    // 排序后各元素在原数组中的索引（恒等 map 会导致面积序 ≠ 原序时索引错位：
+    // 文本多字符轮廓按字符顺序进入、按面积排序后 outer/holes 全部张冠李戴）。
+    const sortedIndex = subpaths.map((_, i) => i).sort((a, b) => Math.abs(subpaths[b].signedArea) - Math.abs(subpaths[a].signedArea));
+    const parentOf = new Array(sorted.length).fill(-1);
+    for (let i = 0; i < sorted.length; i++) {
+        let bestParent = -1;
+        let bestParentArea = Infinity;
+        const centroid = polygonCentroid(sorted[i].points);
+        for (let j = 0; j < sorted.length; j++) {
+            if (i === j)
+                continue;
+            if (Math.abs(sorted[j].signedArea) <= Math.abs(sorted[i].signedArea))
+                continue;
+            if (!bboxContains(sorted[j].bbox, sorted[i].bbox))
+                continue;
+            if (!pointInPolygon(centroid, sorted[j].points))
+                continue;
+            if (Math.abs(sorted[j].signedArea) < bestParentArea) {
+                bestParentArea = Math.abs(sorted[j].signedArea);
+                bestParent = j;
+            }
+        }
+        parentOf[i] = bestParent;
+    }
+    const depthOf = new Array(sorted.length).fill(0);
+    for (let i = 0; i < sorted.length; i++) {
+        let d = 0;
+        let p = parentOf[i];
+        const seen = new Set();
+        while (p !== -1 && !seen.has(p)) {
+            seen.add(p);
+            d++;
+            p = parentOf[p];
+        }
+        depthOf[i] = d;
+    }
+    const groups = [];
+    const groupIdxOfOuter = new Map();
+    for (let i = 0; i < sorted.length; i++) {
+        if (depthOf[i] % 2 === 0) {
+            groupIdxOfOuter.set(i, groups.length);
+            groups.push({ outerIdx: sortedIndex[i], holes: [] });
+        }
+    }
+    for (let i = 0; i < sorted.length; i++) {
+        if (depthOf[i] % 2 === 1) {
+            // 深度 1（或 3/5…）：孔，挂到最近的偶数深度祖先所在的 group
+            let p = parentOf[i];
+            const seen = new Set();
+            while (p !== -1 && !seen.has(p)) {
+                seen.add(p);
+                if (depthOf[p] % 2 === 0)
+                    break;
+                p = parentOf[p];
+            }
+            const groupIdx = p === -1 ? -1 : (groupIdxOfOuter.get(p) ?? -1);
+            if (groupIdx >= 0 && groupIdx < groups.length) {
+                groups[groupIdx].holes.push(sortedIndex[i]);
+            }
+        }
+    }
+    return groups;
+}
+/**
+ * 将闭合子路径分类为外轮廓 + 孔洞的分组（点集版，供 mesh 链 `svgPathToContours` 使用）。
+ *
+ * @param subpaths - the closed subpaths to classify.
+ * @returns the outer/hole contour groups.
+ */
+export function classifyContours(subpaths) {
+    const groups = classifyNested(subpaths);
+    return groups.map((g) => ({
+        outer: subpaths[g.outerIdx].points,
+        holes: g.holes.map((h) => subpaths[h].points),
+    }));
+}
+// ─── 高层：SVG 字符串 → Y-up 轮廓 ───
+/**
+ * 将 SVG 字符串解析为 Y-up 平面轮廓（供 `extrudeShape` 消费）。
+ *
+ * 流程：提取元素 → 逐 path 折线化 → 应用 `<g transform>` → Y-down 翻转为 Y-up →
+ * evenodd 孔洞分类。退化子路径（开放/面积≈0）被过滤。
+ *
+ * @param svgText - the raw SVG source text.
+ * @param curveSegments - per-curve sampling segments (default 6).
+ * @returns the classified contours (Y-up), ready for `extrudeShape`.
+ * @throws when the SVG contains no usable closed contour.
+ */
+export function svgPathToContours(svgText, curveSegments = 6) {
+    const pathDs = extractSvgPaths(svgText);
+    if (pathDs.length === 0) {
+        throw new Error('[svg-path] No path elements found in SVG');
+    }
+    const groupTransform = extractGroupTransform(svgText);
+    const allSubpaths = [];
+    for (const d of pathDs) {
+        for (const sp of parsePathToSubpaths(d, curveSegments)) {
+            if (!sp.closed || Math.abs(sp.signedArea) < 1e-9 || sp.points.length < 3)
+                continue;
+            const pts = groupTransform ? sp.points.map((p) => applySvgTransform(p, groupTransform)) : sp.points;
+            // 翻转为 Y-up（与 core 世界坐标一致）
+            const flipped = pts.map((p) => ({ x: p.x, y: -p.y }));
+            allSubpaths.push({
+                points: flipped,
+                bbox: computeBBox(flipped),
+                signedArea: computeSignedArea(flipped),
+                closed: true,
+            });
+        }
+    }
+    if (allSubpaths.length === 0) {
+        throw new Error('[svg-path] No closed contours generated from SVG paths');
+    }
+    const groups = classifyContours(allSubpaths);
+    const contours = groups.map((g) => ({
+        outer: g.outer,
+        holes: g.holes.map((h) => h),
+    }));
+    return contours;
+}
+//# sourceMappingURL=svg-path.js.map