documonster 0.7.0 → 0.8.0

package/dist/browser/modules/pdf/builder/image-utils.d.ts

@@ -36,4 +36,4 @@ export declare function parseJpegDimensions(data: Uint8Array): {
  * Write an image XObject (JPEG or PNG) to the writer.
  * Returns the allocated object number.
  */
-export declare function writeImageXObject(writer: PdfWriter, data: Uint8Array, format: "jpeg" | "png"): number;
+export declare function writeImageXObject(writer: PdfWriter, data: Uint8Array, format: "jpeg" | "png", grayscale?: boolean): number;

package/dist/browser/modules/pdf/builder/image-utils.js

@@ -76,41 +76,90 @@ export function parseJpegDimensions(data) {
  * Write an image XObject (JPEG or PNG) to the writer.
  * Returns the allocated object number.
  */
-export function writeImageXObject(writer, data, format) {
+export function writeImageXObject(writer, data, format, grayscale = false) {
     if (format === "png") {
-        return writePngImageXObject(writer, data);
+        return writePngImageXObject(writer, data, grayscale);
     }
-    return writeJpegImageXObject(writer, data);
+    return writeJpegImageXObject(writer, data, grayscale);
 }
 /**
- * Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+ * Write the PostScript calculator function that converts an RGB triple to its
+ * Rec. 601 luma, and return its object number.
+ *
+ * Used as the tint transform of a `/DeviceN` space so a JPEG can be recoloured
+ * without decoding it: the samples stay untouched and the consumer applies the
+ * transform per pixel. Unlike painting a blend on top, this cannot darken
+ * transparent areas, because it *is* the color space rather than an overlay.
  */
-function writeJpegImageXObject(writer, data) {
+function writeLumaTintTransform(writer) {
     const objNum = writer.allocObject();
+    const dict = new PdfDict()
+        .set("FunctionType", "4")
+        .set("Domain", "[0 1 0 1 0 1]")
+        .set("Range", "[0 1]");
+    // Stack on entry is R G B (B on top):
+    //   0.114 mul  -> R G 0.114B
+    //   exch       -> R 0.114B G
+    //   0.587 mul  -> R 0.114B 0.587G
+    //   add        -> R (0.114B + 0.587G)
+    //   exch       -> (0.114B + 0.587G) R
+    //   0.299 mul  -> (0.114B + 0.587G) 0.299R
+    //   add        -> luma
+    const program = "{ 0.114 mul exch 0.587 mul add exch 0.299 mul add }";
+    writer.addStreamObject(objNum, dict, new TextEncoder().encode(program));
+    return objNum;
+}
+/**
+ * Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+ */
+function writeJpegImageXObject(writer, data, grayscale = false) {
     const dims = parseJpegDimensions(data);
+    // Grayscale without a JPEG decoder: keep the DCTDecode samples and reinterpret
+    // the three components through a `/DeviceN` space whose tint transform is the
+    // luma formula. Component count still matches the JPEG, as PDF requires.
+    const tintRef = grayscale ? writeLumaTintTransform(writer) : undefined;
+    const objNum = writer.allocObject();
     const dict = new PdfDict()
         .set("Type", "/XObject")
         .set("Subtype", "/Image")
         .set("Width", pdfNumber(dims.width))
         .set("Height", pdfNumber(dims.height))
-        .set("ColorSpace", "/DeviceRGB")
+        .set("ColorSpace", tintRef === undefined
+        ? "/DeviceRGB"
+        : `[/DeviceN [/C1 /C2 /C3] /DeviceGray ${pdfRef(tintRef)}]`)
         .set("BitsPerComponent", "8")
         .set("Filter", "/DCTDecode");
     writer.addStreamObject(objNum, dict, data);
     return objNum;
 }
+/** Rec. 601 luma of an 8-bit RGB triple. */
+function lumaByte(r, g, b) {
+    return Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+}
 /**
  * Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
  */
-function writePngImageXObject(writer, data) {
+function writePngImageXObject(writer, data, grayscale = false) {
     const png = decodePng(data);
     const objNum = writer.allocObject();
+    // PNG is already decoded to raw samples here, so grayscale is a real pixel
+    // conversion: collapse RGB to one luma component and switch to DeviceGray.
+    // The alpha channel lives in a separate SMask and is untouched, so transparent
+    // regions stay transparent.
+    let pixels = png.pixels;
+    if (grayscale) {
+        const gray = new Uint8Array(png.width * png.height);
+        for (let i = 0, p = 0; i < gray.length; i++, p += 3) {
+            gray[i] = lumaByte(pixels[p], pixels[p + 1], pixels[p + 2]);
+        }
+        pixels = gray;
+    }
     const dict = new PdfDict()
         .set("Type", "/XObject")
         .set("Subtype", "/Image")
         .set("Width", pdfNumber(png.width))
         .set("Height", pdfNumber(png.height))
-        .set("ColorSpace", "/DeviceRGB")
+        .set("ColorSpace", grayscale ? "/DeviceGray" : "/DeviceRGB")
         .set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
     if (png.alpha) {
         const smaskObjNum = writer.allocObject();
@@ -124,6 +173,6 @@ function writePngImageXObject(writer, data) {
         writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
         dict.set("SMask", pdfRef(smaskObjNum));
     }
-    writer.addStreamObject(objNum, dict, png.pixels);
+    writer.addStreamObject(objNum, dict, pixels);
     return objNum;
 }

package/dist/browser/modules/pdf/core/pdf-writer.d.ts

@@ -100,6 +100,14 @@ export declare class PdfWriter {
         contentsRef: number | string;
         resourcesRef: number;
         annotRefs?: number[];
+        /**
+         * Declare a transparency group for the page. Required whenever the content
+         * uses transparency features (constant alpha, soft masks, blend modes):
+         * without it the backdrop a blend composites against is implementation
+         * defined, and a consumer that ignores the blend mode can paint a
+         * `/Saturation` overlay as opaque black.
+         */
+        transparencyGroup?: boolean;
     }): number;
     /**
      * Create and add the Catalog dictionary.

package/dist/browser/modules/pdf/core/pdf-writer.js

@@ -164,6 +164,9 @@ export class PdfWriter {
             .set("MediaBox", mediaBox)
             .set("Contents", contentsValue)
             .set("Resources", pdfRef(options.resourcesRef));
+        if (options.transparencyGroup) {
+            dict.set("Group", "<< /S /Transparency /CS /DeviceRGB /I false /K false >>");
+        }
         if (options.annotRefs && options.annotRefs.length > 0) {
             dict.set("Annots", "[" + options.annotRefs.map(r => pdfRef(r)).join(" ") + "]");
         }

package/dist/browser/modules/pdf/excel-bridge.js

@@ -27,7 +27,7 @@ import { chartChartExModel, chartChartModel } from "../excel/chart/chart-handle.
 import { canRenderChartExAsVectorPdf, drawChartExPdf, renderChartExPng } from "../excel/chart/render/chart-ex-renderer.js";
 import { drawChartPdf, renderChartPng } from "../excel/chart/render/chart-renderer.js";
 import { anchorCol, anchorRow } from "../excel/core/anchor.js";
-import { cellCol, cellGetValue, cellHyperlink, cellResult, cellText, cellType, mergeCellStyle } from "../excel/core/cell.js";
+import { cellCol, cellComment, cellGetValue, cellHyperlink, cellResult, cellText, cellType, mergeCellStyle } from "../excel/core/cell.js";
 import { chartsheetChartExModel, chartsheetChartModel, chartsheetModel, chartsheetName, chartsheetPageSetup, chartsheetPageMargins, chartsheetState } from "../excel/core/chartsheet.js";
 import { ValueType } from "../excel/core/enums.js";
 import { computeSparklineGeometry } from "../excel/core/sparkline.js";
@@ -62,7 +62,7 @@ export async function excelToPdf(workbook, options) {
     // shipped with. This keeps the ~200 KB engine out of bundles that only
     // export already-computed workbooks — no host-registry needed.
     options?.recalculate?.(workbook);
-    const pdfWorkbook = await excelWorkbookToPdf(workbook);
+    const pdfWorkbook = await excelWorkbookToPdf(workbook, options);
     return exportPdf(pdfWorkbook, options);
 }
 /**
@@ -174,9 +174,9 @@ export async function chartToPdf(chart, options = {}) {
  * Chartsheets without an orderNo fall to the end, mirroring how Excel
  * treats sheets with missing tab positions.
  */
-async function excelWorkbookToPdf(workbook) {
-    const worksheetResults = await Promise.all(getWorksheets(workbook).map(ws => convertSheet(ws, workbook)));
-    const chartsheetResults = await Promise.all(getChartsheets(workbook).map(cs => convertChartsheet(cs, workbook)));
+async function excelWorkbookToPdf(workbook, options) {
+    const worksheetResults = await Promise.all(getWorksheets(workbook).map(ws => convertSheet(ws, workbook, options)));
+    const chartsheetResults = await Promise.all(getChartsheets(workbook).map(cs => convertChartsheet(cs, workbook, options)));
     const combined = [...worksheetResults, ...chartsheetResults];
     combined.sort((a, b) => (a.orderNo ?? Number.POSITIVE_INFINITY) - (b.orderNo ?? Number.POSITIVE_INFINITY));
     return {
@@ -192,7 +192,7 @@ async function excelWorkbookToPdf(workbook) {
 // =============================================================================
 // Sheet Conversion
 // =============================================================================
-async function convertSheet(ws, workbook) {
+async function convertSheet(ws, workbook, options) {
     const dimensions = getSheetDimensions(ws);
     const hasData = dimensions && dimensions.top > 0 && dimensions.left > 0;
     const bounds = hasData
@@ -312,10 +312,22 @@ async function convertSheet(ws, workbook) {
                 }
                 : undefined,
             scale: ps.scale,
+            fitToPage: ps.fitToPage,
+            fitToWidth: ps.fitToWidth,
+            fitToHeight: ps.fitToHeight,
             printTitlesRow: ps.printTitlesRow,
+            printTitlesColumn: ps.printTitlesColumn,
             showGridLines: ps.showGridLines,
+            showRowColHeaders: ps.showRowColHeaders,
             printArea: ps.printArea,
-            firstPageNumber: ps.useFirstPageNumber === false ? undefined : ps.firstPageNumber
+            firstPageNumber: ps.useFirstPageNumber === false ? undefined : ps.firstPageNumber,
+            pageOrder: ps.pageOrder,
+            blackAndWhite: ps.blackAndWhite,
+            draft: ps.draft,
+            errors: ps.errors,
+            cellComments: ps.cellComments,
+            horizontalCentered: ps.horizontalCentered,
+            verticalCentered: ps.verticalCentered
         }
         : undefined;
     // Convert row/col breaks
@@ -324,9 +336,18 @@ async function convertSheet(ws, workbook) {
     // Convert images and charts. Both are floating objects anchored to
     // cells, and both need to participate in bounds expansion so the
     // layout engine allocates pages that cover their anchor rows/cols.
-    const images = collectImages(ws, workbook);
-    const charts = await collectCharts(ws);
-    const sparklineCharts = collectSparklineCharts(ws);
+    //
+    // Draft quality prints no graphics, so skip collection entirely rather than
+    // gathering (and rasterizing ChartEx layouts) only to drop the result during
+    // layout: draft exists to be cheap, and a rasterizer failure must not sink an
+    // export that would not have shown the graphic anyway. The precedence here
+    // mirrors `resolveOptions`; the layout engine still gates on the resolved
+    // flag, so this stays a pure optimization.
+    const comments = collectComments(ws);
+    const draftQuality = options?.draft ?? ws.pageSetup?.draft ?? false;
+    const images = draftQuality ? undefined : collectImages(ws, workbook);
+    const charts = draftQuality ? undefined : await collectCharts(ws);
+    const sparklineCharts = draftQuality ? undefined : collectSparklineCharts(ws);
     // Merge sparkline micro-charts with regular charts
     const allCharts = charts
         ? sparklineCharts
@@ -398,14 +419,91 @@ async function convertSheet(ws, workbook) {
         rows,
         merges,
         pageSetup,
-        headerFooter: convertHeaderFooter(ws, workbook),
+        headerFooter: convertHeaderFooter(ws, workbook, draftQuality),
         rowBreaks,
         colBreaks,
         images,
-        charts: allCharts
+        charts: allCharts,
+        comments
     };
 }
-function convertHeaderFooter(ws, workbook) {
+/**
+ * Collect every comment on a worksheet, in row-major order.
+ *
+ * Two sources are merged: classic notes stored on the cell (`_comment`, the
+ * VML-backed kind) and Office 365 threaded comments held on the sheet. Only the
+ * text and author are needed — the printed form is an end-of-sheet list, not a
+ * positioned box — so the VML geometry is deliberately ignored.
+ */
+function collectComments(ws) {
+    const collected = [];
+    for (const row of ws._rows ?? []) {
+        if (!row) {
+            continue;
+        }
+        for (const cell of row.cells ?? []) {
+            if (!cell) {
+                continue;
+            }
+            const note = cellComment(cell);
+            const text = noteText(note?.note);
+            if (text) {
+                collected.push({
+                    ref: cell.address,
+                    text,
+                    author: note?.author,
+                    anchor: parseVmlAnchor(note?.note)
+                });
+            }
+        }
+    }
+    for (const entry of ws.threadedComments ?? []) {
+        const text = entry.comment.text?.trim();
+        if (text) {
+            collected.push({ ref: entry.ref, text, author: entry.comment.personId });
+        }
+    }
+    return collected.length > 0 ? collected : undefined;
+}
+/**
+ * Decode a VML comment anchor into fractional sheet coordinates.
+ *
+ * `<x:Anchor>` holds eight integers: for each edge a column/row index followed
+ * by an offset into it, measured in 1/68 of a column and 1/18 of a row (the
+ * reciprocals Excel uses when it writes the value). Returns `undefined` when the
+ * note has no anchor, so callers fall back to Excel's default placement.
+ */
+function parseVmlAnchor(note) {
+    if (!note || typeof note === "string" || typeof note.anchor !== "string") {
+        return undefined;
+    }
+    const parts = note.anchor.split(",").map(p => Number(p.trim()));
+    if (parts.length !== 8 || parts.some(n => !Number.isFinite(n))) {
+        return undefined;
+    }
+    const [l, lf, t, tf, r, rf, b, bf] = parts;
+    return {
+        left: l + lf / 68,
+        top: t + tf / 18,
+        right: r + rf / 68,
+        bottom: b + bf / 18
+    };
+}
+/** Flatten a note body, which may be plain text or a rich `NoteConfig`. */
+function noteText(note) {
+    if (typeof note === "string") {
+        return note.trim() || undefined;
+    }
+    if (note && typeof note === "object" && Array.isArray(note.texts)) {
+        const joined = note.texts
+            .map(t => (typeof t === "string" ? t : (t.text ?? "")))
+            .join("")
+            .trim();
+        return joined || undefined;
+    }
+    return undefined;
+}
+function convertHeaderFooter(ws, workbook, draftQuality = false) {
     const source = ws.headerFooter;
     const fields = [
         source.oddHeader,
@@ -415,7 +513,9 @@ function convertHeaderFooter(ws, workbook) {
         source.firstHeader,
         source.firstFooter
     ];
-    const images = convertHeaderFooterImages(ws, workbook);
+    // Draft quality prints no graphics, header pictures included, so skip
+    // collecting them rather than embedding XObjects nothing will draw.
+    const images = draftQuality ? [] : convertHeaderFooterImages(ws, workbook);
     if (!fields.some(Boolean) && images.length === 0) {
         return undefined;
     }
@@ -1254,7 +1354,7 @@ function chartAnchorRange(chart) {
             : undefined,
         // Chart anchors store ext as EMU (`cx`, `cy`). Pass the values
         // through unchanged; the layout engine converts EMU→pt for charts
-        // (×1/9525) and px→pt for images (×0.75) based on `extUnit`.
+        // (÷12700) and px→pt for images (×0.75) based on `extUnit`.
         ext: r.ext ? { width: r.ext.cx, height: r.ext.cy } : undefined,
         extUnit: r.ext ? "emu" : undefined
     };
@@ -1338,11 +1438,16 @@ const CHARTSHEET_RASTER_PX = { width: 1280, height: 720 };
  *   (matches what Excel prints for a chartsheet whose chart was deleted
  *   but the sheet kept).
  */
-async function convertChartsheet(cs, workbook) {
+async function convertChartsheet(cs, workbook, options) {
     const classicModel = chartsheetChartModel(cs);
     const chartExModel = chartsheetChartExModel(cs);
+    // Resolve draft before touching the chart: a ChartEx outside the vector
+    // whitelist would otherwise be rasterised at cost — and could fail — for a
+    // page that prints no graphics at all. Precedence mirrors `resolveOptions`.
+    const draftQuality = options?.draft ?? chartsheetPageSetup(cs)?.draft ?? false;
+    // Draft quality prints no graphics, so the chart is simply never built.
     let chart = {};
-    if (classicModel) {
+    if (!draftQuality && classicModel) {
         const model = classicModel;
         chart = {
             drawVector: (surface, rect) => {
@@ -1355,7 +1460,7 @@ async function convertChartsheet(cs, workbook) {
             }
         };
     }
-    else if (chartExModel) {
+    else if (!draftQuality && chartExModel) {
         if (canRenderChartExAsVectorPdf(chartExModel)) {
             const model = chartExModel;
             chart = {
@@ -1396,6 +1501,8 @@ async function convertChartsheet(cs, workbook) {
             orientation: ps?.orientation,
             paperSize: ps?.paperSize,
             showGridLines: false,
+            blackAndWhite: ps?.blackAndWhite,
+            draft: ps?.draft,
             firstPageNumber: ps?.useFirstPageNumber === false ? undefined : ps?.firstPageNumber,
             margins: margins
                 ? {
@@ -1417,7 +1524,7 @@ async function convertChartsheet(cs, workbook) {
         orientation,
         chart,
         pageSetup,
-        headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
+        headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, draftQuality ? [] : convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
     };
 }
 function convertChartsheetHeaderImages(images, workbook) {

package/dist/browser/modules/pdf/index.d.ts

@@ -44,7 +44,7 @@ export * as Pdf from "./surface/pdf.js";
 export type { ChartToPdfOptions, ExcelToPdfOptions } from "./excel-bridge.js";
 export type { DocxToPdfOptions } from "./word-bridge.js";
 export type { PdfCell, PdfRow, PdfColumn, PdfSheet, PdfBook, PdfImage, PdfInput } from "./pdf.js";
-export type { PdfExportOptions, PdfOrientation, PdfPageSize, PdfMargins, PdfColor, PageSizeName, PdfWatermark, PdfTextWatermark, PdfImageWatermark, PdfWatermarkFilter } from "./types.js";
+export type { PdfExportOptions, PdfOrientation, PdfPageOrder, PdfCellErrorMode, PdfPageSize, PdfMargins, PdfColor, PageSizeName, PdfWatermark, PdfTextWatermark, PdfImageWatermark, PdfWatermarkFilter } from "./types.js";
 export type { ReadPdfOptions, ReadPdfResult, ReadPdfPage } from "./reader/pdf-reader.js";
 export type { PdfMetadata } from "./reader/metadata-reader.js";
 export type { ExtractedImage } from "./reader/image-extractor.js";

package/dist/browser/modules/pdf/render/chart-surface.d.ts

@@ -29,5 +29,10 @@ import type { PdfChartDrawingSurface } from "../types.js";
  * @param alphaValues   Shared set that accumulates transparency values for
  *                      later `ExtGState` registration. The surface adds any
  *                      `color.a` values it observes to this set.
+ * @param grayscale     When true, every color the chart renderer emits is
+ *                      converted to grayscale. Charts bypass the cell style
+ *                      pipeline entirely — the chart engine pushes colors
+ *                      straight into this surface — so Excel's "Black and
+ *                      white" print option has to be applied right here.
  */
-export declare function createChartSurface(stream: PdfContentStream, fontManager: FontManager, alphaValues: Set<number>): PdfChartDrawingSurface;
+export declare function createChartSurface(stream: PdfContentStream, fontManager: FontManager, alphaValues: Set<number>, grayscale?: boolean): PdfChartDrawingSurface;

package/dist/browser/modules/pdf/render/chart-surface.js

@@ -18,6 +18,7 @@
  */
 import { resolvePdfFontName } from "../font/font-manager.js";
 import { alphaGsName, emitTextBlock } from "./page-renderer.js";
+import { toGrayscale } from "./style-converter.js";
 /**
  * Build a {@link PdfChartDrawingSurface} that forwards to the given content
  * stream. The returned surface is stateful — callers should not mix it with
@@ -28,38 +29,77 @@ import { alphaGsName, emitTextBlock } from "./page-renderer.js";
  * @param alphaValues   Shared set that accumulates transparency values for
  *                      later `ExtGState` registration. The surface adds any
  *                      `color.a` values it observes to this set.
+ * @param grayscale     When true, every color the chart renderer emits is
+ *                      converted to grayscale. Charts bypass the cell style
+ *                      pipeline entirely — the chart engine pushes colors
+ *                      straight into this surface — so Excel's "Black and
+ *                      white" print option has to be applied right here.
  */
-export function createChartSurface(stream, fontManager, alphaValues) {
+export function createChartSurface(stream, fontManager, alphaValues, grayscale = false) {
+    /** Single choke point for every color entering the surface. */
+    const mapColor = (color) => grayscale && color ? toGrayscale(color) : color;
     const applyAlpha = (color) => {
         if (color?.a !== undefined && color.a < 1) {
             alphaValues.add(color.a);
             stream.setGraphicsState(alphaGsName(color.a));
         }
     };
-    const paintFillStroke = (options) => {
-        const { fill, stroke, lineWidth } = options;
+    /**
+     * Fill and/or stroke the path built by `buildPath`.
+     *
+     * `buildPath` is a closure rather than a pre-built path because a fill and a
+     * stroke with *different* opacities cannot share one graphics state: the
+     * alpha `ExtGState` sets `/ca` and `/CA` together, and `fillAndStroke()`
+     * paints both under whichever was applied last. In that case we paint in two
+     * passes and rebuild the path for the second one. (Within a single pass the
+     * unused half of the ExtGState is harmless — a fill-only pass never strokes.)
+     */
+    const paintFillStroke = (buildPath, options) => {
+        const { lineWidth, dashPattern } = options;
+        const fill = mapColor(options.fill);
+        const stroke = mapColor(options.stroke);
+        const applyDash = () => {
+            if (dashPattern && dashPattern.length > 0) {
+                stream.setDashPattern(dashPattern);
+            }
+        };
+        if (fill && stroke) {
+            const fillAlpha = fill.a ?? 1;
+            const strokeAlpha = stroke.a ?? 1;
+            if (fillAlpha !== strokeAlpha) {
+                stream.save();
+                buildPath();
+                stream.setFillColor(fill);
+                applyAlpha(fill);
+                stream.fill();
+                stream.restore();
+                stream.save();
+                buildPath();
+                stream.setStrokeColor(stroke);
+                applyAlpha(stroke);
+                applyDash();
+                if (lineWidth !== undefined) {
+                    stream.setLineWidth(lineWidth);
+                }
+                stream.stroke();
+                stream.restore();
+                return;
+            }
+        }
+        buildPath();
+        applyDash();
+        // Reaching here means either a single operation, or a fill and stroke that
+        // share one opacity — so one ExtGState describes both and no reset is
+        // needed (the differing case returned above, each pass in its own q/Q).
         if (fill) {
             stream.setFillColor(fill);
             applyAlpha(fill);
         }
         if (stroke) {
             stream.setStrokeColor(stroke);
-            // When fill applied a sub-1 alpha but stroke is fully opaque (no
-            // `a` field or `a >= 1`), we must explicitly restore opaque alpha
-            // so the stroke is not drawn with the fill's transparency. The
-            // ExtGState set by `applyAlpha(fill)` applies to both fill and
-            // stroke operations in PDF; without this reset the stroke leaks
-            // the fill's alpha.
-            const strokeNeedsAlpha = stroke.a !== undefined && stroke.a < 1;
-            const fillAppliedAlpha = fill?.a !== undefined && fill.a < 1;
-            if (strokeNeedsAlpha) {
+            if (!fill) {
                 applyAlpha(stroke);
             }
-            else if (fillAppliedAlpha) {
-                // Reset to fully opaque for the stroke
-                alphaValues.add(1);
-                stream.setGraphicsState(alphaGsName(1));
-            }
             if (lineWidth !== undefined) {
                 stream.setLineWidth(lineWidth);
             }
@@ -81,13 +121,13 @@ export function createChartSurface(stream, fontManager, alphaValues) {
         drawRect(options) {
             const { x, y, width, height, fill, stroke, lineWidth } = options;
             stream.save();
-            stream.rect(x, y, width, height);
-            paintFillStroke({ fill, stroke, lineWidth });
+            paintFillStroke(() => stream.rect(x, y, width, height), { fill, stroke, lineWidth });
             stream.restore();
             return this;
         },
         drawLine(options) {
-            const { x1, y1, x2, y2, color, lineWidth, dashPattern } = options;
+            const { x1, y1, x2, y2, lineWidth, dashPattern } = options;
+            const color = mapColor(options.color);
             stream.save();
             if (color) {
                 stream.setStrokeColor(color);
@@ -108,7 +148,7 @@ export function createChartSurface(stream, fontManager, alphaValues) {
                 return this;
             }
             const fontSize = options.fontSize ?? 10;
-            const color = options.color ?? { r: 0, g: 0, b: 0 };
+            const color = mapColor(options.color ?? { r: 0, g: 0, b: 0 });
             const bold = options.bold ?? false;
             const italic = options.italic ?? false;
             const fontFamily = options.fontFamily ?? "Helvetica";
@@ -140,39 +180,38 @@ export function createChartSurface(stream, fontManager, alphaValues) {
         drawCircle(options) {
             const { cx, cy, r, fill, stroke, lineWidth } = options;
             stream.save();
-            stream.circle(cx, cy, r);
-            paintFillStroke({ fill, stroke, lineWidth });
+            paintFillStroke(() => stream.circle(cx, cy, r), { fill, stroke, lineWidth });
             stream.restore();
             return this;
         },
         drawPath(ops, options) {
-            stream.save();
-            for (const op of ops) {
-                switch (op.op) {
-                    case "move":
-                        stream.moveTo(op.x, op.y);
-                        break;
-                    case "line":
-                        stream.lineTo(op.x, op.y);
-                        break;
-                    case "curve":
-                        stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
-                        break;
-                    case "close":
-                        stream.closePath();
-                        break;
+            const buildPath = () => {
+                for (const op of ops) {
+                    switch (op.op) {
+                        case "move":
+                            stream.moveTo(op.x, op.y);
+                            break;
+                        case "line":
+                            stream.lineTo(op.x, op.y);
+                            break;
+                        case "curve":
+                            stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
+                            break;
+                        case "close":
+                            stream.closePath();
+                            break;
+                    }
                 }
-            }
-            if (options?.closePath) {
-                stream.closePath();
-            }
-            if (options?.dashPattern && options.dashPattern.length > 0) {
-                stream.setDashPattern(options.dashPattern);
-            }
-            paintFillStroke({
+                if (options?.closePath) {
+                    stream.closePath();
+                }
+            };
+            stream.save();
+            paintFillStroke(buildPath, {
                 fill: options?.fill,
                 stroke: options?.stroke,
-                lineWidth: options?.lineWidth
+                lineWidth: options?.lineWidth,
+                dashPattern: options?.dashPattern
             });
             stream.restore();
             return this;