quicklook-pptx-renderer 0.1.0

package/dist/reader/transform.js

@@ -0,0 +1,21 @@
+export function readTransform(xfrm) {
+    if (xfrm == null)
+        return undefined;
+    const off = xfrm.off;
+    const ext = xfrm.ext;
+    if (off == null || ext == null)
+        return undefined;
+    const bounds = {
+        x: Number(off["@_x"] ?? 0),
+        y: Number(off["@_y"] ?? 0),
+        cx: Number(ext["@_cx"] ?? 0),
+        cy: Number(ext["@_cy"] ?? 0),
+    };
+    if (xfrm["@_rot"] != null)
+        bounds.rot = Number(xfrm["@_rot"]);
+    if (xfrm["@_flipH"] === "1" || xfrm["@_flipH"] === "true")
+        bounds.flipH = true;
+    if (xfrm["@_flipV"] === "1" || xfrm["@_flipV"] === "true")
+        bounds.flipV = true;
+    return bounds;
+}

package/dist/render/image-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { SKRSContext2D } from "@napi-rs/canvas";
+import type { Picture } from "../model/types.js";
+export declare function drawPicture(ctx: SKRSContext2D, pic: Picture, emuToPx: number, imageData?: Buffer | null): Promise<void>;

package/dist/render/image-renderer.js

@@ -0,0 +1,33 @@
+import { loadImage } from "@napi-rs/canvas";
+const EMU_PER_INCH = 914400;
+export async function drawPicture(ctx, pic, emuToPx, imageData) {
+    const b = pic.bounds;
+    if (!b)
+        return;
+    const data = imageData ?? pic.blipData;
+    if (!data)
+        return;
+    const x = b.x * emuToPx;
+    const y = b.y * emuToPx;
+    const w = b.cx * emuToPx;
+    const h = b.cy * emuToPx;
+    const img = await loadImage(data);
+    ctx.save();
+    if (b.rot) {
+        const cx = x + w / 2;
+        const cy = y + h / 2;
+        ctx.translate(cx, cy);
+        ctx.rotate((b.rot / 60000) * (Math.PI / 180));
+        ctx.translate(-cx, -cy);
+    }
+    if (b.flipH || b.flipV) {
+        ctx.translate(b.flipH ? x + w : 0, b.flipV ? y + h : 0);
+        ctx.scale(b.flipH ? -1 : 1, b.flipV ? -1 : 1);
+        if (b.flipH)
+            ctx.translate(-x, 0);
+        if (b.flipV)
+            ctx.translate(0, -y);
+    }
+    ctx.drawImage(img, x, y, w, h);
+    ctx.restore();
+}

package/dist/render/renderer.d.ts

@@ -0,0 +1,9 @@
+import type { Slide, Presentation } from "../model/types.js";
+import type { PptxPackage } from "../package/package.js";
+export interface RenderOptions {
+    width?: number;
+    scale?: number;
+    pkg?: PptxPackage;
+    slideIndex?: number;
+}
+export declare function renderSlide(slide: Slide, presentation: Presentation, options?: RenderOptions): Promise<Buffer>;

package/dist/render/renderer.js

