quicklook-pptx-renderer 0.1.0

package/dist/mapper/drawable-mapper.js

@@ -0,0 +1,1464 @@
+import { mapShape, mapConnector, getShapeDrawCmd, buildPdf, PDF_PADDING, SUPPORTED_GEOMETRIES, fillToColor as shapeFillToColor, shapeTextBox, } from "./shape-mapper.js";
+import { mapPicture, nextAttachmentIndex } from "./image-mapper.js";
+import { mapTextBody, mapTextParagraphs } from "./text-mapper.js";
+import { resolveColor } from "../resolve/color-resolver.js";
+import { emuToPx } from "./constants.js";
+export function clearDrawableCache() {
+    // Reserved for future use — currently a no-op since bleed is handled
+    // externally via QL extraction (ql-bleed.ts) rather than inline caching.
+}
+export function mapDrawable(drawable, styles, attachments, ctx, drawableIndex) {
+    if (drawable.hidden)
+        return "";
+    switch (drawable.drawableType) {
+        case "sp":
+            return mapShape(drawable, styles, attachments, ctx);
+        case "pic":
+            return mapPicture(drawable, styles, attachments, ctx);
+        case "grpSp":
+            return mapGroup(drawable, styles, attachments, ctx);
+        case "cxnSp":
+            return mapConnector(drawable, attachments, ctx);
+        case "graphicFrame":
+            return mapGraphicFrame(drawable, styles, ctx, attachments);
+    }
+    return "";
+}
+function mapGroup(group, styles, attachments, ctx) {
+    // OfficeImport renders entire groups as a single PDF image.
+    // PMDrawableMapper.mapOfficeArtGroupAt: creates CMDrawingContext with group bounds,
+    // pushes coordinate transform, renders all children into same context, then copyPDF.
+    if (!group.bounds)
+        return "";
+    // Transform children to slide-global coordinates
+    const transformed = getTransformedChildren(group);
+    // Check if all children are PDF-renderable (shapes/connectors).
+    // Pictures need XObject embedding which we don't support in handwritten PDF yet.
+    if (!allChildrenPdfRenderable(transformed)) {
+        // Fall back: render children individually (old expand behavior)
+        return transformed.map((c) => mapDrawable(c, styles, attachments, ctx)).join("");
+    }
+    // Compute tight bounding box from actual children (QL uses content AABB, not group bounds)
+    const aabb = computeChildrenAABB(transformed);
+    if (!aabb)
+        return "";
+    const gx = aabb.x;
+    const gy = aabb.y;
+    const gw = aabb.cx;
+    const gh = aabb.cy;
+    if (gw <= 0 || gh <= 0)
+        return "";
+    // QL's CMDrawingContext tracks stroke bounding boxes via CoreGraphics.
+    // When 2+ shapes are drawn with B (fill+stroke), the hairline stroke (0.5pt)
+    // extends beyond the fill bounds. The cumulative stroke tracking shifts the
+    // _finalFrame origin by floor(-0.5) = -1 relative to the content AABB.
+    // With a single shape, CG sets bounds directly without stroke tracking.
+    const leafCount = countLeafChildren(transformed);
+    const strokeOffset = leafCount >= 2 ? 1 : 0;
+    // Build combined PDF stream with all children
+    const pad = PDF_PADDING;
+    const totalW = gw + pad * 2;
+    const totalH = gh + pad * 2;
+    const streamParts = [];
+    collectChildPdfStreams(transformed, gx, gy, totalH, ctx, streamParts);
+    if (streamParts.length === 0)
+        return "";
+    const pdf = buildPdf(totalW, totalH, streamParts.join("\n"));
+    const imgX = gx - pad - strokeOffset;
+    const imgY = gy - pad - strokeOffset;
+    const idx = nextAttachmentIndex();
+    const name = `Attachment${idx}.pdf`;
+    attachments.set(name, pdf);
+    let html = `<img src="${name}" style="position:absolute; top:${imgY}; left:${imgX}; width:${totalW}; height:${totalH};">`;
+    // QL overlays text divs for child shapes that have text (PMShapeTextMapper)
+    // The stroke offset applies to text coordinates matching the AABB minimum
+    html += collectGroupTextOverlays(transformed, styles, ctx, strokeOffset > 0 ? aabb : undefined);
+    return html;
+}
+/** Count leaf (non-group) children recursively. */
+function countLeafChildren(children) {
+    let count = 0;
+    for (const c of children) {
+        if (c.hidden)
+            continue;
+        if (c.drawableType === "grpSp") {
+            count += countLeafChildren(getTransformedChildren(c));
+        }
+        else {
+            count++;
+        }
+    }
+    return count;
+}
+/** Emit text overlay divs for group children that have text (matching QL's behavior).
+ *  When strokeAabb is provided, text coordinates matching the AABB minimum get -1 offset
+ *  (replicating QL's CoreGraphics stroke tracking behavior for multi-child groups). */
+function collectGroupTextOverlays(children, styles, ctx, strokeAabb) {
+    let html = "";
+    for (const child of children) {
+        if (child.hidden)
+            continue;
+        if (child.drawableType === "sp") {
+            const shape = child;
+            const hasText = shape.textBody?.paragraphs.some((p) => p.runs.some((r) => r.type !== "br" && "text" in r && String(r.text ?? "").trim() !== ""));
+            if (hasText && shape.textBody && shape.bounds) {
+                const geom = shape.geometry?.preset ?? "rect";
+                const tb = shapeTextBox(shape.bounds, geom, shape.geometry?.adjustValues);
+                const textCtx = {
+                    colorMap: ctx.colorMap, colorScheme: ctx.colorScheme,
+                    fontScheme: ctx.fontScheme, slide: ctx.slide,
+                    fontRefColor: shape.shapeStyle?.fontRef?.color,
+                };
+                const textHtml = mapTextBody(shape.textBody, tb, styles, textCtx);
+                let tx = emuToPx(tb.x), ty = emuToPx(tb.y);
+                const tw = emuToPx(tb.cx), th = emuToPx(tb.cy);
+                // Apply stroke offset: coordinates at the AABB minimum shift by -1
+                if (strokeAabb) {
+                    if (tx === strokeAabb.x)
+                        tx -= 1;
+                    if (ty === strokeAabb.y)
+                        ty -= 1;
+                }
+                html += `<div style="position:absolute; top:${ty}; left:${tx}; width:${tw}; height:${th};">${textHtml}</div>`;
+            }
+        }
+        else if (child.drawableType === "grpSp") {
+            const sub = getTransformedChildren(child);
+            html += collectGroupTextOverlays(sub, styles, ctx, strokeAabb);
+        }
+    }
+    return html;
+}
+/** Compute tight AABB in CSS pixels from all leaf children (recursing into nested groups). */
+function computeChildrenAABB(children) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    function visit(drawables) {
+        for (const d of drawables) {
+            if (d.hidden)
+                continue;
+            if (d.drawableType === "grpSp") {
+                const sub = getTransformedChildren(d);
+                visit(sub);
+                continue;
+            }
+            const b = d.bounds;
+            if (!b)
+                continue;
+            const x = emuToPx(b.x);
+            const y = emuToPx(b.y);
+            const r = x + emuToPx(b.cx);
+            const bot = y + emuToPx(b.cy);
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (r > maxX)
+                maxX = r;
+            if (bot > maxY)
+                maxY = bot;
+        }
+    }
+    visit(children);
+    if (minX === Infinity)
+        return null;
+    return { x: minX, y: minY, cx: maxX - minX, cy: maxY - minY };
+}
+/** Transform group children to slide-global coordinates. */
+function getTransformedChildren(group) {
+    if (group.childBounds && group.childBounds.cx && group.childBounds.cy && group.bounds) {
+        const gb = group.bounds;
+        const cb = group.childBounds;
+        const scaleX = gb.cx / cb.cx;
+        const scaleY = gb.cy / cb.cy;
+        return group.children.map((c) => transformChildBounds(c, gb, cb, scaleX, scaleY));
+    }
+    return group.children;
+}
+/** Check if all children (recursively) are shapes or connectors (PDF-renderable). */
+function allChildrenPdfRenderable(children) {
+    for (const c of children) {
+        if (c.drawableType === "sp" || c.drawableType === "cxnSp")
+            continue;
+        if (c.drawableType === "grpSp") {
+            const sub = getTransformedChildren(c);
+            if (!allChildrenPdfRenderable(sub))
+                return false;
+            continue;
+        }
+        return false; // pic, graphicFrame — can't embed in handwritten PDF
+    }
+    return true;
+}
+/** Recursively collect PDF drawing commands for all children in a group. */
+function collectChildPdfStreams(children, groupX, groupY, pageTotalH, ctx, out) {
+    for (const child of children) {
+        if (child.hidden)
+            continue;
+        if (child.drawableType === "sp") {
+            const shape = child;
+            const b = shape.bounds;
+            if (!b)
+                continue;
+            const geom = shape.geometry?.preset ?? "rect";
+            if (!SUPPORTED_GEOMETRIES.has(geom))
+                continue;
+            const w = emuToPx(b.cx);
+            const h = emuToPx(b.cy);
+            if (w <= 0 || h <= 0)
+                continue;
+            const localX = emuToPx(b.x) - groupX + PDF_PADDING;
+            const localY = emuToPx(b.y) - groupY + PDF_PADDING;
+            // Draw commands in local (w x h) space (pad=0, totalH=h)
+            const drawCmd = getShapeDrawCmd(0, w, h, h, geom, shape.geometry?.adjustValues);
+            const color = shapeFillToColor(shape.fill, ctx) ?? "#000000";
+            const colorCmd = hexToRgCmd(color);
+            // PDF translate: move to child position in group page (Y-flipped)
+            const pdfX = localX;
+            const pdfY = pageTotalH - localY - h;
+            out.push(`q\n1 0 0 1 ${pdfX} ${pdfY} cm\n${colorCmd}\n${drawCmd}\nQ`);
+        }
+        else if (child.drawableType === "cxnSp") {
+            const conn = child;
+            const b = conn.bounds;
+            if (!b)
+                continue;
+            let w = emuToPx(b.cx);
+            let h = emuToPx(b.cy);
+            if (h === 0 && w > 0) {
+                h = 1;
+                w -= 1;
+            }
+            else if (w === 0 && h > 0) {
+                w = 1;
+                h -= 1;
+            }
+            if (w <= 0 && h <= 0)
+                continue;
+            const localX = emuToPx(b.x) - groupX + PDF_PADDING;
+            const localY = emuToPx(b.y) - groupY + PDF_PADDING;
+            const geom = conn.geometry?.preset ?? "line";
+            const drawCmd = getShapeDrawCmd(0, w, h, h, geom, conn.geometry?.adjustValues);
+            const color = shapeFillToColor(conn.fill, ctx) ?? "#000000";
+            const colorCmd = hexToRgCmd(color);
+            const pdfX = localX;
+            const pdfY = pageTotalH - localY - h;
+            out.push(`q\n1 0 0 1 ${pdfX} ${pdfY} cm\n${colorCmd}\n${drawCmd}\nQ`);
+        }
+        else if (child.drawableType === "grpSp") {
+            // Nested group: recursively collect children
+            const nestedGroup = child;
+            const sub = getTransformedChildren(nestedGroup);
+            collectChildPdfStreams(sub, groupX, groupY, pageTotalH, ctx, out);
+        }
+    }
+}
+/** Convert hex color string to PDF rg command. */
+function hexToRgCmd(color) {
+    const hex = color.replace("#", "");
+    if (hex.length < 6)
+        return "0 0 0 rg";
+    const r = parseInt(hex.slice(0, 2), 16) / 255;
+    const g = parseInt(hex.slice(2, 4), 16) / 255;
+    const b = parseInt(hex.slice(4, 6), 16) / 255;
+    return `${r.toFixed(3)} ${g.toFixed(3)} ${b.toFixed(3)} rg`;
+}
+/** Deep-clone a drawable and transform its bounds from group-local to slide-global coordinates. */
+function transformChildBounds(drawable, groupBounds, childBounds, scaleX, scaleY) {
+    const clone = { ...drawable };
+    const b = clone.bounds;
+    if (b) {
+        clone.bounds = {
+            ...b,
+            x: groupBounds.x + (b.x - childBounds.x) * scaleX,
+            y: groupBounds.y + (b.y - childBounds.y) * scaleY,
+            cx: b.cx * scaleX,
+            cy: b.cy * scaleY,
+        };
+    }
+    // Recursively transform nested groups
+    if (clone.drawableType === "grpSp" && clone.children) {
+        const g = clone;
+        clone.children = g.children.map((c) => transformChildBounds(c, groupBounds, childBounds, scaleX, scaleY));
+    }
+    return clone;
+}
+function mapGraphicFrame(gf, styles, ctx, attachments) {
+    const b = gf.bounds;
+    if (!b)
+        return "";
+    // Chart or SmartArt: render fallback image if available, or render chart directly
+    if (!gf.tableData && gf.chartRId) {
+        if (gf.fallbackImageData)
+            return mapGraphicFrameFallbackImage(gf, b, ctx, attachments);
+        // No fallback image — try to render the chart as PDF
+        if (gf.chartData && attachments)
+            return renderChartAsPdf(gf.chartData, b, attachments);
+        return "";
+    }
+    if (!gf.tableData && gf.smartArtRId) {
+        return mapGraphicFrameFallbackImage(gf, b, ctx, attachments);
+    }
+    if (!gf.tableData)
+        return "";
+    const { rows, gridCols } = gf.tableData;
+    const x = emuToPx(b.x);
+    const y = emuToPx(b.y);
+    const w = emuToPx(b.cx);
+    const h = emuToPx(b.cy);
+    const cols = gridCols.map((cw) => `<col style="width:${emuToPx(cw)}px;">`).join("");
+    const textCtx = {
+        colorMap: ctx.colorMap,
+        colorScheme: ctx.colorScheme,
+        fontScheme: ctx.fontScheme,
+        slide: ctx.slide,
+    };
+    // Resolve table style defaults (accent-based fills/borders from tableStyleId)
+    const tblStyle = resolveTableStyle(gf.tableData, ctx);
+    // QL registers cell content CSS (margin, p, span) before td CSS, and table CSS last.
+    const rowsHtml = rows.map((row, rowIdx) => {
+        let colIdx = 0;
+        const cellsHtml = row.cells.map((cell) => {
+            if (cell.hMerge || cell.vMerge) {
+                colIdx++;
+                return "";
+            }
+            const span = cell.gridSpan ?? 1;
+            let colWEmu = 0;
+            for (let s = 0; s < span; s++)
+                colWEmu += gridCols[colIdx + s] ?? 0;
+            colIdx += span;
+            const styleDefaults = tblStyle ? getCellStyleDefaults(tblStyle, rowIdx, rows.length) : undefined;
+            return mapTableCell(cell, row.height, colWEmu, styles, textCtx, styleDefaults);
+        }).join("");
+        return `<tr>${cellsHtml}</tr>`;
+    }).join("");
+    const tableCss = `position:absolute; top:${y}; left:${x}; width:${w}; height:${h}; border-width: 0; cellspacing: 0; cellpadding: 0;`;
+    const tableClass = styles.addClass(tableCss);
+    return `<table class="${tableClass}">${cols}${rowsHtml}</table>`;
+}
+// OfficeImport uses a different EMU conversion for table row heights (÷101600 vs ÷12700)
+const TABLE_ROW_HEIGHT_DIVISOR = 101600;
+// Default cell margins: 91440 EMU per side (0.1 inch = 7.2pt).
+// OfficeImport subtracts these in EMU space before pixel conversion.
+const CELL_MARGIN_LR_EMU = 91440;
+function mapTableCell(cell, rowHeight, colWidthEmu, styles, ctx, styleDefaults) {
+    // QL registers cell content CSS (margin, p, span) BEFORE td CSS.
+    let content = "";
+    if (cell.textBody) {
+        const innerW = Math.trunc((colWidthEmu - 2 * CELL_MARGIN_LR_EMU) / 12700);
+        const marginCss = `margin-top:3px; margin-left:7px; margin-bottom:3px; margin-right:7px; width:${innerW}px; overflow:hidden;`;
+        const marginClass = styles.addClass(marginCss);
+        const paragraphsHtml = mapTextParagraphs(cell.textBody, styles, ctx);
+        content = `<div class="${marginClass}">${paragraphsHtml}</div>`;
+    }
+    const cssParts = [];
+    cssParts.push(`height:${Math.trunc(rowHeight / TABLE_ROW_HEIGHT_DIVISOR)}px`);
+    const anchor = cell.anchor;
+    cssParts.push(`vertical-align:${anchor === "ctr" ? "middle" : anchor === "b" ? "bottom" : "top"}`);
+    // Background: explicit cell fill > table style default
+    const bg = fillToColor(cell.fill, ctx) ?? styleDefaults?.fill ?? null;
+    if (bg)
+        cssParts.push(`background-color:${bg}`);
+    if (!cell.borders && !styleDefaults) {
+        cssParts.push("border-style:none");
+    }
+    else if (cell.borders) {
+        cssParts.push("border-style:solid");
+        let maxBorderWidth = 0;
+        for (const side of ["top", "left", "bottom", "right"]) {
+            const stroke = cell.borders[side];
+            if (stroke?.width) {
+                const w = emuToPx(stroke.width);
+                if (w > maxBorderWidth)
+                    maxBorderWidth = w;
+            }
+        }
+        cssParts.push(maxBorderWidth > 1 ? `border-width: ${maxBorderWidth}` : "border-width:thin");
+        for (const side of ["top", "left", "bottom", "right"]) {
+            const stroke = cell.borders[side];
+            const color = strokeToColor(stroke, ctx);
+            if (color)
+                cssParts.push(`border-${side}-color:${color}`);
+        }
+    }
+    else if (styleDefaults?.borderColor) {
+        // Apply table style borders
+        cssParts.push("border-style:solid");
+        cssParts.push(`border-width:${styleDefaults.borderWidth ?? "thin"}`);
+        cssParts.push(`border-top-color:${styleDefaults.borderColor}`);
+        cssParts.push(`border-left-color:${styleDefaults.borderColor}`);
+        cssParts.push(`border-bottom-color:${styleDefaults.borderColor}`);
+        cssParts.push(`border-right-color:${styleDefaults.borderColor}`);
+    }
+    else {
+        cssParts.push("border-style:none");
+    }
+    const tdClass = styles.addClass(cssParts.join(";") + ";");
+    const attrs = [];
+    if (cell.gridSpan && cell.gridSpan > 1)
+        attrs.push(`colspan="${cell.gridSpan}"`);
+    if (cell.rowSpan && cell.rowSpan > 1)
+        attrs.push(`rowspan="${cell.rowSpan}"`);
+    attrs.push(`class="${tdClass}"`);
+    return `<td ${attrs.join(" ")}>${content}</td>`;
+}
+// ── Chart rendering ─────────────────────────────────────────────────
+// OfficeImport chart colors — full precision from decompressed QL PDFs
+// These are sRGB values OfficeImport writes into the PDF content stream.
+const CHART_COLORS_RGB = [
+    [0.3098039, 0.5058824, 0.7411765], // #4e81bd — blue
+    [0.7529412, 0.3137255, 0.3019608], // #bf4f4d — red/salmon
+    [0.6078431, 0.7333333, 0.3490196], // #9bbb59 — green
+    [0.5019608, 0.3921569, 0.6352941], // #8064a2 — purple
+    [0.2941176, 0.6745098, 0.7725490], // #4bacc6 — teal
+    [0.9647059, 0.5882353, 0.2745098], // #f79646 — orange
+];
+/** Render a chart as a PDF image. */
+function renderChartAsPdf(chart, bounds, attachments) {
+    const w = emuToPx(bounds.cx);
+    const h = emuToPx(bounds.cy);
+    const x = emuToPx(bounds.x);
+    const y = emuToPx(bounds.y);
+    let pdf = null;
+    if (chart.type === "bar")
+        pdf = renderColumnChart(chart, w, h);
+    else if (chart.type === "line")
+        pdf = renderLineChart(chart, w, h);
+    else if (chart.type === "pie")
+        pdf = renderPieChart(chart, w, h);
+    else if (chart.type === "area")
+        pdf = renderAreaChart(chart, w, h);
+    if (!pdf)
+        return "";
+    const idx = nextAttachmentIndex();
+    const name = `Attachment${idx}.pdf`;
+    attachments.set(name, pdf);
+    return `<img src="${name}" style="position:absolute; top:${y}; left:${x}; width:${w}; height:${h};">`;
+}
+/**
+ * Render a column/bar chart matching OfficeImport's exact layout.
+ * Measurements reverse-engineered from QL's decompressed PDF content stream.
+ */
+function renderColumnChart(chart, w, h) {
+    const isCol = chart.direction !== "bar";
+    const nCats = chart.categories.length || 1;
+    const nSer = chart.series.length || 1;
+    // Axis max: for stacked, use sum per category; for clustered, use single max
+    const isStacked = chart.grouping === "stacked" || chart.grouping === "percentStacked";
+    let dataMax = 0;
+    if (isStacked) {
+        for (let c = 0; c < nCats; c++) {
+            let sum = 0;
+            for (const s of chart.series)
+                sum += s.values[c] ?? 0;
+            if (sum > dataMax)
+                dataMax = sum;
+        }
+    }
+    else {
+        for (const s of chart.series)
+            for (const v of s.values)
+                if (v > dataMax)
+                    dataMax = v;
+    }
+    // Horizontal bar chart uses lineChartAxisScale (unit-based); column chart uses niceAxisMax (headroom-based)
+    if (!isCol) {
+        const { axisMax: hbarMax, nTicks: hbarTicks } = lineChartAxisScale(dataMax);
+        if (hbarMax === 0)
+            return buildChartPdf(w, h, "");
+        return renderHorizontalBarChart(chart, w, h, nCats, nSer, hbarMax, hbarTicks);
+    }
+    const axisMax = niceAxisMax(dataMax);
+    if (axisMax === 0)
+        return buildChartPdf(w, h, "");
+    // QL layout: plot area margins (from QL PDF analysis)
+    // For 648x324: left=82.5, bottom=41.5, plotW=521, plotH=242
+    const ml = Math.round(w * 0.127) + 0.5; // snap to half-pixel (82.5 for 648)
+    const mb = Math.round(h * 0.128) + 0.5; // (41.5 for 324)
+    const pw = Math.round(w * 0.804);
+    const ph = Math.round(h * 0.747);
+    // QL clip rect uses fractional height (h * 0.7448 = 241.3152 for 324)
+    // Bar heights are scaled using this fractional value, not the integer ph
+    const clipH = h * 0.7448;
+    const f = (v) => v.toFixed(4); // PDF coordinate formatter
+    const cmds = [];
+    // QL draws canvas/plot borders at 0% opacity (invisible via ExtGState)
+    // The actual visible border comes from WebKit rendering the <img> element
+    cmds.push("q Q q");
+    cmds.push(`/Cs1 cs 0 0 0 sc /Gs1 gs 0 0 ${w} ${h} re f`);
+    cmds.push(`2 w /Cs2 CS 0.95 0.95 0.95 SC 0 0 ${w} ${h} re S`);
+    cmds.push(`${f(ml)} ${f(mb)} ${pw} ${ph} re f`);
+    cmds.push(`1 w /Cs2 CS 0 0 0 SC /Gs2 gs ${f(ml)} ${f(mb)} ${pw} ${ph} re S`);
+    // Grid positions via Bresenham over gridRange = ph-1
+    const nTicks = axisMax <= 5 ? axisMax : axisMax <= 10 ? 5 : Math.min(axisMax / (axisMax >= 100 ? 100 : axisMax >= 10 ? 10 : 1), 8);
+    const gridRange = ph - 1;
+    const gridBase = Math.floor(gridRange / nTicks);
+    const gridRem = gridRange - gridBase * nTicks;
+    const gridPositions = [];
+    {
+        let pos = 0, err = Math.ceil(nTicks / 2);
+        for (let i = 0; i <= nTicks; i++) {
+            gridPositions.push(pos);
+            pos += gridBase;
+            err += gridRem;
+            if (err >= nTicks) {
+                pos++;
+                err -= nTicks;
+            }
+        }
+    }
+    const mbSnap = Math.floor(mb) + 0.5;
+    // Draw grid lines: black stroke at 25% opacity (Gs3)
+    cmds.push(`/Cs1 CS 0 0 0 SC /Gs3 gs`);
+    for (const gp of gridPositions) {
+        const gy = mbSnap + gp;
+        cmds.push(`${f(ml)} ${gy} m ${f(ml + pw)} ${gy} l S`);
+    }
+    cmds.push("Q");
+    // Clip to plot area
+    cmds.push("q");
+    cmds.push(`${f(ml)} ${f(mb)} ${pw + 1} ${ph + 1} re W n`);
+    {
+        const catW = pw / nCats;
+        if (isStacked) {
+            // Stacked: one bar per category, series stacked vertically
+            // QL uses 50% of category width for bars, Bresenham category stepping,
+            // integer leftPad = floor((floor(catW) - barW) / 2)
+            const barW = Math.round(catW * 0.5);
+            const intCatW = Math.floor(catW);
+            const leftPad = Math.floor((intCatW - barW) / 2);
+            // Bresenham category positions (initial error=1 matches QL)
+            const stkCatPos = [];
+            {
+                const base = Math.floor(pw / nCats), rem = pw - base * nCats;
+                let pos = 0, err = 1;
+                for (let c = 0; c < nCats; c++) {
+                    stkCatPos.push(pos);
+                    let step = base;
+                    err += rem;
+                    if (err >= nCats) {
+                        step++;
+                        err -= nCats;
+                    }
+                    pos += step;
+                }
+            }
+            for (let c = 0; c < nCats; c++) {
+                let cumVal = 0;
+                let cumH = 0;
+                for (let s = 0; s < nSer; s++) {
+                    const val = chart.series[s]?.values[c] ?? 0;
+                    cumVal += val;
+                    const cumTop = Math.round((cumVal / axisMax) * clipH);
+                    const barH = cumTop - cumH;
+                    const bx = ml + stkCatPos[c] + leftPad;
+                    const by = mb + cumH;
+                    const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+                    cmds.push(`/Cs1 cs ${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} sc`);
+                    cmds.push(`${f(bx)} ${f(by)} ${barW} ${barH} re f`);
+                    cmds.push(`0.75 w /Cs1 CS ${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} SC`);
+                    cmds.push(`${f(bx)} ${f(by)} ${barW} ${barH} re S`);
+                    cumH = cumTop;
+                }
+            }
+        }
+        else {
+            // Clustered: bars side by side
+            // QL: integer barW, Bresenham category stepping, integer leftPad
+            const barW = Math.floor(catW / (nSer + 1));
+            const leftPad = Math.floor(catW / (2 * (nSer + 1)));
+            // Bresenham category positions (initial error=1 matches QL bar spacing)
+            const barCatPos = [];
+            {
+                const base = Math.floor(pw / nCats), rem = pw - base * nCats;
+                let pos = 0, err = 1;
+                for (let c = 0; c < nCats; c++) {
+                    barCatPos.push(pos);
+                    let step = base;
+                    err += rem;
+                    if (err >= nCats) {
+                        step++;
+                        err -= nCats;
+                    }
+                    pos += step;
+                }
+            }
+            for (let c = 0; c < nCats; c++) {
+                for (let s = 0; s < nSer; s++) {
+                    const val = chart.series[s]?.values[c] ?? 0;
+                    const barH = Math.round((val / axisMax) * clipH);
+                    const bx = ml + leftPad + barCatPos[c] + s * barW;
+                    const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+                    cmds.push(`${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} rg`);
+                    cmds.push(`${f(bx)} ${f(mb)} ${barW} ${barH} re f`);
+                    cmds.push(`${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} RG 0.75 w`);
+                    cmds.push(`${f(bx)} ${f(mb)} ${barW} ${barH} re S`);
+                }
+            }
+        }
+    }
+    cmds.push("Q"); // end clip
+    // Axis tick marks (QL style: ticks at category boundaries, snapped to .5)
+    cmds.push("q /Cs1 CS 0 0 0 SC");
+    for (let c = 0; c < nCats; c++) {
+        const tx = Math.floor(ml + c * pw / nCats) + 0.5;
+        cmds.push(`${tx} ${f(mb)} m ${tx} ${f(mb - 2)} l S`);
+    }
+    // Bottom axis line
+    cmds.push(`${f(ml)} ${f(mb)} m ${f(ml + pw)} ${f(mb)} l S`);
+    // Y-axis ticks (reuse Bresenham grid positions)
+    for (const gp of gridPositions) {
+        const gy = mbSnap + gp;
+        cmds.push(`${f(ml)} ${gy} m ${f(ml - 3)} ${gy} l S`);
+    }
+    // Left axis line from bottom to top grid line
+    cmds.push(`${f(ml)} ${f(mb)} m ${f(ml)} ${mbSnap + gridRange} l S`);
+    // Category labels: Helvetica 12pt, centered below category
+    // QL uses Bresenham stepping (init_err=2) for category boundaries, then centers labels
+    cmds.push("/Cs1 cs 0 0 0 sc");
+    // Compute category boundaries via Bresenham (init_err=2 matches QL's distribution)
+    const catBounds = [];
+    {
+        const base = Math.floor(pw / nCats), rem = pw - base * nCats;
+        let pos = 0, err = 2;
+        for (let c = 0; c <= nCats; c++) {
+            catBounds.push(pos);
+            let step = base;
+            err += rem;
+            if (err >= nCats) {
+                step++;
+                err -= nCats;
+            }
+            pos += step;
+        }
+    }
+    const mlInt = Math.floor(ml);
+    for (let c = 0; c < nCats; c++) {
+        const label = chart.categories[c] ?? "";
+        if (!label)
+            continue;
+        const textW = chartTextWidth(label, 12, HELV_WIDTHS);
+        let catCenter;
+        if (isStacked) {
+            // Stacked: center on bar midpoint (barX + barW/2)
+            const stkCatW = pw / nCats;
+            const intCatW = Math.floor(stkCatW);
+            const barW = Math.round(stkCatW * 0.5);
+            const leftPad = Math.floor((intCatW - barW) / 2);
+            const base = Math.floor(pw / nCats), rem = pw - base * nCats;
+            let pos = 0, err = 1;
+            for (let i = 0; i < c; i++) {
+                let step = base;
+                err += rem;
+                if (err >= nCats) {
+                    step++;
+                    err -= nCats;
+                }
+                pos += step;
+            }
+            catCenter = ml + pos + leftPad + barW / 2;
+        }
+        else {
+            catCenter = mlInt + (catBounds[c] + catBounds[c + 1]) / 2;
+        }
+        const labelX = Math.floor(catCenter) - Math.floor(textW / 2) + 0.5;
+        cmds.push(`BT -0.0002 Tc 12 0 0 12 ${labelX.toFixed(1)} ${(mb - 9).toFixed(1)} Tm /F1 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+    }
+    // Value labels: Arial 10pt, right-aligned
+    // QL: single-char labels get no Tc; multi-char get 0.0002 Tc + 0 Tc reset
+    for (let i = 0; i <= nTicks; i++) {
+        const val = (axisMax / nTicks) * i;
+        const label = formatAxisValue(val);
+        const textW = chartTextWidth(label, 10, ARIAL_WIDTHS);
+        const labelX = Math.floor(ml - 7.5 - textW) + 0.5;
+        const gy = mbSnap + gridPositions[i];
+        if (label.length > 1) {
+            cmds.push(`BT 0.0002 Tc 10 0 0 10 ${labelX.toFixed(1)} ${(gy - 3).toFixed(1)} Tm /F2 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+        }
+        else {
+            cmds.push(`BT 10 0 0 10 ${labelX.toFixed(1)} ${(gy - 3).toFixed(1)} Tm /F2 1 Tf (${pdfEscape(label)}) Tj ET`);
+        }
+    }
+    return buildChartPdf(w, h, cmds.join("\n"));
+}
+/**
+ * Render a horizontal bar chart as PDF matching OfficeImport's exact layout.
+ * Measurements reverse-engineered from QL's decompressed Attachment6.pdf content stream
+ * (python-pptx-charts.pptx slide 2, 648x324).
+ *
+ * Key differences from column chart:
+ * - Grid lines are VERTICAL (value axis on X, category axis on Y)
+ * - Bars grow rightward from the left axis
+ * - Category labels on Y-axis (ArialMT 10pt, right-aligned), value labels on X-axis (bottom)
+ * - Clip rect uses sub-pixel offsets: ml+0.1848, mb-0.1576
+ * - Ghost black paths drawn before each bar (QL hit-test artifacts)
+ */
+function renderHorizontalBarChart(chart, w, h, nCats, nSer, axisMax, nTicks) {
+    // Same plot margins as column chart
+    const ml = Math.round(w * 0.127) + 0.5; // 82.5 for 648
+    const mb = Math.round(h * 0.128) + 0.5; // 41.5 for 324
+    const pw = Math.round(w * 0.804); // 521 for 648
+    const ph = Math.round(h * 0.747); // 242 for 324
+    const f = (v) => v.toFixed(4);
+    const cmds = [];
+    // 1. Background: transparent black fill + gray border + white plot + invisible plot border
+    // QL uses /Cs1 (ICCBased sRGB) for fill and /Cs2 for stroke color spaces
+    cmds.push("q Q q /Cs1 cs 0 0 0 sc /Gs1 gs");
+    cmds.push(`0 0 ${w} ${h} re f`);
+    cmds.push(`2 w /Cs2 CS 0.95 0.95 0.95 SC 0 0 ${w} ${h} re S`);
+    cmds.push(`${f(ml)} ${f(mb)} ${pw} ${ph} re f`);
+    cmds.push(`1 w /Cs2 CS 0 0 0 SC /Gs2 gs ${f(ml)} ${f(mb)} ${pw} ${ph} re S`);
+    // 2. VERTICAL grid lines at value positions (25% alpha)
+    // Bresenham over pw with nTicks intervals, initial error=1
+    const gridXPos = [];
+    {
+        const base = Math.floor(pw / nTicks), rem = pw - base * nTicks;
+        let pos = 0, err = 1;
+        for (let i = 0; i <= nTicks; i++) {
+            gridXPos.push(pos);
+            let step = base;
+            err += rem;
+            if (err >= nTicks) {
+                step++;
+                err -= nTicks;
+            }
+            pos += step;
+        }
+    }
+    // QL draws grid lines only for first nTicks positions (not rightmost edge)
+    cmds.push("/Cs1 CS 0 0 0 SC /Gs3 gs");
+    for (let i = 0; i < nTicks; i++) {
+        const gx = ml + gridXPos[i];
+        cmds.push(`${f(gx)} ${f(mb)} m ${f(gx)} ${f(mb + ph - 1)} l`);
+    }
+    cmds.push("S Q");
+    // 3. Category Y positions via Bresenham (ph-1 range, nCats intervals, error=1)
+    const catYPos = []; // relative positions from mb
+    {
+        const base = Math.floor((ph - 1) / nCats), rem = (ph - 1) - base * nCats;
+        let pos = 0, err = 1;
+        for (let i = 0; i <= nCats; i++) {
+            catYPos.push(pos);
+            let step = base;
+            err += rem;
+            if (err >= nCats) {
+                step++;
+                err -= nCats;
+            }
+            pos += step;
+        }
+    }
+    // Bar dimensions: barH and topPad computed from floor(ph/nCats) — the nominal category height
+    const intCatH = Math.floor(ph / nCats);
+    const barH = Math.floor(intCatH / (nSer + 1));
+    const topPad = Math.floor(intCatH / (2 * (nSer + 1)));
+    // Clip rect: sub-pixel precision matching QL exactly
+    const clipX = ml + 0.1848;
+    const clipY = mb - 0.1576;
+    const clipW = pw - 0.2672;
+    const clipH = ph - 0.6848;
+    cmds.push(`q ${clipX.toFixed(4)} ${clipY.toFixed(4)} ${clipW.toFixed(4)} ${clipH.toFixed(4)} re W n`);
+    cmds.push("/Cs1 cs 0 0 0 sc");
+    // 4. Bars: for each category (bottom to top), draw ghost path + colored bar
+    let firstBar = true;
+    for (let c = 0; c < nCats; c++) {
+        const catBase = clipY + catYPos[c];
+        for (let s = 0; s < nSer; s++) {
+            const val = chart.series[s]?.values[c] ?? 0;
+            const bw = Math.round((val / axisMax) * pw);
+            const by = catBase + topPad + s * barH;
+            // Ghost path: black fill quad (QL hit-test artifact, uses ml-based integer Y)
+            const ghostEndX = ml + bw;
+            const ghostBotY = mb + catYPos[c] + topPad + s * barH;
+            const ghostTopY = ghostBotY + barH;
+            cmds.push(`${f(ghostEndX)} ${f(ghostBotY)} m ${f(ml)} ${f(ghostTopY)} l ${f(ml)} ${f(ghostTopY)} l ${f(ml)} ${f(ghostBotY)} l h f`);
+            // Colored bar (clipX for x, sub-pixel y)
+            const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+            cmds.push(`${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} sc`);
+            cmds.push(`${clipX.toFixed(4)} ${f(by)} ${bw} ${barH} re f`);
+            // First bar sets line width + stroke colorspace; subsequent bars inherit
+            if (firstBar) {
+                cmds.push(`0.75 w /Cs1 CS ${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} SC`);
+                firstBar = false;
+            }
+            else {
+                cmds.push(`${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} SC`);
+            }
+            cmds.push(`${clipX.toFixed(4)} ${f(by)} ${bw} ${barH} re S`);
+            // Reset fill to black for next ghost path (QL skips after last bar)
+            if (c < nCats - 1 || s < nSer - 1)
+                cmds.push("0 0 0 sc");
+        }
+    }
+    cmds.push("Q");
+    // 5. X-axis: value tick marks + axis line
+    cmds.push("q /Cs1 CS 0 0 0 SC");
+    for (let i = 0; i <= nTicks; i++) {
+        const tx = ml + gridXPos[i];
+        cmds.push(`${f(tx)} ${f(mb)} m ${f(tx)} ${f(mb - 1)} l`);
+    }
+    cmds.push(`${f(ml)} ${f(mb)} m ${f(ml + pw)} ${f(mb)} l S`);
+    // 6. Value labels: ArialMT 10pt, centered under grid X positions
+    // First label (val=0): floor(gridX - textW/2) + 0.5
+    // Other labels: floor(gridX) - floor(textW/2) + 0.5
+    cmds.push("/Cs1 cs 0 0 0 sc");
+    for (let i = 0; i <= nTicks; i++) {
+        const val = (axisMax / nTicks) * i;
+        const label = formatAxisValue(val);
+        const textW = chartTextWidth(label, 10, ARIAL_WIDTHS);
+        const gridX = ml + gridXPos[i];
+        const labelX = i === 0
+            ? Math.floor(gridX - textW / 2) + 0.5
+            : Math.floor(gridX) - Math.floor(textW / 2) + 0.5;
+        const labelY = mb - 11; // QL: y=30.5 for mb=41.5
+        if (label.length > 1) {
+            cmds.push(`BT 0.0002 Tc 10 0 0 10 ${labelX.toFixed(1)} ${labelY.toFixed(1)} Tm /TT1 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+        }
+        else {
+            cmds.push(`BT 10 0 0 10 ${labelX.toFixed(1)} ${labelY.toFixed(1)} Tm /TT1 1 Tf (${pdfEscape(label)}) Tj ET`);
+        }
+    }
+    // 7. Y-axis: category tick marks (3px left) + axis line
+    for (let i = 0; i <= nCats; i++) {
+        const ty = mb + catYPos[i];
+        cmds.push(`${f(ml)} ${f(ty)} m ${f(ml - 3)} ${f(ty)} l`);
+    }
+    cmds.push(`${f(ml)} ${f(mb)} m ${f(ml)} ${f(mb + ph - 1)} l S`);
+    // 8. Category labels: ArialMT 10pt, right-aligned to ml-5.5
+    // labelX = floor(ml - 5.5 - textW) + 0.5
+    // labelY = floor(catCenter) - 2.5
+    for (let c = 0; c < nCats; c++) {
+        const label = chart.categories[c] ?? "";
+        if (!label)
+            continue;
+        const textW = chartTextWidth(label, 10, ARIAL_WIDTHS);
+        const labelX = Math.floor(ml - 5.5 - textW) + 0.5;
+        const catBottom = mb + catYPos[c];
+        const catTop = mb + catYPos[c + 1];
+        const catCenter = (catBottom + catTop) / 2;
+        const labelY = Math.floor(catCenter) - 2.5;
+        cmds.push(`BT 10 0 0 10 ${labelX.toFixed(1)} ${labelY.toFixed(1)} Tm /TT1 1 Tf`);
+        cmds.push(`[ ${pdfKernedText(label)} ] TJ ET`);
+    }
+    cmds.push("Q");
+    return buildChartPdf(w, h, cmds.join("\n"));
+}
+/** Compute a nice axis maximum matching OfficeImport's chart axis rounding.
+ *  Verified from QL PDFs: 3.5→5, 58→100, 175→400, 195→400, 1600→4000 */
+function niceAxisMax(dataMax) {
+    if (dataMax <= 0)
+        return 1;
+    // QL adds ~40% headroom then rounds to next nice number (1,2,4,5,8,10 series)
+    const target = dataMax * 1.4;
+    if (target <= 5)
+        return Math.ceil(target);
+    if (target <= 10)
+        return 10;
+    const magnitude = Math.pow(10, Math.floor(Math.log10(target)));
+    const normalized = target / magnitude;
+    const niceValues = [1, 2, 4, 5, 8, 10];
+    for (const n of niceValues) {
+        if (normalized <= n)
+            return n * magnitude;
+    }
+    return Math.ceil(target / magnitude) * magnitude;
+}
+/**
+ * Compute axis max and tick interval for line charts.
+ * Reverse-engineered from QL's decompressed PDF: pick nice unit, ensure >= 4 intervals.
+ */
+function lineChartAxisScale(dataMax) {
+    if (dataMax <= 0)
+        return { axisMax: 1, unit: 1, nTicks: 1 };
+    const mag = Math.pow(10, Math.floor(Math.log10(dataMax)));
+    const norm = dataMax / mag;
+    const unit = norm <= 1 ? 0.5 * mag : norm <= 5 ? mag : 2 * mag;
+    const nTicks = Math.max(4, Math.ceil(dataMax / unit));
+    return { axisMax: unit * nTicks, unit, nTicks };
+}
+/** Render a line chart as PDF matching OfficeImport's layout.
+ *  Measurements from QL's decompressed Attachment3.pdf content stream:
+ *  Plot: 71.5 41.5 443 242 | lines: 2.25w round cap/join | grid: 25% alpha
+ *  Categories: Helvetica 12pt | values: ArialMT 10pt | legend: 10x10 box + 10pt */
+function renderLineChart(chart, w, h) {
+    const nCats = chart.categories.length || 1;
+    let dataMax = 0;
+    for (const s of chart.series)
+        for (const v of s.values)
+            if (v > dataMax)
+                dataMax = v;
+    const { axisMax, unit, nTicks } = lineChartAxisScale(dataMax);
+    if (axisMax === 0)
+        return buildChartPdf(w, h, "");
+    const hasLegend = chart.legendPos === "r" && chart.series.some(s => s.name);
+    const f = (v) => v.toFixed(4);
+    // QL layout: with legend ml=71.5/pw=443, without ml=82.5/pw=521 (for 648x324)
+    const mlInt = hasLegend ? Math.round(w * 0.10957) : Math.round(w * 0.127315 - 0.5);
+    const ml = mlInt + 0.5;
+    const mb = Math.round(h * 0.12654) + 0.5;
+    const pw = hasLegend ? Math.round(w * 0.68364) : Math.round(w * 0.803858);
+    const ph = Math.round(h * 0.74691);
+    const catW = pw / nCats;
+    const mbInt = Math.round(mb - 0.5);
+    // Grid Y positions: QL snaps to round(mbInt + i*(ph-1)/nTicks) + 0.5
+    const gridY = [];
+    for (let i = 0; i <= nTicks; i++)
+        gridY.push(Math.round(mbInt + i * (ph - 1) / nTicks) + 0.5);
+    // Right edge of plot: QL draws grid/axis to ml + pw - 1, not ml + pw
+    const plotRight = ml + pw - 1;
+    // Tick X positions: QL uses floor(mlInt + i * catW) + 0.5
+    const tickX = [];
+    for (let i = 0; i < nCats; i++)
+        tickX.push(Math.floor(mlInt + i * catW) + 0.5);
+    // Data point X: QL uses mlInt + round((i + 0.5) * catW) - 0.5
+    const dataX = [];
+    for (let i = 0; i < nCats; i++) {
+        dataX.push(mlInt + Math.round((i + 0.5) * catW) - 0.5);
+    }
+    const cmds = [];
+    // 1. Background (QL: transparent fill + light gray border)
+    cmds.push("q Q q");
+    cmds.push("0 0 0 rg /Gs1 gs");
+    cmds.push(`0 0 ${w} ${h} re f`);
+    cmds.push(`2 w 0.95 0.95 0.95 RG`);
+    cmds.push(`0 0 ${w} ${h} re S`);
+    // 2. Plot area: white fill + invisible black border
+    cmds.push(`${f(ml)} ${f(mb)} ${pw} ${ph} re f`);
+    cmds.push(`1 w 0 0 0 RG /Gs2 gs`);
+    cmds.push(`${f(ml)} ${f(mb)} ${pw} ${ph} re S`);
+    // 3. Grid lines: black at 25% alpha
+    cmds.push("0 0 0 RG /Gs3 gs");
+    for (let i = 0; i <= nTicks; i++) {
+        cmds.push(`${f(ml)} ${gridY[i]} m ${f(plotRight)} ${gridY[i]} l`);
+    }
+    cmds.push("S");
+    cmds.push("Q");
+    // 4. Data lines (clipped to plot area, 2.25pt round cap/join)
+    // QL clip rect offsets from plot area: -0.24592, -0.1576 (inset slightly)
+    const clipX = (ml - 0.24592).toFixed(5);
+    const clipY = (mb - 0.1576).toFixed(4);
+    const clipW = (pw - 0.3771).toFixed(4);
+    const clipH = (ph - 0.6848).toFixed(4);
+    cmds.push(`q ${clipX} ${clipY} ${clipW} ${clipH} re W n`);
+    cmds.push("2.25 w 1 J 1 j");
+    // QL draws series 0 first (blue = 2025), then series 1 (red = 2026)
+    for (let s = 0; s < chart.series.length; s++) {
+        const ser = chart.series[s];
+        const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+        cmds.push(`${r.toFixed(7)} ${g.toFixed(7)} ${b.toFixed(7)} RG`);
+        for (let c = 0; c < ser.values.length; c++) {
+            const x = dataX[c];
+            // Data Y: QL uses mbInt + floor(value * ph / axisMax) + 0.5
+            const yRel = ser.values[c] * ph / axisMax;
+            const y = mbInt + Math.floor(yRel) + 0.5;
+            cmds.push(c === 0 ? `${x} ${y} m` : `${x} ${y} l`);
+        }
+        cmds.push("S");
+    }
+    cmds.push("Q");
+    // 5. X-axis: tick marks + axis line + category labels
+    cmds.push("q 0 0 0 RG 0 0 0 rg");
+    for (let i = 0; i < nCats; i++) {
+        cmds.push(`${tickX[i]} ${f(mb)} m ${tickX[i]} ${f(mb - 2)} l`);
+    }
+    cmds.push(`${f(ml)} ${f(mb)} m ${f(plotRight)} ${f(mb)} l S`);
+    // Category labels (Helvetica 12pt, centered on data X using font metrics)
+    for (let i = 0; i < nCats; i++) {
+        const label = chart.categories[i] ?? "";
+        if (!label)
+            continue;
+        const tw = chartTextWidth(label, 12, HELV_WIDTHS);
+        const labelX = Math.round(dataX[i] - tw / 2) + 0.5;
+        cmds.push(`BT 12 0 0 12 ${labelX.toFixed(1)} ${(mb - 9).toFixed(1)} Tm /F1 1 Tf`);
+        cmds.push(`[ ${pdfKernedText(label)} ] TJ ET`);
+    }
+    // 6. Y-axis: tick marks + axis line + value labels
+    for (let i = 0; i <= nTicks; i++) {
+        cmds.push(`${f(ml)} ${gridY[i]} m ${f(ml - 3)} ${gridY[i]} l`);
+    }
+    cmds.push(`${f(ml)} ${gridY[0]} m ${f(ml)} ${gridY[nTicks]} l S`);
+    // Value labels (ArialMT 10pt, right-aligned with 5pt gap from tick edge)
+    for (let i = 0; i <= nTicks; i++) {
+        const val = Math.round(unit * i);
+        const label = formatAxisValue(val);
+        const tw = chartTextWidth(label, 10, ARIAL_WIDTHS);
+        const labelX = mlInt - 3 - Math.round(tw) - 5 + 0.5;
+        const labelY = gridY[i] - 3;
+        if (val === 0) {
+            cmds.push(`BT 10 0 0 10 ${labelX.toFixed(1)} ${labelY.toFixed(1)} Tm /F2 1 Tf (${pdfEscape(label)}) Tj ET`);
+        }
+        else {
+            cmds.push(`BT 0.0002 Tc 10 0 0 10 ${labelX.toFixed(1)} ${labelY.toFixed(1)} Tm /F2 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+        }
+    }
+    cmds.push("Q");
+    // 7. Legend (right side)
+    if (hasLegend) {
+        const legendX = ml + pw + 25;
+        const sx = Math.round(legendX) - 0.5;
+        const legendClipX = (sx + 0.284).toFixed(3);
+        const legendClipW = (w - (sx + 0.284) - 12.96).toFixed(3);
+        cmds.push(`q ${legendClipX} 3.24 ${legendClipW} ${h - 6.48} re W n`);
+        cmds.push("2.25 w 1 J 1 j");
+        // QL legend: bottom entry at plotMidY, each subsequent 25px higher
+        const plotMidY = mb + ph / 2;
+        const nSeries = chart.series.length;
+        let drawIdx = 0;
+        for (let s = nSeries - 1; s >= 0; s--) {
+            const ser = chart.series[s];
+            if (!ser.name)
+                continue;
+            const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+            const rc = r.toFixed(7), gc = g.toFixed(7), bc = b.toFixed(7);
+            const entryY = plotMidY + (nSeries - 1 - drawIdx) * 25;
+            // Color box (stroke only)
+            cmds.push(`${rc} ${gc} ${bc} RG`);
+            cmds.push(`${sx} ${entryY} 10 10 re S`);
+            // Series name
+            cmds.push(`0 0 0 rg BT 0.0002 Tc 10 0 0 10 ${(sx + 14).toFixed(1)} ${(entryY + 2).toFixed(1)} Tm /F2 1 Tf`);
+            cmds.push(`(${pdfEscape(ser.name)}) Tj 0 Tc ET`);
+            drawIdx++;
+        }
+        cmds.push("Q");
+    }
+    return buildChartPdf(w, h, cmds.join("\n"));
+}
+/**
+ * Render a pie chart as PDF matching OfficeImport's exact output.
+ *
+ * OfficeImport renders one full circle per SERIES (not per data point).
+ * Layout: gray border, pie centered in left ~83% of page, legend swatches on right.
+ * Circle uses standard 4-segment cubic bezier approximation (kappa = 4*(sqrt(2)-1)/3).
+ *
+ * Geometry reverse-engineered from QL's decompressed PDF content stream:
+ *   Page 576x324: cx=260.0582, cy=162, r=108.5918
+ *   cx ≈ w*0.4515, cy = h/2, r ≈ h*0.335
+ *   Legend clip: x=w*0.833, y=h*0.01, w=w*0.147, h=h*0.98
+ */
+function renderPieChart(chart, w, h) {
+    const nSer = chart.series.length;
+    if (nSer === 0)
+        return buildPdf(w, h, "");
+    const kappa = 4 * (Math.sqrt(2) - 1) / 3; // ≈ 0.5522847498
+    const f = (v) => v.toFixed(4); // coordinates
+    const fc = (v) => v.toFixed(7); // colors (QL uses 7 decimal places)
+    // ── Layout (from QL) ──
+    const cx = w * 0.4515;
+    const cy = h / 2;
+    const r = h * 0.335;
+    // Legend swatch: half-pixel-aligned, vertically centered
+    const swatchSize = 10;
+    const entryH = 14; // swatch height + gap between entries
+    const swatchX = Math.round(w * 0.833) - 0.5; // QL uses round(legX) - 0.5
+    const cmds = [];
+    // ── Background: gray border (QL draws transparent black fill then gray stroke) ──
+    cmds.push(`2 w 0.95 0.95 0.95 RG 0 0 ${w} ${h} re S`);
+    // ── One full circle per series ──
+    for (let s = 0; s < nSer; s++) {
+        const [cr, cg, cb] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+        cmds.push(`${fc(cr)} ${fc(cg)} ${fc(cb)} rg`);
+        // Move to center, line to top of circle
+        cmds.push(`${f(cx)} ${f(cy)} m`);
+        cmds.push(`${f(cx)} ${f(cy + r)} l`);
+        // 4 bezier arcs: top->right->bottom->left->top
+        const k = r * kappa;
+        cmds.push(`${f(cx + k)} ${f(cy + r)} ${f(cx + r)} ${f(cy + k)} ${f(cx + r)} ${f(cy)} c`);
+        cmds.push(`${f(cx + r)} ${f(cy - k)} ${f(cx + k)} ${f(cy - r)} ${f(cx)} ${f(cy - r)} c`);
+        cmds.push(`${f(cx - k)} ${f(cy - r)} ${f(cx - r)} ${f(cy - k)} ${f(cx - r)} ${f(cy)} c`);
+        cmds.push(`${f(cx - r)} ${f(cy + k)} ${f(cx - k)} ${f(cy + r)} ${f(cx)} ${f(cy + r)} c`);
+        cmds.push(`${f(cx)} ${f(cy)} l f`);
+        // ── Legend swatch ──
+        // QL places swatch at half-pixel offset from center; for 1 series: y = cy + 0.5
+        const sy = cy - (nSer - 1) * entryH / 2 + s * entryH + 0.5;
+        cmds.push(`${fc(cr)} ${fc(cg)} ${fc(cb)} rg`);
+        cmds.push(`${swatchX} ${f(sy)} ${swatchSize} ${swatchSize} re f`);
+        cmds.push(`0.75 w 1 J 1 j ${fc(cr)} ${fc(cg)} ${fc(cb)} RG`);
+        cmds.push(`${swatchX} ${f(sy)} ${swatchSize} ${swatchSize} re S`);
+    }
+    return buildPdf(w, h, cmds.join("\n"));
+}
+/** Render an area chart as PDF matching OfficeImport's exact layout.
+ *  Layout reverse-engineered from QL's decompressed Attachment6.pdf content stream.
+ *  Key: transparent bg, invisible plot border, 25%-alpha grid, area fill+stroke,
+ *  tick marks, axis labels (Helvetica/Arial), legend with color swatch. */
+function renderAreaChart(chart, w, h) {
+    const nCats = chart.categories.length || 1;
+    let dataMax = 0;
+    for (const s of chart.series)
+        for (const v of s.values)
+            if (v > dataMax)
+                dataMax = v;
+    const axisMax = niceAxisMax(dataMax);
+    if (axisMax === 0)
+        return buildChartPdf(w, h, "");
+    // QL area chart layout (from decompressed PDF):
+    // Plot area at (71.5, 41.5, 443, 242) for 648x324 chart.
+    // Legend area on right side starting at ~539.
+    const ml = Math.round(w * 0.10957); // 71 for 648
+    const mb = Math.round(h * 0.12654); // 41 for 324
+    const pw = Math.round(w * 0.68364); // 443 for 648
+    const ph = Math.round(h * 0.74691); // 242 for 324
+    // Grid line count — QL uses value-based ticks
+    const nTicks = computeTickCount(axisMax);
+    // Grid Y positions: floor(mb + i*ph/nTicks) + 0.5, clamped to mb+ph-1
+    const gridY = [];
+    for (let i = 0; i <= nTicks; i++) {
+        const y = Math.min(Math.floor(mb + i * ph / nTicks), mb + ph - 1);
+        gridY.push(y + 0.5);
+    }
+    // Pre-compute tick X positions — floor(ml + i*pw/nCats) + 0.5
+    const tickX = [];
+    for (let i = 0; i < nCats; i++)
+        tickX.push(Math.floor(ml + i * pw / nCats) + 0.5);
+    // Data point X: midpoint of category zone (integer center + 0.5)
+    const dataX = [];
+    for (let i = 0; i < nCats; i++) {
+        const left = Math.floor(ml + i * pw / nCats);
+        const right = Math.floor(ml + (i + 1) * pw / nCats);
+        dataX.push(Math.floor((left + right) / 2) + 0.5);
+    }
+    // Data point Y: interpolate within grid intervals using round()
+    const tickVal = axisMax / nTicks;
+    const dataY = [];
+    for (const ser of chart.series) {
+        for (let c = 0; c < ser.values.length; c++) {
+            const v = ser.values[c];
+            const gridIdx = Math.min(Math.floor(v / tickVal), nTicks - 1);
+            const frac = (v - gridIdx * tickVal) / tickVal;
+            const yLow = gridY[gridIdx];
+            const yHigh = gridY[gridIdx + 1] ?? gridY[nTicks];
+            const yRaw = yLow + frac * (yHigh - yLow);
+            // QL snaps to half-pixel: round to nearest integer then add 0.5
+            dataY.push(Math.round(yRaw - 0.5) + 0.5);
+        }
+    }
+    const f = (v) => v.toFixed(4);
+    const cmds = [];
+    // 1. Background: transparent fill + gray border (QL: ca=0 fill, 0.95 stroke)
+    cmds.push("q Q q");
+    cmds.push("0 0 0 rg /Gs1 gs");
+    cmds.push(`0 0 ${w} ${h} re f`);
+    cmds.push(`2 w 0.95 0.95 0.95 RG`);
+    cmds.push(`0 0 ${w} ${h} re S`);
+    // 2. Plot area: white fill + invisible black border
+    cmds.push(`${ml}.5 ${mb}.5 ${pw} ${ph} re f`);
+    cmds.push(`1 w 0 0 0 RG /Gs2 gs`);
+    cmds.push(`${ml}.5 ${mb}.5 ${pw} ${ph} re S`);
+    // 3. Grid lines: black at 25% alpha
+    cmds.push("0 0 0 SC /Gs3 gs");
+    for (let i = 0; i <= nTicks; i++) {
+        cmds.push(`${ml}.5 ${gridY[i]} m ${ml + pw - 1}.5 ${gridY[i]} l`);
+    }
+    cmds.push("S");
+    cmds.push("Q");
+    // 4. Area fill (clipped to plot area)
+    // QL clip rect uses sub-pixel precision: ml+0.25408, mb+0.3424, pw-0.377, ph-0.685
+    const clipX = (ml + 0.25408).toFixed(5);
+    const clipY = (mb + 0.3424).toFixed(4);
+    const clipW = (pw - 0.3771).toFixed(4);
+    const clipH = (ph - 0.6848).toFixed(4);
+    cmds.push(`q ${clipX} ${clipY} ${clipW} ${clipH} re W n`);
+    for (let s = chart.series.length - 1; s >= 0; s--) {
+        const ser = chart.series[s];
+        const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+        const rc = r.toFixed(7), gc = g.toFixed(7), bc = b.toFixed(7);
+        // Fill polygon: first data point → all points → baseline → close
+        cmds.push(`${rc} ${gc} ${bc} rg`);
+        cmds.push(`${dataX[0]} ${dataY[s * nCats + 0]} m`);
+        for (let c = 1; c < ser.values.length; c++) {
+            cmds.push(`${dataX[c]} ${dataY[s * nCats + c]} l`);
+        }
+        // Down to baseline, across to first point's x, close and fill
+        cmds.push(`${dataX[ser.values.length - 1]} ${mb}.5 l`);
+        cmds.push(`${dataX[0]} ${mb}.5 l f`);
+        // Stroke the top edge (same color, 0.75w, round cap+join)
+        cmds.push(`0.75 w 1 J 1 j`);
+        cmds.push(`${rc} ${gc} ${bc} SC`);
+        cmds.push(`${dataX[0]} ${dataY[s * nCats + 0]} m`);
+        for (let c = 1; c < ser.values.length; c++) {
+            cmds.push(`${dataX[c]} ${dataY[s * nCats + c]} l`);
+        }
+        cmds.push("S");
+    }
+    cmds.push("Q");
+    // 5. Category axis: tick marks + axis line + labels
+    cmds.push("q 0 0 0 RG 0 0 0 rg");
+    // Tick marks at category boundaries (2px tall, downward from baseline)
+    for (let i = 0; i < nCats; i++) {
+        cmds.push(`${tickX[i]} ${mb}.5 m ${tickX[i]} ${mb - 2}.5 l`);
+    }
+    // Bottom axis line
+    cmds.push(`${ml}.5 ${mb}.5 m ${ml + pw - 1}.5 ${mb}.5 l S`);
+    // Category labels: Helvetica 12pt, centered using Bresenham boundaries
+    // QL uses Bresenham stepping (init_err=2) for category boundaries
+    {
+        const lineCatBounds = [];
+        const base = Math.floor(pw / nCats), rem = pw - base * nCats;
+        let pos = 0, err = 2;
+        for (let c = 0; c <= nCats; c++) {
+            lineCatBounds.push(pos);
+            let step = base;
+            err += rem;
+            if (err >= nCats) {
+                step++;
+                err -= nCats;
+            }
+            pos += step;
+        }
+        const labelOrigin = ml + 0.5; // area chart uses half-pixel origin for centering
+        for (let i = 0; i < nCats; i++) {
+            const label = chart.categories[i] ?? "";
+            const textW = chartTextWidth(label, 12, HELV_WIDTHS);
+            const catCenter = labelOrigin + (lineCatBounds[i] + lineCatBounds[i + 1]) / 2;
+            const labelX = Math.floor(catCenter) - Math.floor(textW / 2) + 0.5;
+            cmds.push(`BT -0.0002 Tc 12 0 0 12 ${labelX.toFixed(1)} ${mb - 8.5} Tm /F1 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+        }
+    }
+    // 6. Value axis: tick marks (3px) + axis line + labels
+    for (let i = 0; i <= nTicks; i++) {
+        cmds.push(`${ml}.5 ${gridY[i]} m ${ml - 3}.5 ${gridY[i]} l`);
+    }
+    cmds.push(`${ml}.5 ${gridY[0]} m ${ml}.5 ${gridY[nTicks]} l S`);
+    // Value labels: Arial 10pt, right-aligned 5pt before tick end (ml-3.5)
+    for (let i = 0; i <= nTicks; i++) {
+        const val = (axisMax / nTicks) * i;
+        const label = formatAxisValue(val);
+        const textW = chartTextWidth(label, 10, ARIAL_WIDTHS);
+        const labelX = Math.floor(ml - 7.5 - textW) + 0.5;
+        cmds.push(`BT 0.0002 Tc 10 0 0 10 ${labelX.toFixed(1)} ${(gridY[i] - 3).toFixed(1)} Tm /F2 1 Tf (${pdfEscape(label)}) Tj 0 Tc ET`);
+    }
+    cmds.push("Q");
+    // 7. Legend (color swatch + series name)
+    const legendX = ml + pw + 26;
+    cmds.push(`q ${(legendX - 0.216).toFixed(3)} 3.24 ${(w - legendX + 0.216 - 12.96).toFixed(3)} ${h - 6.48} re W n`);
+    for (let s = 0; s < chart.series.length; s++) {
+        const [r, g, b] = CHART_COLORS_RGB[s % CHART_COLORS_RGB.length];
+        const rc = r.toFixed(7), gc = g.toFixed(7), bc = b.toFixed(7);
+        // QL: swatch at (539.5, 162.5) = (legendX-0.5, h/2+0.5)
+        const sx = legendX - 0.5;
+        const sy = Math.round(h / 2) + 0.5;
+        cmds.push(`${rc} ${gc} ${bc} rg ${sx} ${sy} 10 10 re f`);
+        cmds.push(`0.75 w 1 J 1 j ${rc} ${gc} ${bc} RG ${sx} ${sy} 10 10 re S`);
+        const name = chart.series[s].name ?? "";
+        cmds.push(`0 0 0 rg BT 10 0 0 10 ${sx + 14} ${sy + 2} Tm /F2 1 Tf`);
+        cmds.push(`[ ${pdfKernedText(name)} ] TJ ET`);
+    }
+    cmds.push("Q");
+    return buildChartPdf(w, h, cmds.join("\n"));
+}
+/** Compute tick count for value axis matching QL behavior.
+ *  QL: 5→5, 400→4, 4000→4 (axisMax / magnitude, with 5 for powers of 10). */
+function computeTickCount(axisMax) {
+    if (axisMax <= 10)
+        return axisMax;
+    const magnitude = Math.pow(10, Math.floor(Math.log10(axisMax)));
+    const n = axisMax / magnitude;
+    return n === 1 ? 5 : n; // powers of 10 use 5 subdivisions
+}
+/** Format axis value label matching QL convention (e.g., "1.000" for thousands). */
+function formatAxisValue(val) {
+    if (val === 0)
+        return "0";
+    if (val >= 1000)
+        return (val / 1000).toFixed(3);
+    if (Number.isInteger(val))
+        return String(val);
+    return val.toFixed(1);
+}
+/** Escape a string for PDF text. */
+function pdfEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+}
+/** Approximate kerned text for PDF TJ operator. */
+function pdfKernedText(s) {
+    return `(${pdfEscape(s)})`;
+}
+// Helvetica Regular glyph widths (per 1000 em) — from QL's embedded font subsets
+const HELV_WIDTHS = { W: 944, M: 833, " ": 278, A: 667, B: 667, C: 722, D: 722, E: 667, F: 611, G: 778, H: 722, I: 278, J: 500, K: 667, L: 556, N: 722, O: 778, P: 667, Q: 778, R: 722, S: 667, T: 611, U: 722, V: 667, X: 667, Y: 667, Z: 611, a: 556, b: 556, c: 500, d: 556, e: 556, f: 278, g: 556, h: 556, i: 222, j: 222, k: 500, l: 222, m: 833, n: 556, o: 556, p: 556, q: 556, r: 333, s: 500, t: 278, u: 556, v: 500, w: 722, x: 500, y: 500, z: 500 };
+// ArialMT glyph widths — from QL's embedded ArialMT subset
+const ARIAL_WIDTHS = { ".": 278, ",": 278, "0": 556, "1": 556, "2": 556, "3": 556, "4": 556, "5": 556, "6": 556, "7": 556, "8": 556, "9": 556, " ": 278, A: 667, B: 667, C: 722, D: 722, E: 667, F: 611, G: 778, H: 722, I: 278, J: 556, K: 667, L: 556, M: 833, N: 722, O: 778, P: 667, Q: 778, R: 722, S: 667, T: 611, U: 722, V: 667, W: 944, X: 667, Y: 667, Z: 611, a: 556, b: 556, c: 500, d: 556, e: 556, f: 278, g: 556, h: 556, i: 222, j: 222, k: 500, l: 222, m: 833, n: 556, o: 556, p: 556, q: 556, r: 333, s: 500, t: 278, u: 556, v: 500, w: 722, x: 500, y: 500, z: 500 };
+/** Compute text width in points given font size and width table. */
+function chartTextWidth(text, fontSize, widths) {
+    let w = 0;
+    for (const ch of text)
+        w += widths[ch] ?? 556;
+    return w * fontSize / 1000;
+}
+// ICC profiles from QL chart PDFs for correct WebKit color rendering.
+// Generic RGB (Apple) for /Cs1, sRGB IEC61966-2.1 for /Cs2.
+const ICC_GENERIC_RGB = Buffer.from("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", "base64");
+const ICC_SRGB = Buffer.from("AAAMSExpbm8CEAAAbW50clJHQiBYWVogB84AAgAJAAYAMQAAYWNzcE1TRlQAAAAASUVDIHNSR0IAAAAAAAAAAAAAAAAAAPbWAAEAAAAA0y1IUCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARY3BydAAAAVAAAAAzZGVzYwAAAYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAUclhZWgAAAhgAAAAUZ1hZWgAAAiwAAAAUYlhZWgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAABIdnVlZAAAAwwAAABHdmlldwAAA1QAAAAkbHVtaQAAA3gAAAAUbWVhcwAAA4wAAAAkdGVjaAAAA7AAAAAMclRSQwAAA7wAAAgMZ1RSQwAAA7wAAAgMYlRSQwAAA7wAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5OTggSGV3bGV0dC1QYWNrYXJkIENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNjAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAuSUVDIDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAuSUVDIDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwABBMLAANYngAAAAFYWVogAAAAAABMCVYAUAAAAFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAJzaWcgAAAAAENSVCBjdXJ2AAAAAAAABAAAAAAFAAoADwAUABkAHgAjACgALQAyADcAOwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8AIEAhgCLAJAAlQCaAJ8ApACpAK4AsgC3ALwAwQDGAMsA0QDWANwA4QDnAO0A8wD5AP8BBQELAREBFwEdASMBKQEvATUBOwFCAUgBTgFUAVsBYQFoAW4BdQF8AYMBigGRAZgBnwGnAa4BtgG9AcUBzQHVAd0B5QHtAfYB/gIHAg8CGAIhAioCMwI8AkUCTgJYAmECawJ1An8CiQKTAp0CpwKxArsCxgLQAtsC5QLwAvsDBgMRAx0DKAM0A0ADTANYA2UDcQN+A4oDlwOkA7EDvgPLA9kD5gP0BAIEEAQeBCwEOgRJBFcEZgR0BIMEkgShBLAEwATQBN8E7wT/BQ8FHwUwBUAFUQVhBXIFgwWVBaUFtgXIBdkF6wX8Bg4GIAYyBkQGVgZpBnsGjgahBrMGxgbaBu0HAAccBzAHRAdYB2wHgAeUB6oHvgfSB+cH/AgRCCYIPAhRCGcIfQiTCKkIvwjWCOwJAwkZCTAJRwleCXUJjAmkCbsJ0wnrCgIKGgoyCoqKoQq5CtIK6gsCCxsLNAtNC2YLfwuYC7ILywvlC/8MGQwzDE0MZwyCDJwMtwzRDOwNBw0iDT0NWQ10DY8Nqw3GDeIOAA==", "base64");
+/** Build a chart PDF with font, ExtGState, and ICC color space resources.
+ *  Binary concat to embed ICC profiles for correct WebKit color rendering. */
+function buildChartPdf(w, h, stream) {
+    const parts = [];
+    const offsets = [];
+    let pos = 0;
+    const mark = () => { offsets.push(pos); };
+    const emit = (s) => { const b = Buffer.from(s, "latin1"); parts.push(b); pos += b.length; };
+    const emitBin = (b) => { parts.push(b); pos += b.length; };
+    emit("%PDF-1.4\n");
+    mark();
+    emit(`1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Version /1.4 >>\nendobj\n`);
+    mark();
+    emit(`2 0 obj\n<< /Type /Pages /MediaBox [0 0 ${w} ${h}] /Count 1 /Kids [ 3 0 R ] >>\nendobj\n`);
+    mark();
+    emit(`3 0 obj\n<< /Type /Page /Parent 2 0 R /Resources 4 0 R /Contents 5 0 R /MediaBox [0 0 ${w} ${h}] >>\nendobj\n`);
+    mark();
+    emit([
+        `4 0 obj\n<< /ProcSet [ /PDF /Text ]`,
+        ` /ColorSpace << /Cs1 11 0 R /Cs2 12 0 R >>`,
+        ` /Font << /F1 6 0 R /F2 7 0 R /TT1 7 0 R >>`,
+        ` /ExtGState << /Gs1 8 0 R /Gs2 9 0 R /Gs3 10 0 R >>`,
+        ` >>\nendobj\n`,
+    ].join(""));
+    const streamBuf = Buffer.from(stream, "ascii");
+    mark();
+    emit(`5 0 obj\n<< /Length ${streamBuf.length} >>\nstream\n`);
+    emitBin(streamBuf);
+    emit(`\nendstream\nendobj\n`);
+    mark();
+    emit(`6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n`);
+    mark();
+    emit(`7 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n`);
+    mark();
+    emit(`8 0 obj\n<< /Type /ExtGState /ca 0 >>\nendobj\n`);
+    mark();
+    emit(`9 0 obj\n<< /Type /ExtGState /CA 0 >>\nendobj\n`);
+    mark();
+    emit(`10 0 obj\n<< /Type /ExtGState /CA 0.25 >>\nendobj\n`);
+    mark();
+    emit(`11 0 obj\n[ /ICCBased 13 0 R ]\nendobj\n`);
+    mark();
+    emit(`12 0 obj\n[ /ICCBased 14 0 R ]\nendobj\n`);
+    mark();
+    emit(`13 0 obj\n<< /N 3 /Alternate /DeviceRGB /Length ${ICC_GENERIC_RGB.length} >>\nstream\n`);
+    emitBin(ICC_GENERIC_RGB);
+    emit(`\nendstream\nendobj\n`);
+    mark();
+    emit(`14 0 obj\n<< /N 3 /Alternate /DeviceRGB /Length ${ICC_SRGB.length} >>\nstream\n`);
+    emitBin(ICC_SRGB);
+    emit(`\nendstream\nendobj\n`);
+    const xrefOffset = pos;
+    const nObjs = offsets.length + 1;
+    emit(`xref\n0 ${nObjs}\n0000000000 65535 f \n`);
+    for (const off of offsets)
+        emit(`${String(off).padStart(10, "0")} 00000 n \n`);
+    emit(`trailer\n<< /Size ${nObjs} /Root 1 0 R >>\nstartxref\n${xrefOffset}\n%%EOF`);
+    return Buffer.concat(parts);
+}
+/**
+ * Resolve table style from tableStyleId + accent color scheme.
+ * OfficeImport's table styles are accent-based with fixed tint formulas.
+ * The most common styles (Medium Style 2, etc.) use accent1 with tinted bands.
+ */
+function resolveTableStyle(tableData, ctx) {
+    if (!tableData.tableStyleId)
+        return undefined;
+    const props = tableData.properties;
+    if (!props?.firstRow && !props?.bandRow)
+        return undefined;
+    // Resolve accent1 from color scheme
+    const accent1 = ctx.colorScheme?.colors?.accent1;
+    if (!accent1)
+        return undefined;
+    const resolved = resolveColor(accent1, ctx.colorMap, ctx.colorScheme);
+    const accentHex = `#${hex2(resolved.r)}${hex2(resolved.g)}${hex2(resolved.b)}`;
+    // Compute banded row tints (OfficeImport applies fixed tint levels to the accent color)
+    // Medium Style 2: odd rows ~40% tint, even rows ~20% tint
+    const oddBand = tintColor(resolved, 0.4);
+    const evenBand = tintColor(resolved, 0.2);
+    return {
+        accentColor: accentHex,
+        firstRow: props.firstRow ?? false,
+        bandRow: props.bandRow ?? false,
+        bandFills: [oddBand, evenBand],
+        headerBorderWidth: "3",
+        borderColor: "#ffffff",
+    };
+}
+/** Apply table style defaults for a specific cell position. */
+function getCellStyleDefaults(style, rowIdx, totalRows) {
+    // Header row (row 0 when firstRow=true)
+    if (style.firstRow && rowIdx === 0) {
+        return {
+            fill: style.accentColor,
+            borderWidth: style.headerBorderWidth,
+            borderColor: style.borderColor,
+        };
+    }
+    // Banded rows
+    if (style.bandRow) {
+        const dataRowIdx = style.firstRow ? rowIdx - 1 : rowIdx;
+        if (dataRowIdx >= 0) {
+            const isOdd = dataRowIdx % 2 === 0; // first data row is "odd"
+            return {
+                fill: isOdd ? style.bandFills[0] : style.bandFills[1],
+                borderWidth: "thin",
+                borderColor: style.borderColor,
+            };
+        }
+    }
+    return undefined;
+}
+/** Tint a color toward white by the given amount (0=white, 1=original). */
+function tintColor(c, amount) {
+    const r = Math.round(c.r + (255 - c.r) * (1 - amount));
+    const g = Math.round(c.g + (255 - c.g) * (1 - amount));
+    const b = Math.round(c.b + (255 - c.b) * (1 - amount));
+    return `#${hex2(r)}${hex2(g)}${hex2(b)}`;
+}
+/** Render a GraphicFrame (chart/SmartArt) using its pre-rendered fallback image. */
+function mapGraphicFrameFallbackImage(gf, b, ctx, attachments) {
+    // Fallback image data is pre-resolved in html-generator and stored on the GraphicFrame
+    const data = gf.fallbackImageData;
+    if (!data || !attachments)
+        return "";
+    const x = emuToPx(b.x);
+    const y = emuToPx(b.y);
+    const w = emuToPx(b.cx);
+    const h = emuToPx(b.cy);
+    const ext = detectImageExt(data);
+    const idx = nextAttachmentIndex();
+    const name = `Attachment${idx}.${ext}`;
+    attachments.set(name, data);
+    return `<img src="${name}" style="position:absolute; top:${y}; left:${x}; width:${w}; height:${h};">`;
+}
+function detectImageExt(buf) {
+    if (buf[0] === 0x89 && buf[1] === 0x50)
+        return "png";
+    if (buf[0] === 0xFF && buf[1] === 0xD8)
+        return "jpeg";
+    if (buf[0] === 0x47 && buf[1] === 0x49)
+        return "gif";
+    if (buf.length > 4 && buf.slice(0, 4).toString("ascii") === "RIFF")
+        return "webp";
+    // EMF/WMF headers
+    if (buf.length > 44 && buf[0] === 0x01 && buf[1] === 0x00 && buf[2] === 0x00 && buf[3] === 0x00)
+        return "emf";
+    return "png";
+}
+function fillToColor(fill, ctx) {
+    if (!fill)
+        return null;
+    if (fill.type === "solid")
+        return rgbaToHex(resolveColor(fill.color, ctx.colorMap, ctx.colorScheme));
+    if (fill.type === "noFill")
+        return null;
+    return null;
+}
+function strokeToColor(stroke, ctx) {
+    if (!stroke?.fill)
+        return null;
+    if (stroke.fill.type === "solid")
+        return rgbaToHex(resolveColor(stroke.fill.color, ctx.colorMap, ctx.colorScheme));
+    return null;
+}
+function rgbaToHex(c) {
+    if (c.a < 1)
+        return `rgba(${c.r},${c.g},${c.b},${c.a.toFixed(2)})`;
+    return `#${hex2(c.r)}${hex2(c.g)}${hex2(c.b)}`;
+}
+function hex2(n) {
+    return n.toString(16).padStart(2, "0");
+}