@qvac/harness 0.7.3 → 0.8.0

package/dist-lib/lib/office/engine/pptx/read.d.ts

@@ -0,0 +1,9 @@
+import type { Document } from '../xml.ts';
+import type { ShapeEntry } from './shapes.ts';
+import type { ReadOptions, ShapeInfo } from './types.ts';
+export declare const BODY_TYPES: Set<string>;
+export declare function pick(total: number, opts: ReadOptions): (i: number) => boolean;
+export declare function layoutName(doc: Document): string;
+export declare function layoutType(doc: Document): string;
+export declare function hasBody(doc: Document): boolean;
+export declare function describe(shape: ShapeEntry): ShapeInfo;

package/dist-lib/lib/office/engine/pptx/read.js

@@ -0,0 +1,66 @@
+import * as xml from '../xml.js';
+import * as text from '../drawingml/text.js';
+import { DocsError } from '../errors.js';
+import { shapesOf } from './shapes.js';
+const { a: A, p: P } = xml.ns;
+export const BODY_TYPES = new Set(['body', 'obj', 'subTitle']);
+function window(total, opts) {
+    const from = opts.from ?? 0;
+    const count = opts.count ?? Math.max(total, 1);
+    if (!Number.isInteger(from) || from < 0 || (from >= total && total > 0)) {
+        throw new DocsError('INVALID_OPTIONS', `from must be a slide index from 0 to ${Math.max(0, total - 1)}, got ${String(opts.from)}`);
+    }
+    if (!Number.isInteger(count) || count < 1) {
+        throw new DocsError('INVALID_OPTIONS', `count must be at least 1, got ${String(opts.count)}`);
+    }
+    return { from, to: Math.min(total, from + count) };
+}
+export function pick(total, opts) {
+    if (opts.slides === undefined) {
+        const { from, to } = window(total, opts);
+        return (i) => i >= from && i < to;
+    }
+    if (opts.from !== undefined || opts.count !== undefined) {
+        throw new DocsError('INVALID_OPTIONS', 'pass either slides or from/count, not both');
+    }
+    const slides = opts.slides;
+    const valid = Array.isArray(slides) && slides.every((i) => Number.isInteger(i) && i >= 0 && i < total);
+    if (!valid) {
+        throw new DocsError('SLIDE_NOT_FOUND', `slides must list slide indexes from 0 to ${total - 1}`);
+    }
+    const set = new Set(slides);
+    return (i) => set.has(i);
+}
+export function layoutName(doc) {
+    const cSld = xml.child(xml.root(doc), P, 'cSld');
+    return cSld?.getAttribute('name') || '';
+}
+export function layoutType(doc) {
+    return xml.root(doc).getAttribute('type') || 'cust';
+}
+export function hasBody(doc) {
+    return shapesOf(doc).some((s) => s.placeholder !== null && BODY_TYPES.has(s.placeholder) && s.placeholder !== 'subTitle');
+}
+function tableRows(shape) {
+    return xml.descendants(shape.el, A, 'tr').map((tr) => xml.children(tr, A, 'tc').map((tc) => {
+        const txBody = xml.child(tc, A, 'txBody');
+        return txBody ? text.readText(txBody) : '';
+    }));
+}
+export function describe(shape) {
+    const out = { id: shape.id, name: shape.name, kind: shape.kind };
+    if (shape.placeholder) {
+        out.placeholder = shape.placeholder;
+    }
+    if (shape.group !== null) {
+        out.group = shape.group;
+    }
+    if (shape.kind === 'text') {
+        const txBody = xml.child(shape.el, P, 'txBody');
+        out.paragraphs = txBody ? text.readParagraphs(txBody) : [];
+    }
+    else if (shape.kind === 'table') {
+        out.rows = tableRows(shape);
+    }
+    return out;
+}

package/dist-lib/lib/office/engine/pptx/shapes.d.ts

