quicklook-pptx-renderer 0.1.0

package/dist/mapper/slide-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { Slide, Presentation } from "../model/types.js";
+import type { StyleBuilder } from "./style-builder.js";
+import { type MapperContext } from "./drawable-mapper.js";
+export declare function mapSlide(slide: Slide, presentation: Presentation, styles: StyleBuilder, attachments: Map<string, Buffer>, ctx: MapperContext, slideWidthPx: number, slideHeightPx: number): string;

package/dist/mapper/slide-mapper.js

@@ -0,0 +1,112 @@
+import { resolveColor } from "../resolve/color-resolver.js";
+import { mapDrawable } from "./drawable-mapper.js";
+import { nextAttachmentIndex } from "./image-mapper.js";
+export function mapSlide(slide, presentation, styles, attachments, ctx, slideWidthPx, slideHeightPx) {
+    const parts = [];
+    // Background div — supports solid color and image fills
+    const bg = slide.background
+        ?? slide.slideLayout.background
+        ?? slide.slideLayout.slideMaster.background;
+    const bgCssParts = [`top:0`, `left:0`, `width:${slideWidthPx}`, `height:${slideHeightPx}`, `position:absolute`];
+    if (bg?.fill?.type === "image" && bg.fill.blipData) {
+        // Image background: render as img src (OfficeImport uses img tags, not CSS background)
+        const ext = detectBgImageExt(bg.fill.blipData);
+        const idx = nextAttachmentIndex();
+        const name = `Attachment${idx}.${ext}`;
+        attachments.set(name, bg.fill.blipData);
+        bgCssParts.push("background-color:#ffffff");
+        const bgClass = styles.addClass(bgCssParts.join("; ") + ";");
+        parts.push(`<div class="${bgClass}"></div>`);
+        parts.push(`<img src="${name}" style="position:absolute; top:0; left:0; width:${slideWidthPx}; height:${slideHeightPx};">`);
+    }
+    else {
+        const bgFillCss = resolveBackgroundFillCss(bg, ctx.colorMap, ctx.colorScheme);
+        bgCssParts.push(bgFillCss);
+        const bgClass = styles.addClass(bgCssParts.join("; ") + ";");
+        parts.push(`<div class="${bgClass}"></div>`);
+    }
+    // Drawables in z-order: master → layout → slide
+    for (const layer of [slide.slideLayout.slideMaster.drawables, slide.slideLayout.drawables]) {
+        for (const drawable of layer) {
+            if (drawable.placeholder)
+                continue;
+            const html = mapDrawable(drawable, styles, attachments, ctx);
+            if (html)
+                parts.push(html);
+        }
+    }
+    // Slide drawables — pass index for nanov2 bleed cache lookup
+    for (let i = 0; i < slide.drawables.length; i++) {
+        const html = mapDrawable(slide.drawables[i], styles, attachments, ctx, i);
+        if (html)
+            parts.push(html);
+    }
+    return parts.join("");
+}
+function resolveBackgroundFillCss(bg, colorMap, colorScheme) {
+    if (bg?.fill) {
+        const prop = fillToCssProp(bg.fill, colorMap, colorScheme);
+        if (prop)
+            return prop;
+    }
+    return "background-color:#ffffff";
+}
+function detectBgImageExt(buf) {
+    if (buf[0] === 0x89 && buf[1] === 0x50)
+        return "png";
+    if (buf[0] === 0xFF && buf[1] === 0xD8)
+        return "jpeg";
+    return "png";
+}
+function fillToCssProp(fill, colorMap, colorScheme) {
+    if (fill.type === "solid") {
+        return `background-color:${rgbaToColor(resolveColor(fill.color, colorMap, colorScheme))}`;
+    }
+    if (fill.type === "gradient" && fill.stops.length > 0) {
+        if (fill.stops.length === 2) {
+            const c1 = rgbaToColor(resolveColor(fill.stops[0].color, colorMap, colorScheme));
+            const c2 = rgbaToColor(resolveColor(fill.stops[1].color, colorMap, colorScheme));
+            const { from, to } = gradientPoints(fill.linear?.angle ?? 5400000);
+            return `background-image:-webkit-gradient(linear, ${from}, ${to}, from(${c1}), to(${c2}))`;
+        }
+        // 3+ stops: average to single color
+        let r = 0, g = 0, b = 0;
+        for (const stop of fill.stops) {
+            const c = resolveColor(stop.color, colorMap, colorScheme);
+            r += c.r;
+            g += c.g;
+            b += c.b;
+        }
+        const n = fill.stops.length;
+        return `background-color:${rgbaToColor({ r: Math.round(r / n), g: Math.round(g / n), b: Math.round(b / n), a: 1 })}`;
+    }
+    if (fill.type === "noFill")
+        return null;
+    return null;
+}
+function gradientPoints(angleDeg60k) {
+    const a = ((angleDeg60k / 60000) % 360 + 360) % 360;
+    if (a < 22.5 || a >= 337.5)
+        return { from: "left top", to: "right top" };
+    if (a < 67.5)
+        return { from: "left bottom", to: "right top" };
+    if (a < 112.5)
+        return { from: "left bottom", to: "left top" };
+    if (a < 157.5)
+        return { from: "right bottom", to: "left top" };
+    if (a < 202.5)
+        return { from: "right top", to: "left top" };
+    if (a < 247.5)
+        return { from: "right top", to: "left bottom" };
+    if (a < 292.5)
+        return { from: "left top", to: "left bottom" };
+    return { from: "left top", to: "right bottom" };
+}
+function rgbaToColor(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");
+}

