documonster 0.16.0 → 0.16.1

package/README.md

@@ -13,7 +13,7 @@ Documonster is a zero-dependency TypeScript toolkit for spreadsheets and documen
 - **AI-Friendly** — Clean, consistent API designed for AI coding agents. Every module has comprehensive documentation and runnable examples for AI to learn from. An [MCP server](packages/mcp/README.md) is available for AI clients that need to work on real files
 - **Zero Runtime Dependencies** — Pure TypeScript, no external packages
 - **Nine Modules** — Excel, Word, Formula, PDF, CSV, Markdown, XML, Archive, Stream
-- **Cross-Platform** — Node.js 22.13+, Bun, Chrome 89+, Firefox 102+, Safari 14.1+
+- **Cross-Platform** — Node.js LTS + Current (22, 24, 26), Bun latest, Chrome 98+, Firefox 102+, Safari 15.4+
 - **ESM only** — Native ES Modules with full tree-shaking; CommonJS consumers `require()` it unchanged on Node >= 22.13
 
 ## Modules
@@ -211,7 +211,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script tag (no bundler) — one IIFE per module, each under the shared `Documonster` global -->
-<script src="https://unpkg.com/documonster@0.16.0/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.16.1/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();
@@ -246,13 +246,24 @@ For older browsers without native `CompressionStream` API, Documonster automatic
 
 ## Requirements
 
-- **Node.js >= 22.13.0**
-- **Bun >= 1.0**
+| Runtime    | Supported         |
+| ---------- | ----------------- |
+| Node.js 22 | LTS — floor 22.13 |
+| Node.js 24 | LTS               |
+| Node.js 26 | Current           |
+| Bun        | latest            |
+
+| Browser | Minimum Version     |
+| ------- | ------------------- |
+| Chrome  | 98+ (February 2022) |
+| Edge    | 98+ (February 2022) |
+| Firefox | 102+ (June 2022)    |
+| Safari  | 15.4+ (March 2022)  |
+| Opera   | 84+ (February 2022) |
 
 The package is ESM-only. Nothing changes for Node ESM, a bundler or a `<script>` tag, and a
 CommonJS `require()` call site is unchanged too — Node loads an ES module through `require()`
-from 22.12, and stops printing an experimental warning about it from 22.13, which is why that
-is the floor.
+from 22.12, and stops warning about it from 22.13, which is why the floor is that patch.
 
 <details>
 <summary>Using it from TypeScript with <code>module: node16</code></summary>
@@ -298,14 +309,6 @@ Vitest needs no configuration.
 
 </details>
 