@@ -0,0 +1,52 @@
+import type { Document, Element } from '../xml.ts';
+import type { Box } from './inherit.ts';
+export type ShapeKind = 'text' | 'shape' | 'picture' | 'group' | 'connector' | 'table' | 'chart' | 'diagram' | 'frame';
+export interface ShapeEntry {
+    el: Element;
+    id: number | null;
+    name: string;
+    kind: ShapeKind;
+    placeholder: string | null;
+    group: number | null;
+}
+export type Cell = string | number | null;
+export interface PictureFrame {
+    id: number;
+    rId: string;
+    box: Box;
+    name?: string;
+    description?: string;
+}
+export interface TextBoxFrame {
+    id: number;
+    box: Box;
+    text?: unknown;
+    style?: unknown;
+    fill?: unknown;
+    name?: string;
+}
+export interface TableFrame {
+    id: number;
+    box: Box;
+    rows: unknown;
+    header?: boolean;
+    name?: string;
+    tableStyle: string;
+}
+export interface ChartFrame {
+    id: number;
+    box: Box;
+    rId: string;
+    name?: string;
+}
+export declare const SHAPE_ORDER: string[];
+export declare function shapesOf(doc: Document): ShapeEntry[];
+export declare function placeholderFrom(doc: Document, source: ShapeEntry, id: number): Element;
+export declare function pictureElement(doc: Document, frame: PictureFrame): Element;
+export declare function nextShapeId(doc: Document): number;
+export declare function validateColor(color: unknown, name?: string): string;
+export declare function textBoxElement(doc: Document, frame: TextBoxFrame): Element;
+export declare function validateRows(rows: unknown): Cell[][];
+export declare function tableElement(doc: Document, frame: TableFrame): Element;
+export declare function chartFrameElement(doc: Document, frame: ChartFrame): Element;
+export declare function setBackground(doc: Document, color: unknown): void;

package/dist-lib/lib/office/engine/pptx/shapes.js