package/dist/mapper/style-builder.d.ts

@@ -0,0 +1,12 @@
+/** Deduplicating CSS class builder. Mirrors CMStyle from OfficeImport. */
+export declare class StyleBuilder {
+    private counter;
+    private cache;
+    /** Register CSS declarations and get back the class name (e.g. "s5"). */
+    addClass(css: string): string;
+    /** Emit the <style> block content with triple-specificity selectors. */
+    getStyleSheet(): string;
+    /** Reset counter and cache (called per-slide). */
+    reset(startIndex: number): void;
+    get nextIndex(): number;
+}

package/dist/mapper/style-builder.js

@@ -0,0 +1,30 @@
+/** Deduplicating CSS class builder. Mirrors CMStyle from OfficeImport. */
+export class StyleBuilder {
+    counter = 0;
+    cache = new Map();
+    /** Register CSS declarations and get back the class name (e.g. "s5"). */
+    addClass(css) {
+        const existing = this.cache.get(css);
+        if (existing)
+            return existing;
+        const name = `s${this.counter++}`;
+        this.cache.set(css, name);
+        return name;
+    }
+    /** Emit the <style> block content with triple-specificity selectors. */
+    getStyleSheet() {
+        const lines = [];
+        for (const [css, name] of this.cache) {
+            lines.push(`.${name}.${name}.${name} {${css}}`);
+        }
+        return lines.join("\n");
+    }
+    /** Reset counter and cache (called per-slide). */
+    reset(startIndex) {
+        this.counter = startIndex;
+        this.cache.clear();
+    }
+    get nextIndex() {
+        return this.counter;
+    }
+}

package/dist/mapper/text-mapper.d.ts

@@ -0,0 +1,14 @@
+import type { TextBody, OrientedBounds, ColorMap, ColorScheme, FontScheme, Slide, Color } from "../model/types.js";
+import type { PlaceholderType } from "../model/enums.js";
+import type { StyleBuilder } from "./style-builder.js";
+export interface TextMapperContext {
+    colorMap: ColorMap;
+    colorScheme: ColorScheme;
+    fontScheme: FontScheme;
+    slide?: Slide;
+    placeholderType?: PlaceholderType;
+    fontRefColor?: Color;
+}
+export declare function mapTextBody(textBody: TextBody, bounds: OrientedBounds, styles: StyleBuilder, ctx: TextMapperContext): string;
+/** Render just the paragraphs (no margin wrapper). Used by table cells which provide their own wrapper. */
+export declare function mapTextParagraphs(textBody: TextBody, styles: StyleBuilder, ctx: TextMapperContext): string;

package/dist/mapper/text-mapper.js