-| Browser | Minimum Version    |
-| ------- | ------------------ |
-| Chrome  | 89+ (March 2021)   |
-| Edge    | 89+ (March 2021)   |
-| Firefox | 102+ (June 2022)   |
-| Safari  | 14.1+ (April 2021) |
-| Opera   | 75+ (March 2021)   |
-
 ## Links
 
 - 🏠 [GitHub Repository](https://github.com/documonster/documonster)

package/README_zh.md

@@ -13,7 +13,7 @@ Documonster 是一个零依赖的 TypeScript 电子表格和文档工具包：
 - **AI 友好** — 简洁一致的 API,专为 AI 编程助手设计。每个模块都配有完整的文档和可运行的示例供 AI 学习。另提供 [MCP 服务器](packages/mcp/README.md),供需要操作真实文件的 AI 客户端使用
 - **零运行时依赖** — 纯 TypeScript,无外部包
 - **九大模块** — Excel、Word、Formula、PDF、CSV、Markdown、XML、Archive、Stream
-- **跨平台** — Node.js 22.13+、Bun、Chrome 89+、Firefox 102+、Safari 14.1+
+- **跨平台** — Node.js LTS + Current（22、24、26）、Bun latest、Chrome 98+、Firefox 102+、Safari 15.4+
 - **纯 ESM** — 原生 ES Modules,完整 tree-shaking;CommonJS 消费者在 Node >= 22.13 上写法不变,直接 `require()`
 
 ## 模块
@@ -198,7 +198,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script 标签（无需打包工具）— 每个模块一个 IIFE，共享同一个 `Documonster` 全局 -->
-<script src="https://unpkg.com/documonster@0.16.0/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.16.1/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();
@@ -231,12 +231,24 @@ URL 中的版本号是刻意锁定的：不锁版本的 `unpkg.com/documonster/
 
 ## 系统要求
 
-- **Node.js >= 22.13.0**
-- **Bun >= 1.0**
-
-本包是纯 ESM。Node ESM、打包工具、`<script>` 标签一切不变;CommonJS 的 `require()` 写法也
-不变——Node 从 22.12 起支持用 `require()` 加载 ES 模块,从 22.13 起不再为此打印实验特性警告,
-所以下限定在 22.13。
+| 运行时     | 支持范围          |
+| ---------- | ----------------- |
+| Node.js 22 | LTS —— 下限 22.13 |
+| Node.js 24 | LTS               |
+| Node.js 26 | Current           |
+| Bun        | latest            |
+
+| 浏览器  | 最低版本              |
+| ------- | --------------------- |
+| Chrome  | 98+（2022 年 2 月）   |
+| Edge    | 98+（2022 年 2 月）   |
+| Firefox | 102+（2022 年 6 月）  |
+| Safari  | 15.4+（2022 年 3 月） |
+| Opera   | 84+（2022 年 2 月）   |
+
+本包是纯 ESM。Node ESM、打包工具、`<script>` 标签一切不变；CommonJS 的 `require()` 写法也
+不变 —— Node 从 22.12 起支持用 `require()` 加载 ES 模块，从 22.13 起不再为此打印警告，所以
+下限定在这个补丁版本。
 
 <details>
 <summary>TypeScript 用 <code>module: node16</code> 时</summary>
@@ -279,14 +291,6 @@ Vitest 无需任何配置。
 
 </details>
 
-| 浏览器  | 最低版本           |
-| ------- | ------------------ |
-| Chrome  | 89+（2021年3月）   |
-| Edge    | 89+（2021年3月）   |
-| Firefox | 102+（2022年6月）  |
-| Safari  | 14.1+（2021年4月） |
-| Opera   | 75+（2021年3月）   |
-
 ## 链接
 
 - 🏠 [GitHub 仓库](https://github.com/documonster/documonster)

package/dist/esm/modules/archive/zip/zip-archive.js

@@ -1,3 +1,4 @@
+import { hasDeflateRawCompressionStream } from "../compression/compress.base.js";
 import { crc32Finalize, crc32Update } from "#platform/modules/archive/compression/crc32";
 import { ByteQueue } from "../core/byte-queue.js";
 import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS, REPRODUCIBLE_ZIP_MOD_TIME } from "../core/defaults.js";
@@ -14,6 +15,28 @@ import { buildZipDeflateFileOptions } from "./zip-entry-options.js";
 import { createZipOperation } from "./zip-output-pipeline.js";
 import { stringToUint8Array as encodeUtf8 } from "../../../utils/binary.js";
 import { isNode } from "../../../utils/env.js";
+/**
+ * Decide whether {@link ZipArchive.bytes} may take the browser Blob fast path,
+ * which streams each source instead of materialising every Blob through
+ * `Blob.arrayBuffer()`.
+ *
+ * A pure function because `isNode` is one of its terms, so the decision cannot
+ * be reached from a Node test otherwise.
+ *
+ * `hasDeflateRawCompressionStream` is a thunk so a STORE-only archive never
+ * consults it: the probe constructs a `CompressionStream`, and an archive with
+ * `needsDeflate: false` neither needs the codec nor may be refused on it.
+ * Chromium 80–102 has the class but not the `deflate-raw` format.
+ */
+export function canUseBrowserBlobFastPath(facts) {
+    if (facts.isNode || !facts.hasBlobSource || !facts.allSourcesInMemory) {
+        return false;
+    }
+    if (facts.smartStore || facts.zip64Requested) {
+        return false;
+    }
+    return !facts.needsDeflate || facts.hasDeflateRawCompressionStream();
+}
 export class ZipArchive {
     constructor(options = {}) {
         this._entries = [];
@@ -291,13 +314,20 @@ export class ZipArchive {
         }
         const allSourcesInMemory = this._entries.every(e => isInMemoryArchiveSource(e.source));
         const hasBlobSource = typeof Blob !== "undefined" && this._entries.some(e => e.source instanceof Blob);
-        // Browser fast path: stream Blob sources through CompressionStream
-        const canUseBrowserFastPath = !isNode() &&
-            hasBlobSource &&
-            !this._options.smartStore &&
-            this._options.zip64 !== true &&
-            typeof CompressionStream !== "undefined";
-        if (canUseBrowserFastPath && allSourcesInMemory) {
+        // Browser fast path: stream Blob sources instead of materialising them.
+        // `needsDeflate` mirrors the per-entry `level > 0` test inside
+        // `_browserStreamingBytes`, which is the only thing there that reaches
+        // for `CompressionStream("deflate-raw")`.
+        const needsDeflate = this._entries.some(e => (e.options?.level ?? this._options.level) > 0);
+        if (canUseBrowserBlobFastPath({
+            isNode: isNode(),
+            hasBlobSource,
+            allSourcesInMemory,
+            smartStore: this._options.smartStore,
+            zip64Requested: this._options.zip64 === true,
+            needsDeflate,
+            hasDeflateRawCompressionStream
+        })) {
             try {
                 return await this._browserStreamingBytes();
             }

package/dist/esm/modules/excel/chart/chart-handle.js

@@ -1334,10 +1334,10 @@ function _chartExtractFirstRunProperties(c, title) {
     return undefined;
 }
 /**
- * Deep-clone a chart model. Uses `structuredClone` which is always available
- * in our supported environments (Node 22+, all modern browsers) and handles
- * the `Uint8Array` captured on {@link ChartExModel.rawXml} correctly — the
- * older `JSON.parse(JSON.stringify(...))` fallback stripped the typed-array
+ * Deep-clone a chart model. `structuredClone` is available in every supported
+ * environment and preserves the `Uint8Array` values on
+ * {@link ChartExModel.externalParts}; the older
+ * `JSON.parse(JSON.stringify(...))` fallback stripped the typed-array
  * prototype and corrupted round-trip data.
  */
 function deepClone(obj) {

package/dist/esm/modules/excel/chart/render/chart-renderer.js

@@ -1,5 +1,4 @@
-import { encodePng, withPngDpi } from "../../../archive/png.js";
-import { BasicRasterCanvas } from "../../../draw/raster/canvas.js";
+import { withPngDpi } from "../../../archive/png.js";
 import { renderDrawList } from "../../../draw/render.js";
 import { toSvg } from "../../../draw/svg.js";
 import { createChartPdfDrawSurface } from "./chart-pdf-draw-surface.js";
@@ -7,7 +6,6 @@ import { rasterizeDrawList } from "./draw-raster-png.js";
 import { sceneToDrawList } from "./scene-to-draw.js";
 import { AXIS_COLOR, COLORS, DEFAULT_HEIGHT, DEFAULT_WIDTH, GRID_COLOR, clamp01, densifySparsePoints, estimateTextWidth, fmt, interpolateColor, normalizeHex6, previewShapeFillColor, previewShapeLineColor, previewShapeLineWidthPx, resolveChartColor, singleLineLabel, valueToX, valueToY } from "../shared/chart-utils.js";
 import { parseSpPr, parseTxPr, getSpPrFill, getSpPrLine, getTxPrFontSize } from "../shared/shape-properties.js";
-import { parseCssColor, parseSvgAttributes, parseSvgNumberList, parseSvgPointPairs, parseSvgRotate, parseSvgTextRuns } from "../../../../utils/svg-lex.js";
 // ---------------------------------------------------------------------------
 // Plot layout constants — extracted from getPlotRect / legendRect so the
 // spatial reasoning behind the scene builder is self-documenting.
@@ -262,7 +260,11 @@ export async function renderSvgToPng(svg, options) {
     const outputWidth = Math.max(1, Math.round(width * scale));
     const outputHeight = Math.max(1, Math.round(height * scale));
     if (typeof document === "undefined" || typeof Image === "undefined") {
-        return renderSvgToBasicPng(svg, width, height, scale, options.dpi);
+        // Unreachable in production: both callers guard on the same pair. This used
+        // to re-parse the SVG with a regex scanner, which had no callers left once
+        // the chart PNG paths started rasterising a display list directly.
+        throw new Error("renderSvgToPng needs a DOM: use renderChartPng or renderChartExPng, which " +
+            "rasterise a display list directly on Node.");
     }
     const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
     const url = URL.createObjectURL(blob);
@@ -294,381 +296,6 @@ export async function renderSvgToPng(svg, options) {
         URL.revokeObjectURL(url);
     }
 }
-/**
- * Scale a `points` list into device pixels.
- *
- * Tokenising lives in `@utils/svg-lex` so this raster path and the PDF SVG
- * importer cannot disagree about what a coordinate list means; only the scale is
- * local.
- */
-/**
- * Parse `stroke-dasharray` into device-pixel on/off lengths.
- *
- * Returns `undefined` for `none`, an empty list or an all-zero pattern, so the
- * caller keeps the cheaper solid path. An odd-length list repeats to make an even
- * cycle, which is what SVG specifies.
- */
-function parseStrokeDashArray(value, scale) {
-    if (!value || value.trim() === "none") {
-        return undefined;
-    }
-    const parts = parseSvgNumberList(value).filter(part => part >= 0);
-    if (parts.length === 0 || parts.every(part => part === 0)) {
-        return undefined;
-    }
-    const cycle = parts.length % 2 === 0 ? parts : [...parts, ...parts];
-    return cycle.map(part => part * scale);
-}
-function scaledSvgPoints(input, scale) {
-    return parseSvgPointPairs(input).map(point => ({ x: point.x * scale, y: point.y * scale }));
-}
-/**
- * Resolve a paint to 8-bit RGBA, folding in the SVG opacity attributes.
- *
- * `opacity` applies to the element as a whole and multiplies with the
- * channel-specific `fill-opacity` / `stroke-opacity`, which in turn multiply
- * with any alpha carried by the colour itself. All three used to be ignored
- * here, so a ChartEx series that emits `opacity="0.55"` rasterised fully opaque
- * on Node while the browser canvas honoured it — the same `Chart.toPNG` call
- * produced visibly different images per platform.
- */
-function rasterPaint(color, attrs, channel) {
-    const parsed = parseCssColor(color);
-    if (!parsed) {
-        return undefined;
-    }
-    let alpha = parsed.a;
-    for (const name of [channel, "opacity"]) {
-        const raw = attrs?.[name];
-        if (raw === undefined) {
-            continue;
-        }
-        const value = Number.parseFloat(raw);
-        if (Number.isFinite(value)) {
-            alpha *= value < 0 ? 0 : value > 1 ? 1 : value;
-        }
-    }
-    return [
-        Math.round(parsed.r * 255),
-        Math.round(parsed.g * 255),
-        Math.round(parsed.b * 255),
-        Math.round(Math.max(0, Math.min(1, alpha)) * 255)
-    ];
-}
-/**
- * Resolve a paint plus its opacity attributes into a single `#RRGGBBAA` token.
- *
- * The canvas primitives take a colour *string*, so folding the opacity into the
- * token keeps their signatures untouched while still compositing correctly —
- * `setPixel` already does source-over blending on the alpha channel.
- */
-function paintToken(color, attrs, channel) {
-    const rgba = rasterPaint(color, attrs, channel);
-    if (!rgba) {
-        return undefined;
-    }
-    const hex = (value) => value.toString(16).padStart(2, "0");
-    return `#${hex(rgba[0])}${hex(rgba[1])}${hex(rgba[2])}${hex(rgba[3])}`;
-}
-function renderSvgToBasicPng(svg, width, height, scale, dpi) {
-    const outputWidth = Math.max(1, Math.round(width * scale));
-    const outputHeight = Math.max(1, Math.round(height * scale));
-    const canvas = new BasicRasterCanvas(outputWidth, outputHeight);
-    const tagRe = /<(rect|line|circle|polyline|polygon|path)\b[^>]*>|<text\b[^>]*>[\s\S]*?<\/text>/g;
-    let match;
-    while ((match = tagRe.exec(svg)) !== null) {
-        const tag = match[0];
-        const name = tag.startsWith("<text") ? "text" : match[1];
-        const attrs = parseSvgAttributes(tag);
-        // Resolve paint once per element so `opacity` / `fill-opacity` /
-        // `stroke-opacity` reach the canvas. They used to be dropped entirely here.
-        const fillPaint = paintToken(attrs.fill, attrs, "fill-opacity");
-        const strokePaint = paintToken(attrs.stroke, attrs, "stroke-opacity");
-        // `stroke-dasharray` is emitted by the waterfall connector, the box-whisker
-        // mean line and classic dashed trendlines; it was previously dropped, so
-        // those strokes rasterised solid.
-        const dash = parseStrokeDashArray(attrs["stroke-dasharray"], scale);
-        if (name === "rect") {
-            const x = numAttr(attrs, "x") * scale;
-            const y = numAttr(attrs, "y") * scale;
-            const rectWidth = numAttr(attrs, "width", 0, width) * scale;
-            const rectHeight = numAttr(attrs, "height", 0, height) * scale;
-            const strokeWidth = numAttr(attrs, "stroke-width", 1) * scale;
-            const radius = numAttr(attrs, "rx", numAttr(attrs, "ry", 0)) * scale;
-            if (fillPaint !== undefined) {
-                if (radius > 0) {
-                    canvas.fillRoundRect(x, y, rectWidth, rectHeight, radius, fillPaint);
-                }
-                else {
-                    canvas.fillRect(x, y, rectWidth, rectHeight, fillPaint);
-                }
-            }
-            if (strokePaint !== undefined && strokeWidth > 0) {
-                canvas.strokeRect(x, y, rectWidth, rectHeight, strokePaint, strokeWidth);
-            }
-        }
-        else if (name === "line") {
-            const x1 = numAttr(attrs, "x1") * scale;
-            const y1 = numAttr(attrs, "y1") * scale;
-            const x2 = numAttr(attrs, "x2") * scale;
-            const y2 = numAttr(attrs, "y2") * scale;
-            const lineWidth = numAttr(attrs, "stroke-width", 1) * scale;
-            if (dash) {
-                canvas.drawPolyline([
-                    { x: x1, y: y1 },
-                    { x: x2, y: y2 }
-                ], strokePaint, lineWidth, dash);
-            }
-            else {
-                canvas.drawLine(x1, y1, x2, y2, strokePaint, lineWidth);
-            }
-        }
-        else if (name === "circle") {
-            canvas.fillCircle(numAttr(attrs, "cx") * scale, numAttr(attrs, "cy") * scale, numAttr(attrs, "r") * scale, fillPaint);
-            canvas.strokeCircle(numAttr(attrs, "cx") * scale, numAttr(attrs, "cy") * scale, numAttr(attrs, "r") * scale, strokePaint, numAttr(attrs, "stroke-width", 1) * scale);
-        }
-        else if (name === "polyline") {
-            canvas.drawPolyline(scaledSvgPoints(attrs.points, scale), strokePaint, numAttr(attrs, "stroke-width", 1) * scale, dash);
-        }
-        else if (name === "polygon") {
-            const points = scaledSvgPoints(attrs.points, scale);
-            canvas.fillPolygon(points, fillPaint);
-            if (points.length > 0) {
-                canvas.drawPolyline([...points, points[0]], strokePaint, numAttr(attrs, "stroke-width", 1) * scale, dash);
-            }
-        }
-        else if (name === "path") {
-            // Pie/doughnut slices emit `data-sector="cx,cy,outerR,innerR,startAngle,endAngle"`
-            // for pixel-perfect circular rendering instead of polygon approximation.
-            const sectorData = attrs["data-sector"];
-            if (sectorData) {
-                const parts = sectorData.split(",").map(Number);
-                if (parts.length === 6 && parts.every(Number.isFinite)) {
-                    const [cx, cy, outerR, innerR, startAngle, endAngle] = parts;
-                    canvas.fillSector(cx * scale, cy * scale, outerR * scale, innerR * scale, startAngle, endAngle, fillPaint);
-                }
-            }
-            else {
-                const points = parsePathPoints(attrs.d, scale);
-                canvas.fillPolygon(points, fillPaint);
-                if (points.length > 0) {
-                    canvas.drawPolyline([...points, points[0]], strokePaint, numAttr(attrs, "stroke-width", 1) * scale, dash);
-                }
-            }
-        }
-        else if (name === "text") {
-            const rotation = parseSvgRotate(attrs.transform);
-            const fontSize = numAttr(attrs, "font-size", 10);
-            const baseX = numAttr(attrs, "x");
-            const baseY = numAttr(attrs, "y");
-            const inner = tag.match(/<text\b[^>]*>([\s\S]*?)<\/text>/)?.[1] ?? "";
-            // A multi-paragraph title is emitted as `<tspan dy>` children. Stripping
-            // the markup and drawing the result as one string ran the paragraphs
-            // together ("QuarterlyRevenue"), because stripping markup removes the
-            // tags but nothing put the line break back. Walk the tspans instead so
-            // the raster matches what an SVG viewer shows.
-            for (const line of parseSvgTextRuns(inner, fontSize)) {
-                canvas.drawText((line.x ?? baseX) * scale, (baseY + line.dy) * scale, line.text, fontSize * scale, fillPaint, attrs["text-anchor"], rotation
-                    ? {
-                        angle: rotation.angle,
-                        originX: rotation.cx * scale,
-                        originY: rotation.cy * scale
-                    }
-                    : undefined);
-            }
-        }
-    }
-    return encodePng(canvas.data, outputWidth, outputHeight, { dpi });
-}
-function numAttr(attrs, name, fallback = 0, percentBase) {
-    const value = attrs[name];
-    if (value === undefined) {
-        return fallback;
-    }
-    if (value.endsWith("%")) {
-        const percent = Number.parseFloat(value);
-        return Number.isFinite(percent) && percentBase !== undefined
-            ? (percent / 100) * percentBase
-            : fallback;
-    }
-    const parsed = Number.parseFloat(value);
-    return Number.isFinite(parsed) ? parsed : fallback;
-}
-function parsePathPoints(input, scale = 1) {
-    if (!input) {
-        return [];
-    }
-    // Accept both upper and lower-case SVG commands; we lowercase via
-    // `toUpperCase` below, treating relative and absolute forms the
-    // same (caller supplies paths the renderer itself emits, which are
-    // always absolute — the tolerance is for third-party author-shape
-    // round-trips).
-    const tokens = input.match(/[MLAZ]|-?\d+(?:\.\d+)?/gi) ?? [];
-    const points = [];
-    let i = 0;
-    let current;
-    let start;
-    while (i < tokens.length) {
-        const command = tokens[i++].toUpperCase();
-        if (command === "M" || command === "L") {
-            const point = readPathPoint(tokens, i);
-            i += 2;
-            if (!point) {
-                // Malformed M/L — skip its two parameter tokens (already
-                // advanced) and continue walking the rest of the path. The
-                // previous `break` abandoned every subsequent command,
-                // silently dropping half a path for a single bad coordinate.
-                continue;
-            }
-            point.x *= scale;
-            point.y *= scale;
-            current = point;
-            start ?? (start = point);
-            points.push(point);
-        }
-        else if (command === "A") {
-            // An `A` command consumes seven parameter tokens regardless of
-            // whether the arc is successfully decoded. Advance the cursor
-            // up front so a malformed arc doesn't strand the parser on its
-            // own parameter list.
-            if (!current) {
-                i += 7;
-                continue;
-            }
-            const arc = readPathArc(tokens, i, current, scale);
-            i += 7;
-            if (!arc) {
-                continue;
-            }
-            for (const p of arc.points) {
-                points.push(p);
-            }
-            current = arc.end;
-        }
-        else if (command === "Z") {
-            if (start) {
-                points.push(start);
-            }
-        }
-        else {
-            // Unrecognised command — try to reinterpret the token as an
-            // implicit coordinate pair (SVG allows repeated coordinates
-            // after an `M` / `L`, e.g. `M 1 2 3 4` draws an implicit
-            // lineTo from (1,2) to (3,4)).
-            const numeric = Number.parseFloat(command);
-            if (!Number.isFinite(numeric) || i >= tokens.length) {
-                // Genuinely unknown token — skip and keep walking instead
-                // of abandoning the rest of the path.
-                continue;
-            }
-            const y = Number.parseFloat(tokens[i]);
-            if (!Number.isFinite(y)) {
-                continue;
-            }
-            i++;
-            current = { x: numeric * scale, y: y * scale };
-            start ?? (start = current);
-            points.push(current);
-        }
-    }
-    return points;
-}
-function readPathPoint(tokens, index) {
-    const x = Number.parseFloat(tokens[index]);
-    const y = Number.parseFloat(tokens[index + 1]);
-    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : undefined;
-}
-function readPathArc(tokens, index, from, scale) {
-    const rx = Number.parseFloat(tokens[index]);
-    const ry = Number.parseFloat(tokens[index + 1]);
-    const largeArc = Number.parseFloat(tokens[index + 3]) === 1;
-    const sweep = Number.parseFloat(tokens[index + 4]) === 1;
-    const end = readPathPoint(tokens, index + 5);
-    if (!Number.isFinite(rx) || !Number.isFinite(ry) || !end) {
-        return undefined;
-    }
-    end.x *= scale;
-    end.y *= scale;
-    return {
-        end,
-        points: approximateArcPoints(from, end, Math.max(rx, ry) * scale, largeArc, sweep)
-    };
-}
-function approximateArcPoints(start, end, radius, largeArc, sweep) {
-    const dx = end.x - start.x;
-    const dy = end.y - start.y;
-    const chord = Math.hypot(dx, dy);
-    if (!Number.isFinite(radius) || radius <= 0 || chord === 0 || chord > radius * 2) {
-        return [end];
-    }
-    const mx = (start.x + end.x) / 2;
-    const my = (start.y + end.y) / 2;
-    const halfChord = chord / 2;
-    const h = Math.sqrt(Math.max(0, radius * radius - halfChord * halfChord));
-    const nx = -dy / chord;
-    const ny = dx / chord;
-    // When the chord equals the diameter (`h ≈ 0` for a half-circle)
-    // both candidate centres coincide at the midpoint and produce
-    // `|delta| ≈ π`. The strict inequality `|delta| > π === largeArc`
-    // treats both as "not large", so the selected centre was identical
-    // regardless of `largeArc`, making a semicircle traced the wrong
-    // way round for `largeArc=true`. Use the SVG endpoint→centre
-    // parametrisation for this degenerate case and fall back to the
-    // chord-bisector approach otherwise.
-    const candidates = [
-        { x: mx + nx * h, y: my + ny * h },
-        { x: mx - nx * h, y: my - ny * h }
-    ];
-    // Prefer the candidate whose resulting arc length matches
-    // `largeArc`. Use `>=` so the exact-π boundary sorts with
-    // `largeArc=true` instead of `false`; combined with the
-    // `sweep` tie-breaker below, this routes a true semicircle to the
-    // candidate whose winding direction matches `sweep`.
-    let selected = candidates[0];
-    let bestScore = -Infinity;
-    for (const center of candidates) {
-        const delta = arcDelta(center, start, end, sweep);
-        const isLarge = Math.abs(delta) >= Math.PI - 1e-9;
-        // Score 2 when this candidate's large-arc classification agrees
-        // with the requested `largeArc`; score 1 as a half-match when we
-        // are exactly on the boundary (the `Math.abs(delta) - π` is near
-        // zero); score 0 otherwise. Picking the highest score gives us
-        // the disambiguation we need for semicircles without breaking
-        // non-boundary cases.
-        const score = isLarge === largeArc ? 2 : 1 - Math.abs(Math.abs(delta) - Math.PI);
-        if (score > bestScore) {
-            bestScore = score;
-            selected = center;
-        }
-    }
-    const startAngle = Math.atan2(start.y - selected.y, start.x - selected.x);
-    const delta = arcDelta(selected, start, end, sweep);
-    const steps = clampInt(Math.ceil((Math.abs(delta) * radius) / 3), 12, 180);
-    const points = [];
-    for (let i = 1; i <= steps; i++) {
-        const angle = startAngle + (delta * i) / steps;
-        points.push({
-            x: selected.x + Math.cos(angle) * radius,
-            y: selected.y + Math.sin(angle) * radius
-        });
-    }
-    return points;
-}
-function arcDelta(center, start, end, sweep) {
-    const startAngle = Math.atan2(start.y - center.y, start.x - center.x);
-    const endAngle = Math.atan2(end.y - center.y, end.x - center.x);
-    let delta = endAngle - startAngle;
-    if (sweep && delta < 0) {
-        delta += Math.PI * 2;
-    }
-    else if (!sweep && delta > 0) {
-        delta -= Math.PI * 2;
-    }
-    return delta;
-}
-function clampInt(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
 function normalizePngScale(scale) {
     if (scale === undefined) {
         return 1;