@@ -0,0 +1,276 @@
+import * as xml from '../xml.js';
+import * as text from '../drawingml/text.js';
+import * as chart from '../drawingml/chart.js';
+import { DocsError } from '../errors.js';
+const { a: A, p: P, r: R } = xml.ns;
+export const SHAPE_ORDER = ['nvSpPr', 'spPr', 'style', 'txBody', 'extLst'];
+const TABLE_URI = 'http://schemas.openxmlformats.org/drawingml/2006/table';
+function graphicKind(el) {
+    if (xml.descendants(el, A, 'tbl').length)
+        return 'table';
+    const data = xml.descendants(el, A, 'graphicData')[0];
+    const uri = data?.getAttribute('uri') ?? '';
+    if (uri.endsWith('/chart')) {
+        return 'chart';
+    }
+    if (uri.endsWith('/diagram')) {
+        return 'diagram';
+    }
+    return 'frame';
+}
+function kindOf(el) {
+    switch (el.localName) {
+        case 'sp': {
+            const nv = xml.children(el)[0];
+            const placeholder = nv ? xml.descendants(nv, P, 'ph').length > 0 : false;
+            return xml.child(el, P, 'txBody') || placeholder ? 'text' : 'shape';
+        }
+        case 'pic':
+            return 'picture';
+        case 'grpSp':
+            return 'group';
+        case 'cxnSp':
+            return 'connector';
+        case 'graphicFrame':
+            return graphicKind(el);
+        default:
+            return null;
+    }
+}
+function entryOf(el, kind, group) {
+    const nv = xml.children(el)[0];
+    const cNvPr = nv ? xml.child(nv, P, 'cNvPr') : null;
+    const nvPr = nv ? xml.child(nv, P, 'nvPr') : null;
+    const ph = nvPr ? xml.child(nvPr, P, 'ph') : null;
+    return {
+        el,
+        id: cNvPr ? Number(cNvPr.getAttribute('id')) : null,
+        name: cNvPr?.getAttribute('name') ?? '',
+        kind,
+        placeholder: ph ? ph.getAttribute('type') || 'obj' : null,
+        group
+    };
+}
+function walk(container, group, out) {
+    for (const el of xml.children(container, P)) {
+        const kind = kindOf(el);
+        if (!kind) {
+            continue;
+        }
+        const shape = entryOf(el, kind, group);
+        out.push(shape);
+        if (kind === 'group') {
+            walk(el, shape.id, out);
+        }
+    }
+}
+export function shapesOf(doc) {
+    const spTree = xml.descendants(doc, P, 'spTree')[0];
+    const out = [];
+    if (spTree) {
+        walk(spTree, null, out);
+    }
+    return out;
+}
+export function placeholderFrom(doc, source, id) {
+    const p = xml.builder(doc, P);
+    const a = xml.builder(doc, A);
+    const sourceNv = xml.children(source.el)[0];
+    const sourceNvPr = sourceNv ? xml.child(sourceNv, P, 'nvPr') : null;
+    const sourcePh = sourceNvPr ? xml.child(sourceNvPr, P, 'ph') : null;
+    const sp = p('sp');
+    const nvSpPr = xml.append(sp, p('nvSpPr'));
+    nvSpPr.appendChild(p('cNvPr', { id, name: source.name || `Placeholder ${id - 1}` }));
+    xml.append(nvSpPr, p('cNvSpPr')).appendChild(a('spLocks', { noGrp: 1 }));
+    const ph = xml.append(xml.append(nvSpPr, p('nvPr')), p('ph'));
+    for (const name of ['type', 'orient', 'sz', 'idx']) {
+        const value = sourcePh?.getAttribute(name);
+        if (value !== null && value !== undefined) {
+            ph.setAttribute(name, value);
+        }
+    }
+    sp.appendChild(p('spPr'));
+    text.ensureTextBody(sp, SHAPE_ORDER);
+    return sp;
+}
+function xfrm(doc, box, namespace) {
+    const a = xml.builder(doc, A);
+    const el = xml.builder(doc, namespace)('xfrm');
+    el.appendChild(a('off', { x: box.x, y: box.y }));
+    el.appendChild(a('ext', { cx: box.width, cy: box.height }));
+    return el;
+}
+function rectangle(doc) {
+    const a = xml.builder(doc, A);
+    const geom = a('prstGeom', { prst: 'rect' });
+    geom.appendChild(a('avLst'));
+    return geom;
+}
+export function pictureElement(doc, frame) {
+    const p = xml.builder(doc, P);
+    const a = xml.builder(doc, A);
+    const pic = p('pic');
+    const nv = xml.append(pic, p('nvPicPr'));
+    nv.appendChild(p('cNvPr', {
+        id: frame.id,
+        name: frame.name || `Picture ${frame.id - 1}`,
+        descr: frame.description
+    }));
+    xml.append(nv, p('cNvPicPr')).appendChild(a('picLocks', { noChangeAspect: 1 }));
+    nv.appendChild(p('nvPr'));
+    const fill = xml.append(pic, p('blipFill'));
+    const blip = xml.append(fill, a('blip'));
+    xml.setNsAttribute(blip, { namespace: R, local: 'embed' }, frame.rId);
+    xml.append(fill, a('stretch')).appendChild(a('fillRect'));
+    const spPr = xml.append(pic, p('spPr'));
+    spPr.appendChild(xfrm(doc, frame.box, A));
+    spPr.appendChild(rectangle(doc));
+    return pic;
+}
+export function nextShapeId(doc) {
+    let max = 0;
+    for (const el of xml.descendants(doc, P, 'cNvPr')) {
+        max = Math.max(max, Number(el.getAttribute('id')) || 0);
+    }
+    return max + 1;
+}
+function solidFill(doc, color) {
+    const a = xml.builder(doc, A);
+    const fill = a('solidFill');
+    fill.appendChild(a('srgbClr', { val: color.replace('#', '').toUpperCase() }));
+    return fill;
+}
+export function validateColor(color, name = 'color') {
+    if (typeof color !== 'string' || !/^#?[0-9a-fA-F]{6}$/.test(color)) {
+        throw new DocsError('INVALID_STYLE', `${name} must be a hex RGB value like "1A73E8", got ${String(color)}`);
+    }
+    return color;
+}
+export function textBoxElement(doc, frame) {
+    const p = xml.builder(doc, P);
+    const a = xml.builder(doc, A);
+    const sp = p('sp');
+    const nv = xml.append(sp, p('nvSpPr'));
+    nv.appendChild(p('cNvPr', { id: frame.id, name: frame.name || `TextBox ${frame.id - 1}` }));
+    nv.appendChild(p('cNvSpPr', { txBox: 1 }));
+    nv.appendChild(p('nvPr'));
+    const spPr = xml.append(sp, p('spPr'));
+    spPr.appendChild(xfrm(doc, frame.box, A));
+    spPr.appendChild(rectangle(doc));
+    spPr.appendChild(frame.fill ? solidFill(doc, validateColor(frame.fill, 'fill')) : a('noFill'));
+    const txBody = text.ensureTextBody(sp, SHAPE_ORDER);
+    xml.child(txBody, A, 'bodyPr')?.setAttribute('wrap', 'square');
+    text.writeParagraphs(txBody, frame.text === undefined ? '' : frame.text);
+    if (frame.style) {
+        text.applyStyle(txBody, frame.style);
+    }
+    return sp;
+}
+function isCell(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        (typeof value === 'number' && Number.isFinite(value)));
+}
+export function validateRows(rows) {
+    if (!Array.isArray(rows) || rows.length === 0 || !rows.every(Array.isArray)) {
+        throw new DocsError('INVALID_TABLE', 'rows must be a non-empty array of rows, each an array of cells');
+    }
+    const out = rows.map((row, r) => row.map((value, c) => {
+        if (isCell(value))
+            return value;
+        throw new DocsError('INVALID_TABLE', `cell ${r},${c} must be a string, a number or null`);
+    }));
+    const columns = Math.max(...out.map((r) => r.length));
+    if (columns === 0) {
+        throw new DocsError('INVALID_TABLE', 'the table has no columns');
+    }
+    if (out.length > 1000 || columns > 64) {
+        throw new DocsError('INVALID_TABLE', 'a table holds at most 1000 rows and 64 columns');
+    }
+    return out;
+}
+function graphicFrame(doc, spec) {
+    const p = xml.builder(doc, P);
+    const a = xml.builder(doc, A);
+    const frame = p('graphicFrame');
+    const nv = xml.append(frame, p('nvGraphicFramePr'));
+    nv.appendChild(p('cNvPr', { id: spec.id, name: spec.name }));
+    const locks = xml.append(nv, p('cNvGraphicFramePr'));
+    if (spec.locked) {
+        locks.appendChild(a('graphicFrameLocks', { noGrp: 1 }));
+    }
+    nv.appendChild(p('nvPr'));
+    frame.appendChild(xfrm(doc, spec.box, P));
+    const data = xml.append(xml.append(frame, a('graphic')), a('graphicData', { uri: spec.uri }));
+    return { frame, data };
+}
+function tableCell(doc, value) {
+    const a = xml.builder(doc, A);
+    const tc = a('tc');
+    const txBody = xml.append(tc, a('txBody'));
+    for (const local of ['bodyPr', 'lstStyle', 'p']) {
+        txBody.appendChild(a(local));
+    }
+    text.writeParagraphs(txBody, value === null || value === undefined ? '' : String(value));
+    tc.appendChild(a('tcPr'));
+    return tc;
+}
+export function tableElement(doc, frame) {
+    const rows = validateRows(frame.rows);
+    const columns = Math.max(...rows.map((r) => r.length));
+    const a = xml.builder(doc, A);
+    const { frame: el, data } = graphicFrame(doc, {
+        id: frame.id,
+        box: frame.box,
+        name: frame.name || `Table ${frame.id - 1}`,
+        uri: TABLE_URI,
+        locked: true
+    });
+    const tbl = xml.append(data, a('tbl'));
+    const tblPr = xml.append(tbl, a('tblPr', { firstRow: frame.header === false ? undefined : 1, bandRow: 1 }));
+    xml.setText(xml.append(tblPr, a('tableStyleId')), frame.tableStyle);
+    const grid = xml.append(tbl, a('tblGrid'));
+    const width = Math.floor(frame.box.width / columns);
+    for (let c = 0; c < columns; c++) {
+        grid.appendChild(a('gridCol', { w: width }));
+    }
+    const height = Math.floor(frame.box.height / rows.length);
+    for (const row of rows) {
+        const tr = xml.append(tbl, a('tr', { h: height }));
+        for (let c = 0; c < columns; c++) {
+            tr.appendChild(tableCell(doc, row[c]));
+        }
+    }
+    return el;
+}
+export function chartFrameElement(doc, frame) {
+    const { frame: el, data } = graphicFrame(doc, {
+        id: frame.id,
+        box: frame.box,
+        name: frame.name || `Chart ${frame.id - 1}`,
+        uri: chart.GRAPHIC_URI,
+        locked: false
+    });
+    const ref = xml.append(data, xml.builder(doc, chart.C)('chart'));
+    xml.setNsAttribute(ref, { namespace: R, local: 'id' }, frame.rId);
+    return el;
+}
+export function setBackground(doc, color) {
+    const cSld = xml.child(xml.root(doc), P, 'cSld');
+    if (!cSld) {
+        throw new DocsError('BROKEN_PPTX', 'the slide has no common slide data');
+    }
+    const existing = xml.child(cSld, P, 'bg');
+    if (existing) {
+        xml.remove(existing);
+    }
+    if (color === null) {
+        return;
+    }
+    const p = xml.builder(doc, P);
+    const bg = p('bg');
+    const bgPr = xml.append(bg, p('bgPr'));
+    bgPr.appendChild(solidFill(doc, validateColor(color)));
+    bgPr.appendChild(xml.builder(doc, A)('effectLst'));
+    cSld.insertBefore(bg, cSld.firstChild);
+}