@@ -0,0 +1,178 @@
+import { createCanvas } from "@napi-rs/canvas";
+import { resolveColor } from "../resolve/color-resolver.js";
+import { drawShape } from "./shape-renderer.js";
+import { drawTextBody } from "./text-renderer.js";
+import { drawPicture } from "./image-renderer.js";
+export async function renderSlide(slide, presentation, options) {
+    const baseWidth = options?.width ?? 1920;
+    const scale = options?.scale ?? 2;
+    const { cx: slideCx, cy: slideCy } = presentation.slideSize;
+    const canvasW = baseWidth * scale;
+    const canvasH = Math.round(canvasW * (slideCy / slideCx));
+    const emuToPx = canvasW / slideCx;
+    const canvas = createCanvas(canvasW, canvasH);
+    const ctx = canvas.getContext("2d");
+    // Resolve theme context from slide hierarchy
+    const master = slide.slideLayout.slideMaster;
+    const colorMap = slide.colorMapOverride
+        ?? slide.slideLayout.colorMapOverride
+        ?? master.colorMap;
+    const colorScheme = master.theme.colorScheme;
+    const fontScheme = master.theme.fontScheme;
+    // Background
+    const bg = resolveBackground(slide, colorMap, colorScheme);
+    ctx.fillStyle = bg;
+    ctx.fillRect(0, 0, canvasW, canvasH);
+    // Resolve image data for this slide
+    const imageMap = new Map();
+    if (options?.pkg && options?.slideIndex != null) {
+        const slidePath = `ppt/slides/slide${options.slideIndex + 1}.xml`;
+        try {
+            const slideRels = await options.pkg.getRelationships(slidePath);
+            for (const [rId, rel] of slideRels) {
+                if (rel.type === "image") {
+                    const imgPath = options.pkg.resolveRelTarget(slidePath, rel.target);
+                    const buf = await options.pkg.getPartBuffer(imgPath);
+                    if (buf)
+                        imageMap.set(rId, buf);
+                }
+            }
+        }
+        catch { /* slide rels might not exist */ }
+    }
+    // Render drawables in z-order (array order)
+    for (const drawable of slide.drawables) {
+        await drawDrawable(ctx, drawable, emuToPx, colorMap, colorScheme, fontScheme, imageMap);
+    }
+    return canvas.toBuffer("image/png");
+}
+// ── Drawable dispatch ───────────────────────────────────────────────
+async function drawDrawable(ctx, drawable, emuToPx, colorMap, colorScheme, fontScheme, imageMap) {
+    if (drawable.hidden)
+        return;
+    switch (drawable.drawableType) {
+        case "sp":
+            drawShapeWithText(ctx, drawable, emuToPx, colorMap, colorScheme, fontScheme);
+            break;
+        case "pic": {
+            const pic = drawable;
+            const imgData = pic.blipRId ? imageMap?.get(pic.blipRId) : undefined;
+            await drawPicture(ctx, pic, emuToPx, imgData);
+            break;
+        }
+        case "grpSp":
+            await drawGroup(ctx, drawable, emuToPx, colorMap, colorScheme, fontScheme, imageMap);
+            break;
+        case "cxnSp":
+            drawConnector(ctx, drawable, emuToPx, colorMap, colorScheme);
+            break;
+        // graphicFrame (tables/charts) not yet rendered
+    }
+}
+// ── Shape + text ────────────────────────────────────────────────────
+function drawShapeWithText(ctx, shape, emuToPx, colorMap, colorScheme, fontScheme) {
+    drawShape(ctx, shape, emuToPx, colorMap, colorScheme);
+    if (shape.textBody && shape.bounds) {
+        drawTextBody(ctx, shape.textBody, shape.bounds, emuToPx, colorMap, colorScheme, fontScheme);
+    }
+}
+// ── Group ───────────────────────────────────────────────────────────
+async function drawGroup(ctx, group, emuToPx, colorMap, colorScheme, fontScheme, imageMap) {
+    const b = group.bounds;
+    const cb = group.childBounds;
+    if (!b || !cb) {
+        for (const child of group.children) {
+            await drawDrawable(ctx, child, emuToPx, colorMap, colorScheme, fontScheme, imageMap);
+        }
+        return;
+    }
+    ctx.save();
+    // Translate to group position, then scale child coordinate space to group bounds
+    const gx = b.x * emuToPx;
+    const gy = b.y * emuToPx;
+    const gw = b.cx * emuToPx;
+    const gh = b.cy * emuToPx;
+    const cx = cb.x * emuToPx;
+    const cy = cb.y * emuToPx;
+    const cw = cb.cx * emuToPx;
+    const ch = cb.cy * emuToPx;
+    if (b.rot) {
+        const centerX = gx + gw / 2;
+        const centerY = gy + gh / 2;
+        ctx.translate(centerX, centerY);
+        ctx.rotate((b.rot / 60000) * (Math.PI / 180));
+        ctx.translate(-centerX, -centerY);
+    }
+    ctx.translate(gx, gy);
+    if (cw > 0 && ch > 0)
+        ctx.scale(gw / cw, gh / ch);
+    ctx.translate(-cx, -cy);
+    for (const child of group.children) {
+        await drawDrawable(ctx, child, emuToPx, colorMap, colorScheme, fontScheme, imageMap);
+    }
+    ctx.restore();
+}
+// ── Connector ───────────────────────────────────────────────────────
+function drawConnector(ctx, conn, emuToPx, colorMap, colorScheme) {
+    const b = conn.bounds;
+    if (!b)
+        return;
+    const x = b.x * emuToPx;
+    const y = b.y * emuToPx;
+    const w = b.cx * emuToPx;
+    const h = b.cy * emuToPx;
+    ctx.save();
+    if (b.rot) {
+        const cx = x + w / 2;
+        const cy = y + h / 2;
+        ctx.translate(cx, cy);
+        ctx.rotate((b.rot / 60000) * (Math.PI / 180));
+        ctx.translate(-cx, -cy);
+    }
+    const stroke = conn.stroke;
+    if (stroke?.width) {
+        ctx.lineWidth = stroke.width * emuToPx;
+        if (stroke.fill?.type === "solid") {
+            ctx.strokeStyle = rgbaStr(resolveColor(stroke.fill.color, colorMap, colorScheme));
+        }
+        else {
+            ctx.strokeStyle = "rgba(0,0,0,1)";
+        }
+    }
+    else {
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = "rgba(0,0,0,1)";
+    }
+    ctx.beginPath();
+    ctx.moveTo(x, y);
+    ctx.lineTo(x + w, y + h);
+    ctx.stroke();
+    ctx.restore();
+}
+// ── Background resolution ───────────────────────────────────────────
+function resolveBackground(slide, colorMap, colorScheme) {
+    // Check slide -> layout -> master for background fill
+    const bg = slide.background
+        ?? slide.slideLayout.background
+        ?? slide.slideLayout.slideMaster.background;
+    if (bg?.fill) {
+        const color = fillToRgba(bg.fill, colorMap, colorScheme);
+        if (color)
+            return rgbaStr(color);
+    }
+    return "rgba(255,255,255,1)";
+}
+function fillToRgba(fill, colorMap, colorScheme) {
+    if (fill.type === "solid")
+        return resolveColor(fill.color, colorMap, colorScheme);
+    if (fill.type === "gradient" && fill.stops.length > 0) {
+        return resolveColor(fill.stops[0].color, colorMap, colorScheme);
+    }
+    if (fill.type === "noFill")
+        return null;
+    return null;
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+function rgbaStr(c) {
+    return `rgba(${c.r},${c.g},${c.b},${c.a.toFixed(3)})`;
+}

package/dist/render/shape-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { SKRSContext2D } from "@napi-rs/canvas";
+import type { Shape, ColorMap, ColorScheme } from "../model/types.js";
+export declare function drawShape(ctx: SKRSContext2D, shape: Shape, emuToPx: number, colorMap: ColorMap, colorScheme: ColorScheme): void;

package/dist/render/shape-renderer.js

@@ -0,0 +1,175 @@
+import { resolveColor } from "../resolve/color-resolver.js";
+const EMU_PER_INCH = 914400;
+export function drawShape(ctx, shape, emuToPx, colorMap, colorScheme) {
+    const b = shape.bounds;
+    if (!b)
+        return;
+    const x = b.x * emuToPx;
+    const y = b.y * emuToPx;
+    const w = b.cx * emuToPx;
+    const h = b.cy * emuToPx;
+    ctx.save();
+    // Rotation
+    if (b.rot) {
+        const cx = x + w / 2;
+        const cy = y + h / 2;
+        ctx.translate(cx, cy);
+        ctx.rotate((b.rot / 60000) * (Math.PI / 180));
+        ctx.translate(-cx, -cy);
+    }
+    // Flips
+    if (b.flipH || b.flipV) {
+        ctx.translate(b.flipH ? x + w : 0, b.flipV ? y + h : 0);
+        ctx.scale(b.flipH ? -1 : 1, b.flipV ? -1 : 1);
+        if (b.flipH)
+            ctx.translate(-x, 0);
+        if (b.flipV)
+            ctx.translate(0, -y);
+    }
+    // Shadow (must be set before fill/stroke draw calls)
+    const shadow = shape.effects?.find((e) => e.type === "outerShdw");
+    if (shadow)
+        applyShadow(ctx, shadow, emuToPx, colorMap, colorScheme);
+    // Fill
+    const fillColor = resolveFill(shape.fill, colorMap, colorScheme);
+    if (fillColor)
+        ctx.fillStyle = rgbaStr(fillColor);
+    // Stroke
+    const stroke = shape.stroke;
+    const hasStroke = stroke?.width && stroke.width > 0;
+    if (hasStroke) {
+        ctx.lineWidth = stroke.width * emuToPx;
+        const strokeColor = resolveStrokeFill(stroke, colorMap, colorScheme);
+        ctx.strokeStyle = rgbaStr(strokeColor);
+    }
+    // Draw geometry
+    const preset = shape.geometry?.preset ?? "rect";
+    drawGeometry(ctx, preset, x, y, w, h, shape.geometry?.adjustValues, fillColor != null, hasStroke === true);
+    // Reset shadow
+    if (shadow) {
+        ctx.shadowBlur = 0;
+        ctx.shadowOffsetX = 0;
+        ctx.shadowOffsetY = 0;
+        ctx.shadowColor = "transparent";
+    }
+    ctx.restore();
+}
+// ── Geometry ────────────────────────────────────────────────────────
+function drawGeometry(ctx, preset, x, y, w, h, adjustValues, doFill, doStroke) {
+    switch (preset) {
+        case "ellipse": {
+            ctx.beginPath();
+            ctx.ellipse(x + w / 2, y + h / 2, w / 2, h / 2, 0, 0, Math.PI * 2);
+            if (doFill)
+                ctx.fill();
+            if (doStroke)
+                ctx.stroke();
+            break;
+        }
+        case "roundRect": {
+            const adj = parseAdj(adjustValues, "adj", 16667);
+            const radius = (adj / 100000) * Math.min(w, h);
+            drawRoundRect(ctx, x, y, w, h, radius);
+            if (doFill)
+                ctx.fill();
+            if (doStroke)
+                ctx.stroke();
+            break;
+        }
+        case "line":
+        case "straightConnector1": {
+            ctx.beginPath();
+            ctx.moveTo(x, y);
+            ctx.lineTo(x + w, y + h);
+            if (doStroke)
+                ctx.stroke();
+            break;
+        }
+        case "triangle": {
+            ctx.beginPath();
+            ctx.moveTo(x + w / 2, y);
+            ctx.lineTo(x + w, y + h);
+            ctx.lineTo(x, y + h);
+            ctx.closePath();
+            if (doFill)
+                ctx.fill();
+            if (doStroke)
+                ctx.stroke();
+            break;
+        }
+        case "diamond": {
+            ctx.beginPath();
+            ctx.moveTo(x + w / 2, y);
+            ctx.lineTo(x + w, y + h / 2);
+            ctx.lineTo(x + w / 2, y + h);
+            ctx.lineTo(x, y + h / 2);
+            ctx.closePath();
+            if (doFill)
+                ctx.fill();
+            if (doStroke)
+                ctx.stroke();
+            break;
+        }
+        default: {
+            // Fallback: rectangle
+            if (doFill)
+                ctx.fillRect(x, y, w, h);
+            if (doStroke)
+                ctx.strokeRect(x, y, w, h);
+            break;
+        }
+    }
+}
+function drawRoundRect(ctx, x, y, w, h, r) {
+    r = Math.min(r, w / 2, h / 2);
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.arcTo(x + w, y, x + w, y + h, r);
+    ctx.arcTo(x + w, y + h, x, y + h, r);
+    ctx.arcTo(x, y + h, x, y, r);
+    ctx.arcTo(x, y, x + w, y, r);
+    ctx.closePath();
+}
+function parseAdj(adjustValues, name, defaultVal) {
+    if (!adjustValues?.[name])
+        return defaultVal;
+    const raw = adjustValues[name];
+    // Adjustment formulas can be "val N" or just a number
+    const match = raw.match(/\d+/);
+    return match ? Number(match[0]) : defaultVal;
+}
+// ── Fill/stroke resolution ──────────────────────────────────────────
+function resolveFill(fill, colorMap, colorScheme) {
+    if (!fill)
+        return null;
+    if (fill.type === "noFill")
+        return null;
+    if (fill.type === "solid")
+        return resolveColor(fill.color, colorMap, colorScheme);
+    if (fill.type === "gradient" && fill.stops.length > 0) {
+        // Approximate gradient with first stop color
+        return resolveColor(fill.stops[0].color, colorMap, colorScheme);
+    }
+    return null;
+}
+function resolveStrokeFill(stroke, colorMap, colorScheme) {
+    if (stroke.fill?.type === "solid")
+        return resolveColor(stroke.fill.color, colorMap, colorScheme);
+    return { r: 0, g: 0, b: 0, a: 1 };
+}
+// ── Shadow ──────────────────────────────────────────────────────────
+function applyShadow(ctx, shadow, emuToPx, colorMap, colorScheme) {
+    const blur = (shadow.blurRad ?? 0) * emuToPx;
+    const dist = (shadow.dist ?? 0) * emuToPx;
+    const dirRad = ((shadow.dir ?? 0) / 60000) * (Math.PI / 180);
+    ctx.shadowBlur = blur;
+    ctx.shadowOffsetX = Math.cos(dirRad) * dist;
+    ctx.shadowOffsetY = Math.sin(dirRad) * dist;
+    ctx.shadowColor = shadow.color
+        ? rgbaStr(resolveColor(shadow.color, colorMap, colorScheme))
+        : "rgba(0,0,0,0.4)";
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+function rgbaStr(c) {
+    return `rgba(${c.r},${c.g},${c.b},${c.a.toFixed(3)})`;
+}

package/dist/render/text-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { SKRSContext2D } from "@napi-rs/canvas";
+import type { TextBody, OrientedBounds, ColorMap, ColorScheme, FontScheme } from "../model/types.js";
+export declare function drawTextBody(ctx: SKRSContext2D, textBody: TextBody, bounds: OrientedBounds, emuToPx: number, colorMap: ColorMap, colorScheme: ColorScheme, fontScheme?: FontScheme): void;

package/dist/render/text-renderer.js

@@ -0,0 +1,152 @@
+import { resolveColor } from "../resolve/color-resolver.js";
+import { resolveFontFamily } from "../resolve/font-map.js";
+const EMU_PER_PT = 12700;
+const DEFAULT_FONT_SIZE = 1800; // 18pt in hundredths
+const DEFAULT_LINE_HEIGHT_FACTOR = 1.2;
+// Default text body insets (EMU)
+const DEFAULT_L_INS = 91440;
+const DEFAULT_R_INS = 91440;
+const DEFAULT_T_INS = 45720;
+const DEFAULT_B_INS = 45720;
+export function drawTextBody(ctx, textBody, bounds, emuToPx, colorMap, colorScheme, fontScheme) {
+    const bp = textBody.properties;
+    // Text box in pixels
+    const lIns = (bp?.lIns ?? DEFAULT_L_INS) * emuToPx;
+    const rIns = (bp?.rIns ?? DEFAULT_R_INS) * emuToPx;
+    const tIns = (bp?.tIns ?? DEFAULT_T_INS) * emuToPx;
+    const bIns = (bp?.bIns ?? DEFAULT_B_INS) * emuToPx;
+    const boxX = bounds.x * emuToPx + lIns;
+    const boxY = bounds.y * emuToPx + tIns;
+    const boxW = bounds.cx * emuToPx - lIns - rIns;
+    const boxH = bounds.cy * emuToPx - tIns - bIns;
+    if (boxW <= 0 || boxH <= 0)
+        return;
+    // Measure total content height for vertical anchor
+    const lines = layoutParagraphs(ctx, textBody.paragraphs, boxW, emuToPx, colorMap, colorScheme, fontScheme);
+    const totalHeight = lines.reduce((sum, l) => sum + l.lineHeight, 0);
+    // Vertical anchor offset
+    const anchor = bp?.anchor ?? "t";
+    let yOffset = 0;
+    if (anchor === "ctr")
+        yOffset = Math.max(0, (boxH - totalHeight) / 2);
+    else if (anchor === "b")
+        yOffset = Math.max(0, boxH - totalHeight);
+    // Draw lines
+    ctx.save();
+    ctx.rect(boxX - 0.5, boxY - 0.5, boxW + 1, boxH + 1);
+    ctx.clip();
+    let curY = boxY + yOffset;
+    for (const line of lines) {
+        // Horizontal alignment offset
+        const slack = boxW - line.width;
+        let lineX = boxX;
+        if (line.align === "ctr")
+            lineX += slack / 2;
+        else if (line.align === "r")
+            lineX += slack;
+        let curX = lineX;
+        for (const seg of line.segments) {
+            ctx.font = seg.font;
+            ctx.fillStyle = rgbaStr(seg.color);
+            ctx.fillText(seg.text, curX, curY + line.ascent);
+            curX += seg.width;
+        }
+        curY += line.lineHeight;
+    }
+    ctx.restore();
+}
+function layoutParagraphs(ctx, paragraphs, boxW, emuToPx, colorMap, colorScheme, fontScheme) {
+    const allLines = [];
+    for (const para of paragraphs) {
+        const align = para.properties?.align ?? "l";
+        const segments = buildSegments(ctx, para.runs, emuToPx, colorMap, colorScheme, fontScheme);
+        if (segments.length === 0) {
+            // Empty paragraph -- still contributes a line break
+            const fontSize = resolveParaFontSize(para, emuToPx);
+            allLines.push({ segments: [], width: 0, lineHeight: fontSize * DEFAULT_LINE_HEIGHT_FACTOR, ascent: fontSize * 0.8, align });
+            continue;
+        }
+        // Word-wrap
+        const wrapped = wordWrap(segments, boxW);
+        for (const line of wrapped) {
+            const maxFontSize = Math.max(...line.map(s => s.fontSize), 1);
+            const lineHeight = maxFontSize * DEFAULT_LINE_HEIGHT_FACTOR;
+            const width = line.reduce((s, seg) => s + seg.width, 0);
+            allLines.push({ segments: line, width, lineHeight, ascent: maxFontSize * 0.8, align });
+        }
+    }
+    return allLines;
+}
+function buildSegments(ctx, runs, emuToPx, colorMap, colorScheme, fontScheme) {
+    const segments = [];
+    for (const run of runs) {
+        if (run.type === "br")
+            continue; // Line breaks handled by paragraph structure
+        const text = run.text;
+        if (!text)
+            continue;
+        const props = run.properties;
+        const fontSize = resolveRunFontSize(props, emuToPx);
+        const font = buildFontString(props, fontSize, fontScheme);
+        const color = resolveRunColor(props?.fill, colorMap, colorScheme);
+        ctx.font = font;
+        const width = ctx.measureText(text).width;
+        segments.push({ text, font, color, width, fontSize });
+    }
+    return segments;
+}
+function wordWrap(segments, maxWidth) {
+    if (segments.length === 0)
+        return [[]];
+    const lines = [[]];
+    let lineWidth = 0;
+    for (const seg of segments) {
+        // If the whole segment fits, add it directly
+        if (lineWidth + seg.width <= maxWidth || lineWidth === 0) {
+            lines[lines.length - 1].push(seg);
+            lineWidth += seg.width;
+            continue;
+        }
+        // Break at word boundaries within this segment
+        const words = seg.text.split(/(?<=\s)/); // split keeping trailing whitespace
+        for (const word of words) {
+            // We need a fresh width measurement approximation: proportional to char count
+            const wordWidth = seg.width * (word.length / seg.text.length);
+            if (lineWidth + wordWidth > maxWidth && lineWidth > 0) {
+                lines.push([]);
+                lineWidth = 0;
+            }
+            lines[lines.length - 1].push({ ...seg, text: word, width: wordWidth });
+            lineWidth += wordWidth;
+        }
+    }
+    return lines;
+}
+// ── Property resolution helpers ─────────────────────────────────────
+function resolveRunFontSize(props, emuToPx) {
+    const raw = props?.fontSize ?? DEFAULT_FONT_SIZE;
+    // fontSize is in hundredths of a point; convert: pts = raw/100, pixels = pts * EMU_PER_PT * emuToPx
+    return (raw / 100) * EMU_PER_PT * emuToPx;
+}
+function resolveParaFontSize(para, emuToPx) {
+    // Use the endParaRPr or first run's fontSize, or default
+    const raw = para.endParaRPr?.fontSize
+        ?? para.runs.find(r => r.properties?.fontSize)?.properties?.fontSize
+        ?? DEFAULT_FONT_SIZE;
+    return (raw / 100) * EMU_PER_PT * emuToPx;
+}
+function buildFontString(props, pxSize, fontScheme) {
+    const bold = props?.bold ? "bold " : "";
+    const italic = props?.italic ? "italic " : "";
+    const family = resolveFontFamily(props?.latinFont, fontScheme);
+    return `${italic}${bold}${pxSize}px "${family}"`;
+}
+function resolveRunColor(fill, colorMap, colorScheme) {
+    if (fill?.type === "solid")
+        return resolveColor(fill.color, colorMap, colorScheme);
+    return { r: 0, g: 0, b: 0, a: 1 }; // default black
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+function rgbaStr(c) {
+    return `rgba(${c.r},${c.g},${c.b},${c.a.toFixed(3)})`;
+}

package/dist/resolve/color-resolver.d.ts

@@ -0,0 +1,18 @@
+import type { Color, ColorMap, ColorScheme } from "../model/types.js";
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare function resolveColor(color: Color, colorMap: ColorMap, colorScheme: ColorScheme): RGBA;
+export declare function rgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslToRgb(h: number, s: number, l: number): {
+    r: number;
+    g: number;
+    b: number;
+};