@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/office/engine/opc/zip.js

@@ -0,0 +1,264 @@
+import { deflateRawSync, inflateRawSync } from '#zlib';
+import { DocsError } from '../errors.js';
+import { errorCode, errorMessage } from '../../../guards.js';
+import * as utf8 from '../utf8.js';
+const EOCD = 0x06054b50;
+const EOCD64_LOCATOR = 0x07064b50;
+const EOCD64 = 0x06064b50;
+const CENTRAL = 0x02014b50;
+const LOCAL = 0x04034b50;
+const DOS_DATE = 33;
+const UTF8_FLAG = 0x0800;
+const CRC_TABLE = new Uint32Array(256).map((_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    return c >>> 0;
+});
+export function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function broken(why) {
+    return new DocsError('NOT_OOXML', `the file is not a readable zip archive: ${why}`);
+}
+function findDirectory(view) {
+    const min = Math.max(0, view.byteLength - 65557);
+    for (let at = view.byteLength - 22; at >= min; at--) {
+        if (view.getUint32(at, true) !== EOCD)
+            continue;
+        const count = view.getUint16(at + 10, true);
+        const offset = view.getUint32(at + 16, true);
+        const locator = at - 20;
+        if ((count === 0xffff || offset === 0xffffffff) &&
+            locator >= 0 &&
+            view.getUint32(locator, true) === EOCD64_LOCATOR) {
+            return zip64Directory(view, Number(view.getBigUint64(locator + 8, true)));
+        }
+        return { offset, count };
+    }
+    throw broken('no end of central directory');
+}
+function zip64Directory(view, at) {
+    if (at + 56 > view.byteLength || view.getUint32(at, true) !== EOCD64) {
+        throw broken('bad zip64 directory');
+    }
+    return {
+        count: Number(view.getBigUint64(at + 32, true)),
+        offset: Number(view.getBigUint64(at + 48, true))
+    };
+}
+function zip64Extra(view, entry, extra) {
+    for (let at = extra.start; at + 4 <= extra.end;) {
+        const id = view.getUint16(at, true);
+        const length = view.getUint16(at + 2, true);
+        if (id === 0x0001) {
+            let field = at + 4;
+            const take = () => {
+                if (field + 8 > extra.end) {
+                    throw broken(`${entry.name} has a short zip64 field`);
+                }
+                const value = Number(view.getBigUint64(field, true));
+                field += 8;
+                return value;
+            };
+            if (entry.size === 0xffffffff) {
+                entry.size = take();
+            }
+            if (entry.compressed === 0xffffffff) {
+                entry.compressed = take();
+            }
+            if (entry.offset === 0xffffffff) {
+                entry.offset = take();
+            }
+            return;
+        }
+        at += 4 + length;
+    }
+}
+function readCentral(bytes, view, at) {
+    if (at + 46 > view.byteLength || view.getUint32(at, true) !== CENTRAL) {
+        throw broken('bad central directory entry');
+    }
+    const nameLength = view.getUint16(at + 28, true);
+    const extraLength = view.getUint16(at + 30, true);
+    const commentLength = view.getUint16(at + 32, true);
+    const entry = {
+        name: utf8.decode(bytes.subarray(at + 46, at + 46 + nameLength)),
+        flags: view.getUint16(at + 8, true),
+        method: view.getUint16(at + 10, true),
+        crc: view.getUint32(at + 16, true),
+        compressed: view.getUint32(at + 20, true),
+        size: view.getUint32(at + 24, true),
+        offset: view.getUint32(at + 42, true),
+        next: at + 46 + nameLength + extraLength + commentLength
+    };
+    const start = at + 46 + nameLength;
+    zip64Extra(view, entry, { start, end: start + extraLength });
+    return entry;
+}
+function checkLimits(entries, limits) {
+    if (entries.length > limits.maxEntries) {
+        throw new DocsError('TOO_LARGE', `the file has more than ${limits.maxEntries} entries`);
+    }
+    let declared = 0;
+    for (const entry of entries) {
+        declared += entry.size;
+        if (declared > limits.maxSize) {
+            throw new DocsError('TOO_LARGE', `the file expands past ${limits.maxSize} bytes`);
+        }
+        if (entry.size > 1024 * 1024 && entry.size / Math.max(1, entry.compressed) > limits.maxRatio) {
+            throw new DocsError('TOO_LARGE', `${entry.name} expands more than ${limits.maxRatio} times, which looks like a zip bomb`);
+        }
+    }
+}
+function extract(bytes, view, entry) {
+    const at = entry.offset;
+    if (at + 30 > view.byteLength || view.getUint32(at, true) !== LOCAL) {
+        throw broken(`bad local header for ${entry.name}`);
+    }
+    if (entry.flags & 1) {
+        throw broken(`${entry.name} is encrypted`);
+    }
+    const start = at + 30 + view.getUint16(at + 26, true) + view.getUint16(at + 28, true);
+    const raw = bytes.subarray(start, start + entry.compressed);
+    if (raw.length !== entry.compressed) {
+        throw broken(`${entry.name} is truncated`);
+    }
+    let data;
+    if (entry.method === 0) {
+        data = raw;
+    }
+    else if (entry.method === 8) {
+        data = inflate(raw, entry);
+    }
+    else {
+        throw broken(`${entry.name} uses compression method ${entry.method}`);
+    }
+    if (data.length !== entry.size) {
+        throw broken(`${entry.name} has the wrong size`);
+    }
+    if (crc32(data) !== entry.crc) {
+        throw broken(`${entry.name} fails its checksum`);
+    }
+    return data;
+}
+function inflate(raw, entry) {
+    try {
+        return new Uint8Array(inflateRawSync(raw, { maxOutputLength: Math.max(1, entry.size) }));
+    }
+    catch (err) {
+        if (isOverflow(err)) {
+            throw broken(`${entry.name} inflates past its declared size`);
+        }
+        throw broken(`${entry.name} does not inflate`);
+    }
+}
+function isOverflow(err) {
+    const code = errorCode(err);
+    return code === 'ERR_BUFFER_TOO_LARGE' || code === 'LIMIT_EXCEEDED';
+}
+export function read(bytes, limits) {
+    try {
+        return readEntries(bytes, limits);
+    }
+    catch (err) {
+        if (err instanceof DocsError) {
+            throw err;
+        }
+        throw broken(errorMessage(err));
+    }
+}
+function readEntries(bytes, limits) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.byteLength < 22) {
+        throw broken('too short');
+    }
+    const directory = findDirectory(view);
+    const entries = [];
+    for (let i = 0, at = directory.offset; i < directory.count; i++) {
+        const entry = readCentral(bytes, view, at);
+        entries.push(entry);
+        at = entry.next;
+    }
+    checkLimits(entries, limits);
+    return entries
+        .filter((entry) => !entry.name.endsWith('/'))
+        .map((entry) => ({ name: entry.name, data: extract(bytes, view, entry) }));
+}
+function encodeEntry(entry) {
+    const compressed = entry.compress && entry.data.length > 0;
+    return {
+        name: utf8.encode(entry.name),
+        data: entry.data,
+        raw: compressed ? new Uint8Array(deflateRawSync(entry.data, { level: 6 })) : entry.data,
+        crc: crc32(entry.data),
+        method: compressed ? 8 : 0
+    };
+}
+function header(size, fill) {
+    const out = new Uint8Array(size);
+    fill(new DataView(out.buffer));
+    return out;
+}
+function localHeader(e) {
+    return header(30, (v) => {
+        v.setUint32(0, LOCAL, true);
+        v.setUint16(4, 20, true);
+        v.setUint16(6, UTF8_FLAG, true);
+        v.setUint16(8, e.method, true);
+        v.setUint16(12, DOS_DATE, true);
+        v.setUint32(14, e.crc, true);
+        v.setUint32(18, e.raw.length, true);
+        v.setUint32(22, e.data.length, true);
+        v.setUint16(26, e.name.length, true);
+    });
+}
+function centralHeader(e, offset) {
+    return header(46, (v) => {
+        v.setUint32(0, CENTRAL, true);
+        v.setUint16(4, 20, true);
+        v.setUint16(6, 20, true);
+        v.setUint16(8, UTF8_FLAG, true);
+        v.setUint16(10, e.method, true);
+        v.setUint16(14, DOS_DATE, true);
+        v.setUint32(16, e.crc, true);
+        v.setUint32(20, e.raw.length, true);
+        v.setUint32(24, e.data.length, true);
+        v.setUint16(28, e.name.length, true);
+        v.setUint32(42, offset, true);
+    });
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+export function write(entries) {
+    const encoded = entries.map(encodeEntry);
+    const body = [];
+    const central = [];
+    let offset = 0;
+    for (const e of encoded) {
+        central.push(centralHeader(e, offset), e.name);
+        body.push(localHeader(e), e.name, e.raw);
+        offset += 30 + e.name.length + e.raw.length;
+    }
+    const directory = concat(central);
+    const end = header(22, (v) => {
+        v.setUint32(0, EOCD, true);
+        v.setUint16(8, encoded.length, true);
+        v.setUint16(10, encoded.length, true);
+        v.setUint32(12, directory.length, true);
+        v.setUint32(16, offset, true);
+    });
+    return concat([...body, directory, end]);
+}

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

@@ -0,0 +1,12 @@
+import type { Box, Insets } from './inherit.ts';
+export interface SizedParagraph {
+    text: string;
+    level: number;
+    size: number;
+}
+export interface Estimate {
+    overflow: boolean;
+    fontScale: number;
+    lineReduction: number;
+}
+export declare function estimate(paragraphs: SizedParagraph[], box: Box, insets: Insets): Estimate;

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

@@ -0,0 +1,37 @@
+const EMU_PER_POINT = 12700;
+const LEVEL_INDENT = 342900;
+const FLOOR = { overflow: true, fontScale: 0.25, lineReduction: 0.2 };
+function paragraphHeight(p, width, squeeze) {
+    const size = p.size * squeeze.scale * EMU_PER_POINT;
+    const available = Math.max(width - p.level * LEVEL_INDENT, width * 0.3);
+    const perLine = Math.max(1, Math.floor(available / (size * 0.5)));
+    let lines = 0;
+    for (const line of p.text.split('\n')) {
+        lines += Math.max(1, Math.ceil(line.length / perLine));
+    }
+    return lines * size * 1.2 * (1 - squeeze.reduction);
+}
+function neededHeight(paragraphs, width, squeeze) {
+    return paragraphs.reduce((total, p) => total + paragraphHeight(p, width, squeeze), 0);
+}
+export function estimate(paragraphs, box, insets) {
+    const width = box.width - insets.left - insets.right;
+    const height = box.height - insets.top - insets.bottom;
+    if (width <= 0 || height <= 0) {
+        return FLOOR;
+    }
+    if (neededHeight(paragraphs, width, { scale: 1, reduction: 0 }) <= height) {
+        return { overflow: false, fontScale: 1, lineReduction: 0 };
+    }
+    for (let scale = 0.975; scale >= 0.25; scale -= 0.025) {
+        const reduction = scale < 0.7 ? 0.2 : 0.1;
+        if (neededHeight(paragraphs, width, { scale, reduction }) <= height) {
+            return {
+                overflow: true,
+                fontScale: Math.round(scale * 1000) / 1000,
+                lineReduction: reduction
+            };
+        }
+    }
+    return FLOOR;
+}

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

@@ -0,0 +1,8 @@
+import { Presentation } from './presentation.ts';
+import type { OpenOptions } from '../opc/package.ts';
+import type { CreateOptions } from './template.ts';
+export { Presentation } from './presentation.ts';
+export type * from './types.ts';
+export type { CreateOptions, SlideSize, ThemeColor, ThemeFonts } from './template.ts';
+export declare function open(bytes: Uint8Array, opts?: OpenOptions): Presentation;
+export declare function create(opts?: CreateOptions): Presentation;

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

@@ -0,0 +1,8 @@
+import { Presentation } from './presentation.js';
+export { Presentation } from './presentation.js';
+export function open(bytes, opts) {
+    return Presentation.open(bytes, opts);
+}
+export function create(opts) {
+    return Presentation.create(opts);
+}

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

@@ -0,0 +1,29 @@
+import type { Element } from '../xml.ts';
+import type { Package } from '../opc/package.ts';
+export interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Insets {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface PlaceholderKey {
+    type: string;
+    idx: string | null;
+}
+export interface ShapeInSlide {
+    pkg: Package;
+    slide: string;
+    el: Element;
+}
+export declare function placeholderOf(el: Element): PlaceholderKey | null;
+export declare function xfrmOf(el: Element): Element | null;
+export declare function explicitBox(el: Element): Box | null;
+export declare function box(shape: ShapeInSlide): Box | null;
+export declare function insets(shape: ShapeInSlide): Insets;
+export declare function fontSize(shape: ShapeInSlide, level: number): number;

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

@@ -0,0 +1,155 @@
+import * as xml from '../xml.js';
+const { a: A, p: P } = xml.ns;
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+const TITLE_TYPES = new Set(['title', 'ctrTitle']);
+const DEFAULT_INSET = 91440;
+const INSET_NAMES = {
+    left: 'lIns',
+    right: 'rIns',
+    top: 'tIns',
+    bottom: 'bIns'
+};
+const SIDES = ['left', 'right', 'top', 'bottom'];
+export function placeholderOf(el) {
+    const nv = xml.children(el)[0];
+    const nvPr = nv ? xml.child(nv, P, 'nvPr') : null;
+    const ph = nvPr ? xml.child(nvPr, P, 'ph') : null;
+    if (!ph) {
+        return null;
+    }
+    return { type: ph.getAttribute('type') || 'obj', idx: ph.getAttribute('idx') || null };
+}
+export function xfrmOf(el) {
+    if (el.localName === 'graphicFrame') {
+        return xml.child(el, P, 'xfrm');
+    }
+    const props = xml.child(el, P, el.localName === 'grpSp' ? 'grpSpPr' : 'spPr');
+    return props ? xml.child(props, A, 'xfrm') : null;
+}
+export function explicitBox(el) {
+    const xfrm = xfrmOf(el);
+    const off = xfrm ? xml.child(xfrm, A, 'off') : null;
+    const ext = xfrm ? xml.child(xfrm, A, 'ext') : null;
+    if (!off || !ext) {
+        return null;
+    }
+    return {
+        x: Number(off.getAttribute('x')),
+        y: Number(off.getAttribute('y')),
+        width: Number(ext.getAttribute('cx')),
+        height: Number(ext.getAttribute('cy'))
+    };
+}
+function spTreeShapes(doc) {
+    const tree = xml.descendants(doc, P, 'spTree')[0];
+    return tree ? xml.children(tree, P, 'sp') : [];
+}
+function matchLayout(doc, key) {
+    const shapes = spTreeShapes(doc).flatMap((el) => {
+        const ph = placeholderOf(el);
+        return ph ? [{ el, ph }] : [];
+    });
+    const byIdx = key.idx === null ? undefined : shapes.find((s) => s.ph.idx === key.idx);
+    if (byIdx) {
+        return byIdx.el;
+    }
+    return shapes.find((s) => s.ph.type === key.type)?.el ?? null;
+}
+function masterType(type) {
+    if (TITLE_TYPES.has(type))
+        return 'title';
+    if (['dt', 'ftr', 'sldNum'].includes(type))
+        return type;
+    return 'body';
+}
+function matchMaster(doc, key) {
+    const wanted = masterType(key.type);
+    const found = spTreeShapes(doc).find((el) => {
+        const ph = placeholderOf(el);
+        return ph !== null && masterType(ph.type) === wanted;
+    });
+    return found ?? null;
+}
+function layoutOf(pkg, slide) {
+    return pkg.related(slide, REL_BASE + 'slideLayout')[0];
+}
+function masterOf(pkg, layout) {
+    return pkg.related(layout, REL_BASE + 'slideMaster')[0];
+}
+function chain(shape) {
+    const { pkg, slide, el } = shape;
+    const key = placeholderOf(el);
+    const out = [el];
+    const layout = key ? layoutOf(pkg, slide) : undefined;
+    if (!key || !layout) {
+        return out;
+    }
+    const layoutShape = matchLayout(pkg.xml(layout), key);
+    if (layoutShape) {
+        out.push(layoutShape);
+    }
+    const master = masterOf(pkg, layout);
+    const masterShape = master ? matchMaster(pkg.xml(master), key) : null;
+    if (masterShape) {
+        out.push(masterShape);
+    }
+    return out;
+}
+export function box(shape) {
+    for (const node of chain(shape)) {
+        const found = explicitBox(node);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function bodyPrOf(node) {
+    const txBody = xml.child(node, P, 'txBody');
+    return txBody ? xml.child(txBody, A, 'bodyPr') : null;
+}
+export function insets(shape) {
+    const out = {
+        left: DEFAULT_INSET,
+        right: DEFAULT_INSET,
+        top: DEFAULT_INSET / 2,
+        bottom: DEFAULT_INSET / 2
+    };
+    const nodes = chain(shape);
+    for (const side of SIDES) {
+        const found = nodes.map(bodyPrOf).find((bodyPr) => bodyPr?.hasAttribute(INSET_NAMES[side]));
+        if (found) {
+            out[side] = Number(found.getAttribute(INSET_NAMES[side]));
+        }
+    }
+    return out;
+}
+function levelSize(list, level) {
+    const lvl = list ? xml.child(list, A, `lvl${level + 1}pPr`) : null;
+    const def = lvl ? xml.child(lvl, A, 'defRPr') : null;
+    return def?.hasAttribute('sz') ? Number(def.getAttribute('sz')) / 100 : null;
+}
+function styleName(key) {
+    if (!key)
+        return 'otherStyle';
+    if (masterType(key.type) === 'title')
+        return 'titleStyle';
+    return ['body', 'obj', 'subTitle'].includes(key.type) ? 'bodyStyle' : 'otherStyle';
+}
+export function fontSize(shape, level) {
+    for (const node of chain(shape)) {
+        const txBody = xml.child(node, P, 'txBody');
+        const size = levelSize(txBody ? xml.child(txBody, A, 'lstStyle') : null, level);
+        if (size) {
+            return size;
+        }
+    }
+    const layout = layoutOf(shape.pkg, shape.slide);
+    const master = layout ? masterOf(shape.pkg, layout) : undefined;
+    if (!master) {
+        return 18;
+    }
+    const styles = xml.child(shape.pkg.root(master), P, 'txStyles');
+    const size = levelSize(styles ? xml.child(styles, P, styleName(placeholderOf(shape.el))) : null, level);
+    return size || 18;
+}

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

@@ -0,0 +1,5 @@
+import type { Document, Element } from '../xml.ts';
+import type { Deck } from './slides.ts';
+export declare function notesBody(doc: Document, id: number): Element;
+export declare function writeNotes(deck: Deck, slidePart: string, value: unknown): void;
+export declare function notesText(deck: Deck, slidePart: string): string | null;

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

@@ -0,0 +1,85 @@
+import * as xml from '../xml.js';
+import * as text from '../drawingml/text.js';
+import { SHAPE_ORDER, shapesOf, nextShapeId } from './shapes.js';
+import { notesTheme } from './template.js';
+import { PRESENTATION_ORDER } from './slides.js';
+const { a: A, p: P, r: R } = xml.ns;
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+const REL = {
+    slide: REL_BASE + 'slide',
+    notesSlide: REL_BASE + 'notesSlide',
+    notesMaster: REL_BASE + 'notesMaster',
+    theme: REL_BASE + 'theme'
+};
+const NOTES_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml';
+const NOTES_MASTER_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml';
+const THEME_TYPE = 'application/vnd.openxmlformats-officedocument.theme+xml';
+const NOTES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<p:notes xmlns:a="${A}" xmlns:r="${R}" xmlns:p="${P}"><p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/><p:sp><p:nvSpPr><p:cNvPr id="2" name="Slide Image Placeholder 1"/><p:cNvSpPr><a:spLocks noGrp="1" noRot="1" noChangeAspect="1"/></p:cNvSpPr><p:nvPr><p:ph type="sldImg"/></p:nvPr></p:nvSpPr><p:spPr/></p:sp></p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:notes>`;
+const NOTES_MASTER_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<p:notesMaster xmlns:a="${A}" xmlns:r="${R}" xmlns:p="${P}"><p:cSld><p:bg><p:bgRef idx="1001"><a:schemeClr val="bg1"/></p:bgRef></p:bg><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/><p:sp><p:nvSpPr><p:cNvPr id="2" name="Slide Image Placeholder 1"/><p:cNvSpPr><a:spLocks noGrp="1" noRot="1" noChangeAspect="1"/></p:cNvSpPr><p:nvPr><p:ph type="sldImg" idx="2"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="381000" y="685800"/><a:ext cx="6096000" cy="3429000"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/><a:ln w="12700"><a:solidFill><a:prstClr val="black"/></a:solidFill></a:ln></p:spPr></p:sp><p:sp><p:nvSpPr><p:cNvPr id="3" name="Notes Placeholder 2"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="body" sz="quarter" idx="3"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="685800" y="4343400"/><a:ext cx="5486400" cy="4114800"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr vert="horz" lIns="91440" tIns="45720" rIns="91440" bIns="45720" rtlCol="0"/><a:lstStyle/><a:p><a:pPr lvl="0"/><a:r><a:rPr lang="en-US"/><a:t>Click to edit Master text styles</a:t></a:r></a:p></p:txBody></p:sp></p:spTree></p:cSld><p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/><p:notesStyle><a:lvl1pPr marL="0" algn="l" defTabSz="914400" rtl="0" eaLnBrk="1" latinLnBrk="0" hangingPunct="1"><a:defRPr sz="1200" kern="1200"><a:solidFill><a:schemeClr val="tx1"/></a:solidFill><a:latin typeface="+mn-lt"/><a:ea typeface="+mn-ea"/><a:cs typeface="+mn-cs"/></a:defRPr></a:lvl1pPr></p:notesStyle></p:notesMaster>`;
+export function notesBody(doc, id) {
+    const p = xml.builder(doc, P);
+    const sp = p('sp');
+    const nv = xml.append(sp, p('nvSpPr'));
+    nv.appendChild(p('cNvPr', { id, name: `Notes Placeholder ${id - 1}` }));
+    xml.append(nv, p('cNvSpPr')).appendChild(xml.builder(doc, A)('spLocks', { noGrp: 1 }));
+    xml.append(nv, p('nvPr')).appendChild(p('ph', { type: 'body', idx: 1 }));
+    sp.appendChild(p('spPr'));
+    text.ensureTextBody(sp, SHAPE_ORDER);
+    return sp;
+}
+function createNotesMaster(deck) {
+    const { pkg } = deck;
+    const themeSource = pkg.related(deck.main, REL.theme)[0];
+    const theme = pkg.freeName('/ppt/theme/theme%d.xml');
+    pkg.add(theme, themeSource ? pkg.bytes(themeSource) : notesTheme(), THEME_TYPE);
+    const part = pkg.freeName('/ppt/notesMasters/notesMaster%d.xml');
+    pkg.add(part, xml.parse(NOTES_MASTER_XML), NOTES_MASTER_TYPE);
+    pkg.rels(part).add(REL.theme, theme);
+    const rId = pkg.rels(deck.main).add(REL.notesMaster, part);
+    const top = pkg.root(deck.main);
+    const p = xml.builder(xml.owner(top), P);
+    const list = xml.child(top, P, 'notesMasterIdLst') ??
+        xml.insertOrdered(top, p('notesMasterIdLst'), PRESENTATION_ORDER);
+    const ref = xml.append(list, p('notesMasterId'));
+    xml.setNsAttribute(ref, { namespace: R, local: 'id' }, rId);
+    pkg.touch(deck.main);
+    return part;
+}
+function createNotes(deck, slidePart) {
+    const { pkg } = deck;
+    const master = pkg.related(deck.main, REL.notesMaster)[0] ?? createNotesMaster(deck);
+    const part = pkg.freeName('/ppt/notesSlides/notesSlide%d.xml');
+    const doc = xml.parse(NOTES_XML);
+    xml.descendants(doc, P, 'spTree')[0]?.appendChild(notesBody(doc, 3));
+    pkg.add(part, doc, NOTES_TYPE);
+    pkg.rels(part).add(REL.notesMaster, master);
+    pkg.rels(part).add(REL.slide, slidePart);
+    pkg.rels(slidePart).add(REL.notesSlide, part);
+    return part;
+}
+function bodyOf(doc) {
+    const existing = shapesOf(doc).find((s) => s.placeholder === 'body');
+    if (existing) {
+        return existing.el;
+    }
+    const el = notesBody(doc, nextShapeId(doc));
+    xml.descendants(doc, P, 'spTree')[0]?.appendChild(el);
+    return el;
+}
+export function writeNotes(deck, slidePart, value) {
+    text.normalizeParagraphs(value);
+    const notes = deck.pkg.related(slidePart, REL.notesSlide)[0] ?? createNotes(deck, slidePart);
+    const txBody = text.ensureTextBody(bodyOf(deck.pkg.xml(notes)), SHAPE_ORDER);
+    text.writeParagraphs(txBody, value);
+    deck.pkg.touch(notes);
+}
+export function notesText(deck, slidePart) {
+    const notes = deck.pkg.related(slidePart, REL.notesSlide)[0];
+    if (!notes) {
+        return null;
+    }
+    const body = shapesOf(deck.pkg.xml(notes)).find((s) => s.placeholder === 'body');
+    const txBody = body ? xml.child(body.el, P, 'txBody') : null;
+    const value = txBody ? text.readText(txBody).trim() : '';
+    return value || null;
+}

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

@@ -0,0 +1,54 @@
+import { Package, type OpenOptions } from '../opc/package.ts';
+import type { Box } from './inherit.ts';
+import type { SaveOptions } from '../opc/properties.ts';
+import type { CreateOptions, SlideSize } from './template.ts';
+import type { TextInput, Style } from '../drawingml/text.ts';
+import type { DataResult, ChartData, Changed as ChartChanged } from '../drawingml/chart.ts';
+import type { ShapeRef, CellRef, ReadOptions, SlideInfo, LayoutInfo, TextResult, FitOptions, StyleOptions, RunCount, AddSlideOptions, AddedSlide, PictureOptions, TextBoxOptions, TableOptions, ChartOptions, PlacedShape, ReplaceOptions, ReplacedPicture, MoveOptions, Moved, Deleted, Remaining, Changed } from './types.ts';
+export declare class Presentation {
+    package: Package;
+    main: string;
+    private slidesChanged;
+    private touchedSlides;
+    constructor(pkg: Package);
+    static open(bytes: Uint8Array, opts?: OpenOptions): Presentation;
+    static create(opts?: CreateOptions): Presentation;
+    get changed(): boolean;
+    get slideCount(): number;
+    get slideSize(): SlideSize;
+    layouts(): LayoutInfo[];
+    read(opts?: ReadOptions): SlideInfo[];
+    setText(target: ShapeRef, value: TextInput, opts?: FitOptions): TextResult;
+    setCellText(cell: CellRef, value: TextInput): TextResult;
+    setStyle(target: ShapeRef, style: Style, opts?: StyleOptions): RunCount;
+    format(target: ShapeRef, style: Style, opts?: StyleOptions): RunCount;
+    addSlide(opts?: AddSlideOptions): AddedSlide;
+    addPicture(slide: number, bytes: Uint8Array, opts?: PictureOptions): PlacedShape;
+    addTextBox(slide: number, opts?: TextBoxOptions): PlacedShape;
+    addTable(slide: number, opts: TableOptions): PlacedShape;
+    addChart(slide: number, spec: ChartOptions): PlacedShape;
+    setChartData(target: ShapeRef, data: ChartData): DataResult;
+    setChartTitle(target: ShapeRef, title: TextInput | null): ChartChanged;
+    setBackground(slide: number, color: string | null): Changed;
+    deleteShape(target: ShapeRef): Deleted;
+    setBox(target: ShapeRef, input: Partial<Box>): PlacedShape;
+    replacePicture(target: ShapeRef, bytes: Uint8Array, opts?: ReplaceOptions): ReplacedPicture;
+    setNotes(slide: number, value: TextInput): Changed;
+    deleteSlide(slide: number): Remaining;
+    moveSlide(slide: number, opts: MoveOptions): Moved;
+    save(opts?: SaveOptions): Uint8Array;
+    private get deck();
+    private spTree;
+    private slideInfo;
+    private shapeInfo;
+    private insertSlide;
+    private refuseLinked;
+    private touchSlide;
+    private locate;
+    private write;
+    private estimate;
+    private chartOf;
+    private chartPart;
+    private box;
+    private pictureBox;
+}