package/dist-lib/lib/office/engine/pptx/slides.d.ts

@@ -0,0 +1,27 @@
+import type { Element } from '../xml.ts';
+import type { Package } from '../opc/package.ts';
+import type { AddSlideOptions } from './types.ts';
+export interface Deck {
+    pkg: Package;
+    main: string;
+}
+export interface SlideEntry {
+    el: Element;
+    id: string;
+    rId: string;
+    part: string;
+}
+interface LayoutEntry {
+    master: string;
+    part: string;
+}
+export declare const PRESENTATION_ORDER: string[];
+export declare function slideIdList(deck: Deck): Element | null;
+export declare function ensureSlideIdList(deck: Deck): Element;
+export declare function entries(deck: Deck): SlideEntry[];
+export declare function slideAt(deck: Deck, index: unknown): SlideEntry;
+export declare function layoutOf(pkg: Package, slidePart: string): string | null;
+export declare function allLayouts(deck: Deck): LayoutEntry[];
+export declare function pickLayout(deck: Deck, opts: AddSlideOptions): string;
+export declare function placeInSection(deck: Deck, id: string): void;
+export {};

package/dist-lib/lib/office/engine/pptx/slides.js

@@ -0,0 +1,123 @@
+import * as xml from '../xml.js';
+import { DocsError } from '../errors.js';
+import { layoutName, layoutType, hasBody } from './read.js';
+const { p: P, r: R, p14: P14 } = xml.ns;
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+export const PRESENTATION_ORDER = [
+    'sldMasterIdLst',
+    'notesMasterIdLst',
+    'handoutMasterIdLst',
+    'sldIdLst',
+    'sldSz'
+];
+export function slideIdList(deck) {
+    return xml.child(deck.pkg.root(deck.main), P, 'sldIdLst');
+}
+export function ensureSlideIdList(deck) {
+    const existing = slideIdList(deck);
+    if (existing) {
+        return existing;
+    }
+    const top = deck.pkg.root(deck.main);
+    return xml.insertOrdered(top, xml.builder(xml.owner(top), P)('sldIdLst'), PRESENTATION_ORDER);
+}
+export function entries(deck) {
+    const list = slideIdList(deck);
+    if (!list) {
+        return [];
+    }
+    const rels = deck.pkg.rels(deck.main);
+    return xml.children(list, P, 'sldId').map((el) => {
+        const rId = el.getAttributeNS(R, 'id');
+        const rel = rels.get(rId);
+        if (!rel || rel.external || !rel.part || !deck.pkg.has(rel.part)) {
+            throw new DocsError('BROKEN_PPTX', `slide id ${String(el.getAttribute('id'))} points at a missing part`);
+        }
+        return { el, id: xml.attr(el, 'id'), rId: rId ?? '', part: rel.part };
+    });
+}
+export function slideAt(deck, index) {
+    const all = entries(deck);
+    const found = typeof index === 'number' && Number.isInteger(index) ? all[index] : undefined;
+    if (!found) {
+        const range = all.length ? ` (0 to ${all.length - 1})` : '';
+        throw new DocsError('SLIDE_NOT_FOUND', `slide ${String(index)} does not exist; the deck has ${all.length} slides${range}`);
+    }
+    return found;
+}
+export function layoutOf(pkg, slidePart) {
+    return pkg.related(slidePart, REL_BASE + 'slideLayout')[0] ?? null;
+}
+export function allLayouts(deck) {
+    return deck.pkg
+        .related(deck.main, REL_BASE + 'slideMaster')
+        .flatMap((master) => deck.pkg.related(master, REL_BASE + 'slideLayout').map((part) => ({ master, part })));
+}
+function layoutByName(deck, layouts, name) {
+    const wanted = name.toLowerCase();
+    const match = layouts.find(({ part }) => layoutName(deck.pkg.xml(part)).toLowerCase() === wanted);
+    if (match) {
+        return match.part;
+    }
+    const names = layouts.map(({ part }) => `"${layoutName(deck.pkg.xml(part))}"`);
+    throw new DocsError('LAYOUT_NOT_FOUND', `no layout is named "${name}"; the deck has ${names.join(', ')}`);
+}
+function defaultLayout(deck, layouts) {
+    const { pkg } = deck;
+    const used = entries(deck)
+        .map((e) => layoutOf(pkg, e.part))
+        .filter((part) => part !== null && layoutType(pkg.xml(part)) !== 'title' && hasBody(pkg.xml(part)));
+    const last = used[used.length - 1];
+    if (last) {
+        return last;
+    }
+    const content = layouts.find(({ part }) => ['obj', 'tx'].includes(layoutType(pkg.xml(part))));
+    return (content ?? layouts[0]).part;
+}
+export function pickLayout(deck, opts) {
+    if (opts.like !== undefined && opts.layout !== undefined) {
+        throw new DocsError('INVALID_OPTIONS', 'pass either like or layout, not both');
+    }
+    if (opts.like !== undefined) {
+        const layout = layoutOf(deck.pkg, slideAt(deck, opts.like).part);
+        if (!layout) {
+            throw new DocsError('BROKEN_PPTX', `slide ${opts.like} has no layout`);
+        }
+        return layout;
+    }
+    const layouts = allLayouts(deck);
+    if (layouts.length === 0) {
+        throw new DocsError('BROKEN_PPTX', 'the deck has no slide layouts');
+    }
+    if (opts.layout !== undefined) {
+        return layoutByName(deck, layouts, String(opts.layout));
+    }
+    return defaultLayout(deck, layouts);
+}
+function sectionIds(list) {
+    return xml.children(list, P14, 'sldId').map((ref) => xml.attr(ref, 'id'));
+}
+export function placeInSection(deck, id) {
+    const lists = xml.descendants(deck.pkg.root(deck.main), P14, 'sldIdLst');
+    if (lists.length === 0) {
+        return;
+    }
+    for (const list of lists) {
+        for (const ref of xml.children(list, P14, 'sldId')) {
+            if (ref.getAttribute('id') === id) {
+                xml.remove(ref);
+            }
+        }
+    }
+    const order = entries(deck).map((e) => e.id);
+    const pos = order.indexOf(id);
+    const neighbor = order[pos - 1] ?? order[pos + 1];
+    const home = lists.find((list) => sectionIds(list).includes(neighbor)) ?? lists[0];
+    home.appendChild(xml.setAttributes(xml.named(xml.owner(home), `${home.prefix || 'p14'}:sldId`, P14), { id }));
+    const sorted = xml
+        .children(home, P14, 'sldId')
+        .sort((x, y) => order.indexOf(xml.attr(x, 'id')) - order.indexOf(xml.attr(y, 'id')));
+    for (const el of sorted) {
+        home.appendChild(el);
+    }
+}

package/dist-lib/lib/office/engine/pptx/template.d.ts

@@ -0,0 +1,20 @@
+import type { Package } from '../opc/package.ts';
+export interface SlideSize {
+    width: number;
+    height: number;
+}
+export type ThemeColor = 'dark1' | 'light1' | 'dark2' | 'light2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6' | 'hyperlink' | 'followedHyperlink';
+export interface ThemeFonts {
+    heading: string;
+    body: string;
+}
+export interface CreateOptions {
+    size?: '16:9' | '4:3' | SlideSize;
+    title?: string;
+    fonts?: Partial<ThemeFonts>;
+    colors?: Partial<Record<ThemeColor, string>>;
+}
+export declare const SIZES: Record<'16:9' | '4:3', SlideSize>;
+export declare const TABLE_STYLE = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
+export declare function build(pkg: Package, opts?: unknown): void;
+export declare function notesTheme(): Uint8Array;