@@ -0,0 +1,302 @@
+import { resolveColor } from "../resolve/color-resolver.js";
+import { resolveFontFamily } from "../resolve/font-map.js";
+import { resolveParagraphProperties } from "../resolve/inheritance.js";
+import { emuToPx } from "./constants.js";
+// Default text body insets in EMU (OOXML spec defaults)
+const DEFAULT_L_INS = 91440;
+const DEFAULT_R_INS = 91440;
+const DEFAULT_T_INS = 45720;
+const DEFAULT_B_INS = 45720;
+const DEFAULT_FONT_SIZE = 1800; // 18pt in hundredths
+// Track auto-number counters per scheme within mapTextParagraphs/mapTextBody calls
+let paraAutoNumCounters = new Map();
+// normAutoFit font scale factor (1.0 = no scaling)
+let currentFontScale = 1;
+export function mapTextBody(textBody, bounds, styles, ctx) {
+    const bp = textBody.properties;
+    const lIns = emuToPx(bp?.lIns ?? DEFAULT_L_INS);
+    const rIns = emuToPx(bp?.rIns ?? DEFAULT_R_INS);
+    const tIns = emuToPx(bp?.tIns ?? DEFAULT_T_INS);
+    const bIns = emuToPx(bp?.bIns ?? DEFAULT_B_INS);
+    const outerW = emuToPx(bounds.cx);
+    const outerH = emuToPx(bounds.cy);
+    // Vertical alignment
+    const anchor = bp?.anchor ?? "t";
+    const needsTable = anchor !== "t";
+    const marginCss = `margin-top:${tIns}px; margin-left:${lIns}px; margin-bottom:${bIns}px; margin-right:${rIns}px;`;
+    paraAutoNumCounters = new Map();
+    // normAutoFit: OfficeImport scales font sizes by fontScale percentage to fit text in shape
+    const fontScale = textBody.properties?.fontScale;
+    if (fontScale && fontScale !== 100000) {
+        currentFontScale = fontScale / 100000; // 100000 = 100%
+    }
+    else {
+        currentFontScale = 1;
+    }
+    // QL registers wrapper/table CSS classes BEFORE paragraph CSS.
+    // For table case: inner (table-cell) first, then outer (table), then paragraphs.
+    if (needsTable) {
+        const vAlign = anchor === "ctr" ? "middle" : "bottom";
+        let outerCss;
+        if (anchor === "b") {
+            outerCss = `${marginCss} display:table; top:-10000; left:0; width:${outerW}; height:${outerH + 10000}; position:absolute;`;
+        }
+        else {
+            outerCss = `${marginCss} display:table; width:${outerW}; height:${outerH};`;
+        }
+        const innerCss = `display:table-cell; vertical-align:${vAlign};`;
+        const innerClass = styles.addClass(innerCss);
+        const outerClass = styles.addClass(outerCss);
+        const paragraphs = textBody.paragraphs.map((p, i) => mapParagraph(p, styles, ctx, i)).join("");
+        return `<div class="${outerClass}"><div class="${innerClass}">${paragraphs}</div></div>`;
+    }
+    const wrapperClass = styles.addClass(marginCss);
+    const paragraphs = textBody.paragraphs.map((p, i) => mapParagraph(p, styles, ctx, i)).join("");
+    return `<div class="${wrapperClass}">${paragraphs}</div>`;
+}
+/** Render just the paragraphs (no margin wrapper). Used by table cells which provide their own wrapper. */
+export function mapTextParagraphs(textBody, styles, ctx) {
+    paraAutoNumCounters = new Map();
+    return textBody.paragraphs.map((p, i) => mapParagraph(p, styles, ctx, i)).join("");
+}
+function mapParagraph(para, styles, ctx, paraIndex = 0) {
+    const pp = para.properties;
+    const parts = [];
+    const pCss = [];
+    // Resolve paragraph properties through inheritance chain
+    const level = pp?.level ?? 0;
+    const resolved = ctx.slide
+        ? resolveParagraphProperties(pp, ctx.slide, level, ctx.placeholderType)
+        : pp;
+    // Line height: only when explicitly set, formula: 1.2 * (pctVal / 100000)
+    const lh = resolved?.lineSpacing;
+    if (lh && lh.type === "pct" && lh.val !== 100000) {
+        pCss.push(`line-height:${(1.2 * lh.val / 100000).toFixed(6)}`);
+    }
+    if (resolved?.align && resolved.align !== "l") {
+        const alignMap = { ctr: "center", r: "right", just: "justify", dist: "justify" };
+        const mapped = alignMap[resolved.align];
+        if (mapped)
+            pCss.push(`text-align:${mapped}`);
+    }
+    // Font-family: local paragraph → endParaRPr → inherited
+    const fontSource = pp?.latinFont ?? para.endParaRPr?.latinFont ?? resolved?.latinFont;
+    let resolvedParaFont;
+    if (fontSource) {
+        resolvedParaFont = resolveFontFamily(fontSource, ctx.fontScheme);
+        pCss.push(`font-family:"${resolvedParaFont}"`);
+    }
+    // Font-size: local paragraph → endParaRPr → inherited → default
+    // Apply normAutoFit fontScale if active
+    const baseFontSize = pp?.fontSize ?? para.endParaRPr?.fontSize ?? resolved?.fontSize ?? DEFAULT_FONT_SIZE;
+    const baseFontPx = Math.trunc((baseFontSize * currentFontScale) / 100);
+    pCss.push(`font-size:${baseFontPx}`);
+    // Space before/after paragraphs — OfficeImport uses padding, not margin (confirmed by probes)
+    // spcBefore is skipped on the first paragraph (QL doesn't apply it there)
+    const spcBefore = resolved?.spaceBefore ?? pp?.spaceBefore;
+    const spcAfter = resolved?.spaceAfter ?? pp?.spaceAfter;
+    if (spcBefore && paraIndex > 0) {
+        if (spcBefore.type === "pts")
+            pCss.push(`padding-top:${Math.trunc(spcBefore.val / 100)}px`);
+        else if (spcBefore.type === "pct")
+            pCss.push(`padding-top:${(spcBefore.val / 1000).toFixed(1)}%`);
+    }
+    if (spcAfter) {
+        if (spcAfter.type === "pts")
+            pCss.push(`padding-bottom:${Math.trunc(spcAfter.val / 100)}px`);
+        else if (spcAfter.type === "pct")
+            pCss.push(`padding-bottom:${(spcAfter.val / 1000).toFixed(1)}%`);
+    }
+    // Paragraph margins from bullet/list formatting
+    const marL = resolved?.marL ?? pp?.marL;
+    const indent = resolved?.indent ?? pp?.indent;
+    if (marL != null && marL !== 0)
+        pCss.push(`margin-left:${emuToPx(marL)}px`);
+    if (indent != null && indent !== 0)
+        pCss.push(`text-indent:${emuToPx(indent)}px`);
+    const pClass = styles.addClass(pCss.join("; ") + ";");
+    // Emit bullet span if paragraph has a bullet
+    const bullet = resolved?.bullet ?? pp?.bullet;
+    if (bullet && bullet.type !== "none") {
+        const marLPx = marL != null ? emuToPx(marL) : 0;
+        const bulletMarginLeft = -marLPx;
+        // Resolve bullet color from properties (bulletColor → text color → tx1)
+        const bulletClr = resolved?.bulletColor ?? pp?.bulletColor;
+        const bulletColor = bulletClr
+            ? rgbaToHex(resolveColor(bulletClr, ctx.colorMap, ctx.colorScheme))
+            : "#000000";
+        // Bullet font size: bulletSizePoints, bulletSizePercent, or first run's font size
+        const bulletSizePts = resolved?.bulletSizePoints ?? pp?.bulletSizePoints;
+        const bulletSizePct = resolved?.bulletSizePercent ?? pp?.bulletSizePercent;
+        const firstRunFontSize = para.runs[0]?.properties?.fontSize;
+        const bulletFontPx = bulletSizePts
+            ? Math.trunc(bulletSizePts / 100)
+            : bulletSizePct
+                ? Math.trunc(baseFontPx * bulletSizePct / 100000)
+                : firstRunFontSize
+                    ? Math.trunc((firstRunFontSize * currentFontScale) / 100)
+                    : baseFontPx;
+        // OfficeImport bullet padding scales with font size.
+        // Empirically: ~3x font size for char bullets, ~3.2x for autonum.
+        const bulletPaddingRight = bullet.type === "autoNum"
+            ? Math.round(bulletFontPx * 3.17)
+            : Math.round(bulletFontPx * 2.94);
+        // Bullet font family
+        const bulletFontFamily = resolved?.bulletFont ?? pp?.bulletFont;
+        let bulletFontCss = "";
+        if (bulletFontFamily) {
+            bulletFontCss = `font-family:"${bulletFontFamily}"; `;
+        }
+        let bulletText = "";
+        if (bullet.type === "char" && bullet.char) {
+            bulletText = escapeHtml(bullet.char);
+        }
+        else if (bullet.type === "autoNum") {
+            bulletText = escapeHtml(formatAutoNumber(bullet.autoNumScheme, bullet.startAt ?? 1, paraAutoNumCounters.get(bullet.autoNumScheme ?? "arabicPeriod") ?? 0));
+            const scheme = bullet.autoNumScheme ?? "arabicPeriod";
+            paraAutoNumCounters.set(scheme, (paraAutoNumCounters.get(scheme) ?? 0) + 1);
+        }
+        if (bulletText) {
+            const bulletCss = `margin-left:${bulletMarginLeft}px; padding-right:${bulletPaddingRight}px; font-size: ${bulletFontPx}; color:${bulletColor}; ${bulletFontCss}`;
+            const bulletClass = styles.addClass(bulletCss);
+            parts.push(`<span class="${bulletClass}">${bulletText}</span>`);
+        }
+    }
+    for (const run of para.runs) {
+        if (run.type === "br") {
+            parts.push("<br>");
+            continue;
+        }
+        const text = escapeHtml(String(run.text ?? ""));
+        if (!text)
+            continue;
+        const rp = run.properties;
+        const spanCss = buildRunCss(rp, baseFontSize, ctx, resolvedParaFont);
+        if (spanCss) {
+            const spanClass = styles.addClass(spanCss);
+            parts.push(`<span class="${spanClass}">${text}</span>`);
+        }
+        else {
+            parts.push(`<span>${text}</span>`);
+        }
+    }
+    // QL emits &nbsp; for empty paragraphs (no span wrapper) to preserve line height.
+    const content = parts.length > 0 ? parts.join("") : "\u00a0";
+    return `<p class="${pClass}">${content}</p>`;
+}
+function buildRunCss(rp, baseFontSize, ctx, paraFontFamily) {
+    if (!rp)
+        return "";
+    const parts = [];
+    const color = runColor(rp, ctx);
+    parts.push(`color:${color}`);
+    if (rp.bold)
+        parts.push("font-weight:bold");
+    if (rp.italic)
+        parts.push("font-style:italic");
+    const fontSize = rp.fontSize ?? baseFontSize;
+    const fontPx = Math.trunc((fontSize * currentFontScale) / 100);
+    parts.push(`font-size:${fontPx}`);
+    // OfficeImport always emits font-family on spans, inheriting from paragraph if not set on run
+    if (rp.latinFont) {
+        const family = resolveFontFamily(rp.latinFont, ctx.fontScheme);
+        parts.push(`font-family:"${family}"`);
+    }
+    else if (paraFontFamily) {
+        parts.push(`font-family:"${paraFontFamily}"`);
+    }
+    if (rp.underline && rp.underline !== "none")
+        parts.push("text-decoration:underline");
+    if (rp.strikethrough === "sngStrike")
+        parts.push("text-decoration:line-through");
+    if (rp.caps === "all")
+        parts.push("text-transform:uppercase");
+    if (rp.caps === "small")
+        parts.push("font-variant:small-caps");
+    // Superscript/subscript: OfficeImport just renders with reduced font size,
+    // does NOT use CSS vertical-align:super/sub. The baseline attribute adjusts
+    // the font size but the text stays on the same baseline visually.
+    // (Confirmed by QL output: no vertical-align in CSS for baseline text)
+    // Character spacing (hundredths of a point → px, 1pt = 1px at 72dpi)
+    if (rp.spacing != null && rp.spacing !== 0) {
+        const spacingPx = rp.spacing / 100;
+        const spacingStr = Number.isInteger(spacingPx) ? `${spacingPx}` : spacingPx.toFixed(1);
+        parts.push(`letter-spacing:${spacingStr}px`);
+    }
+    return parts.join("; ") + ";";
+}
+function runColor(rp, ctx) {
+    if (rp.fill && rp.fill.type === "solid") {
+        const rgba = resolveColor(rp.fill.color, ctx.colorMap, ctx.colorScheme);
+        return rgbaToHex(rgba);
+    }
+    // fontRef color from shapeStyle: fallback when run has no explicit color
+    if (ctx.fontRefColor) {
+        const rgba = resolveColor(ctx.fontRefColor, ctx.colorMap, ctx.colorScheme);
+        return rgbaToHex(rgba);
+    }
+    const tx1Scheme = ctx.colorMap.mappings.tx1;
+    if (tx1Scheme) {
+        const rgba = resolveColor({ type: "scheme", val: tx1Scheme }, ctx.colorMap, ctx.colorScheme);
+        return rgbaToHex(rgba);
+    }
+    return "#000000";
+}
+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");
+}
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        // OfficeImport converts second space in consecutive pairs to &nbsp;
+        // to prevent HTML whitespace collapse. Match this behavior.
+        .replace(/ {2}/g, " &nbsp;");
+}
+function formatAutoNumber(scheme, startAt, index) {
+    const num = startAt + index;
+    switch (scheme) {
+        case "arabicPlain": return `${num}`;
+        case "arabicPeriod": return `${num}.`;
+        case "arabicParenR": return `${num})`;
+        case "arabicParenBoth": return `(${num})`;
+        case "romanLcPeriod": return `${toRoman(num).toLowerCase()}.`;
+        case "romanUcPeriod": return `${toRoman(num)}.`;
+        case "alphaLcPeriod": return `${toAlpha(num).toLowerCase()}.`;
+        case "alphaUcPeriod": return `${toAlpha(num)}.`;
+        case "alphaLcParenR": return `${toAlpha(num).toLowerCase()})`;
+        case "alphaUcParenR": return `${toAlpha(num)})`;
+        case "alphaLcParenBoth": return `(${toAlpha(num).toLowerCase()})`;
+        case "alphaUcParenBoth": return `(${toAlpha(num)})`;
+        default: return `${num}.`;
+    }
+}
+function toRoman(n) {
+    const vals = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+    const syms = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
+    let result = "";
+    for (let i = 0; i < vals.length; i++) {
+        while (n >= vals[i]) {
+            result += syms[i];
+            n -= vals[i];
+        }
+    }
+    return result;
+}
+function toAlpha(n) {
+    let result = "";
+    while (n > 0) {
+        n--;
+        result = String.fromCharCode(65 + (n % 26)) + result;
+        n = Math.floor(n / 26);
+    }
+    return result;
+}

package/dist/model/enums.d.ts

@@ -0,0 +1,25 @@
+export type SchemeColorName = "dk1" | "lt1" | "dk2" | "lt2" | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "accent6" | "hlink" | "folHlink" | "tx1" | "tx2" | "bg1" | "bg2" | "phClr";
+export type ColorMapIndex = "bg1" | "tx1" | "bg2" | "tx2" | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "accent6" | "hlink" | "folHlink";
+export type ColorTransformType = "tint" | "shade" | "comp" | "inv" | "gray" | "alpha" | "alphaOff" | "alphaMod" | "hue" | "hueOff" | "hueMod" | "sat" | "satOff" | "satMod" | "lum" | "lumOff" | "lumMod" | "red" | "redOff" | "redMod" | "green" | "greenOff" | "greenMod" | "blue" | "blueOff" | "blueMod";
+export type PresetGeometry = "rect" | "roundRect" | "ellipse" | "triangle" | "rtTriangle" | "diamond" | "parallelogram" | "trapezoid" | "pentagon" | "hexagon" | "star4" | "star5" | "star6" | "star8" | "line" | "straightConnector1" | "rightArrow" | "leftArrow" | "upArrow" | "downArrow" | "chevron" | "ribbon" | "ribbon2" | "flowChartProcess" | "flowChartDecision" | "flowChartTerminator" | "callout1" | "callout2" | "callout3" | "cloud" | "heart" | "lightningBolt" | "frame" | "bevel" | "donut" | "noSmoking" | "blockArc" | "wedgeRoundRectCallout" | "wedgeEllipseCallout" | string;
+export type TextAlignment = "l" | "ctr" | "r" | "just" | "dist";
+export type TextAnchorType = "t" | "ctr" | "b";
+export type WrapType = "square" | "none";
+export type FlowType = "horz" | "vert" | "vert270" | "wordArtVert" | "wordArtVertRtl" | "eaVert";
+export type TextAutoFitType = "noAutoFit" | "normAutoFit" | "spAutoFit";
+export type UnderlineType = "none" | "sng" | "dbl" | "heavy" | "dotted" | "dottedHeavy" | "dash" | "dashHeavy" | "dashLong" | "dashLongHeavy" | "dotDash" | "dotDashHeavy" | "dotDotDash" | "dotDotDashHeavy" | "wavy" | "wavyHeavy" | "wavyDbl" | string;
+export type StrikeThroughType = "noStrike" | "sngStrike" | "dblStrike";
+export type CapsType = "none" | "small" | "all";
+export type DashType = "solid" | "dot" | "dash" | "lgDash" | "dashDot" | "lgDashDot" | "lgDashDotDot" | "sysDash" | "sysDot" | "sysDashDot" | "sysDashDotDot";
+export type LineCapType = "flat" | "sq" | "rnd";
+export type LineJoinType = "round" | "bevel" | "miter";
+export type CompoundType = "sng" | "dbl" | "thickThin" | "thinThick" | "tri";
+export type LineEndType = "none" | "triangle" | "stealth" | "diamond" | "oval" | "arrow";
+export type LineEndSize = "sm" | "med" | "lg";
+export type FontReferenceIndex = "major" | "minor" | "none";
+export type PlaceholderType = "title" | "body" | "ctrTitle" | "subTitle" | "dt" | "ftr" | "sldNum" | "sldImg" | "chart" | "tbl" | "clipArt" | "dgm" | "media" | "obj" | "pic" | string;
+export type SlideLayoutType = "blank" | "title" | "obj" | "secHead" | "twoObj" | "titleOnly" | "cust" | "twoTxTwoObj" | "twoObjAndTx" | "twoObjOverTx" | "objTx" | "txObj" | "objOnly" | "picTx" | "txAndChart" | "txAndClipArt" | "txAndMedia" | "dgm" | "chart" | "txAndObj" | "clipArtAndTx" | "mediaAndTx" | "objAndTx" | "objOverTx" | "vertTitleAndTx" | "vertTx" | string;
+export type BulletType = "char" | "autoNum" | "blip" | "none";
+export type AutoNumberScheme = "arabicPlain" | "arabicPeriod" | "arabicParenR" | "arabicParenBoth" | "romanLcPeriod" | "romanUcPeriod" | "alphaLcPeriod" | "alphaUcPeriod" | "alphaLcParenR" | "alphaUcParenR" | "alphaLcParenBoth" | "alphaUcParenBoth" | string;
+export type PatternType = "pct5" | "pct10" | "pct20" | "pct25" | "pct30" | "pct40" | "pct50" | "pct60" | "pct70" | "pct75" | "pct80" | "pct90" | "horz" | "vert" | "ltHorz" | "ltVert" | "dkHorz" | "dkVert" | "narHorz" | "narVert" | "wdHorz" | "wdVert" | "dashHorz" | "dashVert" | "cross" | "dnDiag" | "upDiag" | "ltDnDiag" | "ltUpDiag" | "dkDnDiag" | "dkUpDiag" | "wdDnDiag" | "wdUpDiag" | "dashDnDiag" | "dashUpDiag" | "diagCross" | "smCheck" | "lgCheck" | "smGrid" | "lgGrid" | "dotGrid" | "smConfetti" | "lgConfetti" | "horzBrick" | "diagBrick" | "solidDmnd" | "openDmnd" | "dotDmnd" | "plaid" | "sphere" | "weave" | "divot" | "shingle" | "wave" | "trellis" | "zigZag" | string;
+export type ShadowAlignment = "tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br";

package/dist/model/enums.js

@@ -0,0 +1,2 @@
+// Mirrors OAD* enum types from OfficeImport headers
+export {};