@openpresentation/opf 0.16.0 → 0.18.1

package/dist/markdown.d.ts

@@ -1,8 +1,8 @@
-import { C as Catalog } from './catalog-refs-_anZs-Qz.js';
-import { P as Presentation } from './presentation-COrFuj2g.js';
+import { a as Catalog } from './catalog-refs-BSfGELpt.js';
+import { P as Presentation } from './presentation-HondgJ3l.js';
 import { a as Finding, b as FindingLocation } from './finding-CT_f_vbD.js';
-import { V as ValidateOptions, a as ValidationReport } from './validation-types-HxIgJfKx.js';
-import './composition-D4ADF5c-.js';
+import { a as ValidateOptions, V as ValidationReport } from './validation-types-PbGDrNUr.js';
+import './composition-C-OoqvAr.js';
 import './chart-data-BnNqgnC-.js';
 import './json-BFSdESOE.js';
 
@@ -20,8 +20,12 @@ declare class OPFMarkdownError extends Error {
 }
 
 interface ParseOptions {
-    /** `rules` (default): slides are separated by `---` lines. `headings`: a `# ` heading also starts a new slide (outline input). */
-    split?: "rules" | "headings";
+    /**
+     * How the Markdown is cut into slides. `auto` (the default): by `---` lines, and an outline (no `---` line, and two or more `# `
+     * headings outside fences, comments and notes) by its headings. `rules`: by `---` lines only, so a second `# ` heading on a slide is a second title.
+     * `headings`: a `# ` heading also starts a new slide (outline input).
+     */
+    split?: "auto" | "rules" | "headings";
 }
 
 /**

package/dist/markdown.js

@@ -1,9 +1,9 @@
-export { fromMarkdown, toMarkdown } from './chunk-FQSIIADJ.js';
-export { OPFMarkdownError } from './chunk-5UEUAW57.js';
-import './chunk-NAWQR7MN.js';
-import './chunk-5TO6I3GB.js';
-import './chunk-PX5AWL7Y.js';
-import './chunk-5PDN7BN6.js';
+export { fromMarkdown, toMarkdown } from './chunk-DBYZI75U.js';
+export { OPFMarkdownError } from './chunk-CJPDTLGD.js';
+import './chunk-VCGRMNY2.js';
+import './chunk-RAKEVM52.js';
+import './chunk-JT3QXA22.js';
+import './chunk-MBU42S5Y.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-WEDGVC5W.js';
+import './chunk-6WW2EDUW.js';

package/dist/node-engine.d.ts

@@ -0,0 +1,114 @@
+export { b as DeckReport, c as DeckReportOptions, r as readDeckReport } from './deck-report-wszX7uo8.js';
+import { F as FontsHandle, E as EmbeddedFace, R as Renderer, a as Reporter, P as Peer, b as PptxModule, O as OPFApiError } from './conversion-C5foedh6.js';
+export { C as ConversionPlan, D as Diagnostic, c as EXPORT_FORMATS, d as EXPORT_TEXT, e as ExportContext, f as ExportFile, g as ExportFontSummary, h as ExportFormat, i as ExportOptions, j as ExportResult, k as ExportRun, l as ExportText, I as ImportOptions, m as ImportResult, n as OPFExportError, o as OPFImportError, p as PEER_RANGES, q as PPTX_PACKAGE, r as PreparedExport, s as RENDER_EXTRAS, t as RENDER_PACKAGE, u as ReportFinding, v as ResolvedExportOptions, S as SlideSelection, w as Source, V as VERSIONS, x as asApiError, y as checkDate, z as checkOptions, A as checkRenamedOptions, B as checkScale, G as deckFileFormat, H as exportFormatOf, J as finishReport, K as importPresentation, L as loadPptx, M as loadRenderer, N as locatePackage, Q as missingPeerFrom, T as parseSlideSelection, U as planConversion, W as prepareExport, X as reaches, Y as readInput, Z as reportThrown, _ as resolveExportOptions, $ as runExport, a0 as runPreparedExport, a1 as writePlanned } from './conversion-C5foedh6.js';
+import { a as Catalog } from './catalog-refs-BSfGELpt.js';
+import { P as PresentationPaginationResult } from './pagination-BaUjDrTz.js';
+import './presentation-HondgJ3l.js';
+import './validation-types-PbGDrNUr.js';
+import './composition-C-OoqvAr.js';
+import './chart-data-BnNqgnC-.js';
+import './finding-CT_f_vbD.js';
+import './json-BFSdESOE.js';
+
+/** `deck.opf.json` and `deck.pptx` both give `deck`; stdin gives `deck`. */
+declare function stemOf(input: string): string;
+/**
+ * The base name of render and export output files: the deck's `filename` (a trailing .pptx, .pdf, .png or .svg is dropped, any
+ * case), else the slugified `name`, else the input file's stem. The same rule opf-editor names its downloads by. Characters a file
+ * system rejects are replaced, so the name is safe to write.
+ */
+declare function deckStem(deck: unknown, input: string): string;
+interface PlannedFile {
+    file: string;
+    bytes: Uint8Array;
+}
+/**
+ * Fail before writing anything when a destination exists (the commands without --force; `convert` with `overwrite: false`), is a symlink or is
+ * not a regular file: `output-exists` and `output-not-file`, which the commands report at exit 1. `flags` false words the
+ * message for the library API.
+ */
+declare function checkDestinations(files: string[], overwrite: boolean, flags?: boolean): Promise<void>;
+/** Write each file through a temporary sibling and a rename, so no partial output is ever published under its final name. */
+declare function writeFiles(files: PlannedFile[], overwrite: boolean, flags?: boolean): Promise<void>;
+declare function pointerOf(location: string): string;
+
+interface PreparedFonts {
+    /** The fonts handle of opf-render `loadFonts()`: passed as `{ fonts }` to every deck-level call. */
+    handle: FontsHandle;
+    /** Absolute paths of the --fonts files, in load order. */
+    userFonts: string[];
+}
+/** Font files directly inside each directory (no recursion), sorted by name so the load order is the same everywhere. */
+declare function listFontDirectories(directories: string[], label?: string): Promise<string[]>;
+/**
+ * The office pack (Carlito, Intos, the open families font schemes select and the open replacements the font policy
+ * routes to, with lazy faces loaded on demand), visual substitution, and Noto script packages for the scripts the
+ * deck's text draws when they are installed. `faces` are the --fonts files, loaded first.
+ */
+declare function prepareFonts(renderer: Renderer, presentation: unknown, userFonts: string[], reporter: Reporter, embedScriptFonts?: boolean): Promise<PreparedFonts>;
+/** A fonts handle lent to one export. `release` returns it; until then no other export uses the shared handle. */
+interface FontsLease {
+    handle: FontsHandle;
+    release(): void;
+}
+/**
+ * The default fonts handle of this process, prepared once (the office pack plus `userFonts`, keyed by that file list and
+ * `embedScriptFonts`) and lent to one export at a time, so the substitutions it records are the export's own. It is lent
+ * only for a deck that draws no script beyond Latin, Greek and Cyrillic and needs no glyph-fallback face: for such a deck
+ * a handle prepared for it and the shared one hold the same faces, so the bytes are the same. Any other deck, or a
+ * renderer without `autoScriptSelection`, gets undefined and the caller prepares a handle of its own (`prepareFonts`).
+ */
+declare function leaseSharedFonts(renderer: Renderer, presentation: unknown, userFonts: string[], reporter: Reporter, embedScriptFonts?: boolean): Promise<FontsLease | undefined>;
+/**
+ * Faces an SVG should carry for `text`. `"fonts"` (the default) marks every face `embed: "used"`, so the renderer embeds a face only
+ * when the slide's text names its family and a slide in one family ships kilobytes of font rather than the whole pack. `"system"`
+ * embeds none, and `"paths"` draws the text as outlines from the fonts handle itself, so it has no faces to list.
+ */
+declare function embeddedFor(handle: FontsHandle, text?: "fonts" | "system" | "paths"): (EmbeddedFace & {
+    embed?: "used";
+})[];
+
+interface ImportRun {
+    /** The imported presentation, undefined when `fromPptx` threw (the reporter then holds the error finding). */
+    presentation?: Record<string, unknown>;
+    /** With `signals`: the raw per-shape layout and style signals of the file. */
+    signals?: {
+        version?: number;
+    };
+    failure?: {
+        code: string;
+        message: string;
+    };
+    pptx: Peer<PptxModule>;
+}
+/** Read a PowerPoint file. Diagnostics (and the error finding of a failure) are added to `reporter`. Throws an `OPFApiError` when opf-pptx is missing or too old. */
+declare function runImport(bytes: Uint8Array, options: {
+    signals?: boolean;
+}, reporter: Reporter, loaded?: Peer<PptxModule>): Promise<ImportRun>;
+
+declare function createZip(entries: {
+    name: string;
+    bytes: Uint8Array;
+}[]): Uint8Array;
+
+interface PaginateDeckOptions {
+    /** Folders of `.ttf` and `.otf` files, loaded before the bundled pack (as `--fonts`). They need opf-render. */
+    fontFolders?: readonly string[];
+    catalogs?: readonly Catalog[];
+    /** Receives the font diagnostics. */
+    reporter: Reporter;
+    /** Name options as the command's flags in messages. */
+    flags?: boolean;
+}
+interface PaginatedDeck {
+    result: PresentationPaginationResult;
+    /** Why the layout is estimated: the missing or too old peer (`peer-not-installed`, `peer-too-old`) that measuring needs. */
+    estimated?: OPFApiError;
+}
+/**
+ * Paginate with measured text when opf-render and its fonts load, else with core's estimate (and `estimated` saying why). With
+ * `fontFolders` the fonts are required, so a missing renderer throws. Throws `OPFPaginationError` when content cannot fit.
+ */
+declare function paginateDeck(deck: unknown, options: PaginateDeckOptions): Promise<PaginatedDeck>;
+
+export { FontsHandle, type ImportRun, OPFApiError, type PaginateDeckOptions, type PaginatedDeck, Peer, type PlannedFile, PptxModule, Renderer, Reporter, checkDestinations, createZip, deckStem, embeddedFor, leaseSharedFonts, listFontDirectories, paginateDeck, pointerOf, prepareFonts, runImport, stemOf, writeFiles };

package/dist/node-engine.js

@@ -0,0 +1,44 @@
+import { DEFAULT_CATALOGS, loadRenderer, listFontDirectories, leaseSharedFonts, prepareFonts } from './chunk-KXBZ6ZSB.js';
+export { EXPORT_FORMATS, EXPORT_TEXT, PEER_RANGES, PPTX_PACKAGE, RENDER_EXTRAS, RENDER_PACKAGE, Reporter, VERSIONS, checkDate, checkDestinations, checkOptions, checkRenamedOptions, checkScale, createZip, deckFileFormat, deckStem, embeddedFor, exportFormatOf, finishReport, importPresentation, leaseSharedFonts, listFontDirectories, loadPptx, loadRenderer, locatePackage, missingPeerFrom, planConversion, pointerOf, prepareExport, prepareFonts, reaches, readInput, reportThrown, resolveExportOptions, runExport, runImport, runPreparedExport, stemOf, writeFiles, writePlanned } from './chunk-KXBZ6ZSB.js';
+import { OPFApiError } from './chunk-QLFWWHRF.js';
+export { OPFApiError, OPFExportError, OPFImportError, asApiError, parseSlideSelection } from './chunk-QLFWWHRF.js';
+import './chunk-HXHOZ7AH.js';
+import './chunk-ZCFSDSUX.js';
+import './chunk-WCG3THTD.js';
+export { readDeckReport } from './chunk-ZOHFLP3O.js';
+import './chunk-DBYZI75U.js';
+import './chunk-NS3VYB57.js';
+import './chunk-CJPDTLGD.js';
+import './chunk-YWXB4XAT.js';
+import './chunk-YZXTXX2D.js';
+import './chunk-JXVS7BJK.js';
+import { paginate } from './chunk-64YSJZDH.js';
+import './chunk-VCGRMNY2.js';
+import './chunk-RAKEVM52.js';
+import './chunk-JT3QXA22.js';
+import './chunk-MBU42S5Y.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-6WW2EDUW.js';
+import './chunk-WXSPETQ6.js';
+
+// src/node/paginate.ts
+async function paginateDeck(deck, options) {
+  const catalogs = options.catalogs ?? DEFAULT_CATALOGS;
+  const folders = options.fontFolders ?? [];
+  let lease;
+  try {
+    const renderer = await loadRenderer();
+    const userFonts = await listFontDirectories([...folders], options.flags ? "--fonts" : "fonts");
+    lease = await leaseSharedFonts(renderer, deck, userFonts, options.reporter);
+    const handle = lease?.handle ?? (await prepareFonts(renderer, deck, userFonts, options.reporter)).handle;
+    return { result: paginate(deck, { fonts: handle, catalogs }) };
+  } catch (error) {
+    if (error instanceof OPFApiError && (error.code === "peer-not-installed" || error.code === "peer-too-old") && !folders.length) return { result: paginate(deck, { catalogs }), estimated: error };
+    throw error;
+  } finally {
+    lease?.release();
+  }
+}
+
+export { paginateDeck };

package/dist/{pagination-DzZPFheM.d.ts → pagination-BaUjDrTz.d.ts}

@@ -1,5 +1,5 @@
-import { C as ComposeSlideOptions, F as Fonts, L as LayoutDiagnostic } from './composition-D4ADF5c-.js';
-import { U as UnresolvedReferenceDiagnostic, R as RecordProvenance, b as CatalogOptions } from './catalog-refs-_anZs-Qz.js';
+import { C as ComposeSlideOptions, F as Fonts, L as LayoutDiagnostic } from './composition-C-OoqvAr.js';
+import { U as UnresolvedReferenceDiagnostic, R as RecordProvenance, b as CatalogOptions, a as Catalog } from './catalog-refs-BSfGELpt.js';
 
 /**
  * One slide's composition context: the layout, canvas, theme and font families that `composeSlide` needs,
@@ -15,7 +15,7 @@ interface SlideContextOptions extends CatalogOptions {
     fonts?: Fonts;
     /** One-based displayed slide number. Default: index + 1. */
     slideNumber?: number;
-    /** Displayed slide count for `{total}`. Default: the deck's slide count. */
+    /** Displayed slide count for `{{deck.slideCount}}`. Default: the deck's slide count. */
     slideCount?: number;
     /** Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` header/footer fields. */
     date?: string;
@@ -23,6 +23,14 @@ interface SlideContextOptions extends CatalogOptions {
     strictReferences?: boolean;
 }
 interface SlideContext {
+    /**
+     * The slide to compose and draw: slide `index` with `{{slide.number}}`, `{{slide.section}}` and
+     * `{{deck.slideCount}}` substituted (`resolveSlideVariables`) for `options.slideNumber` and `options.slideCount`, and its
+     * logo references (`var:organization.logo.icon` in an image field) resolved for `options.darkBackground`.
+     * Its own header and footer text keeps the tokens: `layoutFurniture` substitutes them and marks each slide number
+     * as a live field. The source slide object itself when it carries no slide-scoped token.
+     */
+    slide: Rec;
     /** Ready for `composeSlide(slide, options)`. */
     options: ComposeSlideOptions;
     diagnostics: SlideContextDiagnostic[];
@@ -49,16 +57,23 @@ interface SlideContext {
     };
 }
 /**
- * Resolve slide `index` of `presentation` into the options `composeSlide` takes. Never throws for an unresolved
- * reference unless `strictReferences` is set: the engine default (or automatic composition, for a layout) applies and
- * `diagnostics` holds one `unresolved-reference` per reference. Throws a RangeError for an index outside the deck or
+ * Resolve slide `index` of `presentation` into the slide and the options `composeSlide` takes: engines compose and draw
+ * `composeSlide(context.slide, context.options)`, so the slide-scoped built-ins carry the same number and count as the
+ * header and footer. Never throws for an unresolved reference unless `strictReferences` is set: the engine default (or
+ * automatic composition, for a layout) applies and `diagnostics` holds one `unresolved-reference` per reference. Throws a RangeError for an index outside the deck or
  * non-positive canvas dimensions, which a schema-valid deck cannot have.
  */
 declare function resolveSlideContext(presentation: unknown, index: number, options?: SlideContextOptions): SlideContext;
 
 interface PaginationOptions extends Omit<ComposeSlideOptions, 'textMeasurement'> {
-    /** The fonts handle: page breaks are chosen with its `textMeasurement`. Without it core uses its portable estimate. */
+    /**
+     * The fonts handle: page breaks are chosen with its `textMeasurement`. Without it core uses its portable estimate. With
+     * `presentation`, a measurement that plans scripts (`forScripts`) measures each script run in the slide's script fonts,
+     * as the engines do.
+     */
     fonts?: Fonts;
+    /** Registered catalogs, for resolving the slide's script fonts when `presentation` is given. `paginate` passes its own. */
+    catalogs?: readonly Catalog[];
     /** Readability floor used while choosing page breaks. Default 24 reference pixels. */
     minFontSize?: number;
     /** All-or-nothing resource limit. Defaults to 100 output slides. */
@@ -112,8 +127,10 @@ interface PresentationPaginationResult {
     pages: (PaginatedPage & {
         sourceSlideIndex: number;
     })[];
+    /** How the page breaks were chosen: `measured` with the `fonts` handle's text measurement, `estimated` with core's portable estimate (no `fonts`). */
+    layout: 'measured' | 'estimated';
 }
 /** Resolve the slides' references (the document's catalogs groups, then the registered catalogs) and paginate a complete presentation without mutating it. */
 declare function paginate(input: unknown, options?: PresentationPaginationOptions): PresentationPaginationResult;
 
-export { OPFPaginationError as O, type PaginatedPage as P, type SlideContext as S, type PaginationMapping as a, type PaginationOptions as b, type PaginationResult as c, type PresentationPaginationOptions as d, type PresentationPaginationResult as e, type SlideContextDiagnostic as f, type SlideContextOptions as g, paginateSlide as h, paginate as p, resolveSlideContext as r };
+export { OPFPaginationError as O, type PresentationPaginationResult as P, type SlideContext as S, type PaginatedPage as a, type PresentationPaginationOptions as b, type PaginationMapping as c, type PaginationOptions as d, type PaginationResult as e, type SlideContextDiagnostic as f, type SlideContextOptions as g, paginateSlide as h, paginate as p, resolveSlideContext as r };

package/dist/pagination.d.ts

@@ -1,4 +1,4 @@
-import './composition-D4ADF5c-.js';
-import './catalog-refs-_anZs-Qz.js';
-export { O as OPFPaginationError, P as PaginatedPage, a as PaginationMapping, b as PaginationOptions, c as PaginationResult, d as PresentationPaginationOptions, e as PresentationPaginationResult, p as paginate, h as paginateSlide } from './pagination-DzZPFheM.js';
+import './composition-C-OoqvAr.js';
+import './catalog-refs-BSfGELpt.js';
+export { O as OPFPaginationError, a as PaginatedPage, c as PaginationMapping, d as PaginationOptions, e as PaginationResult, b as PresentationPaginationOptions, P as PresentationPaginationResult, p as paginate, h as paginateSlide } from './pagination-BaUjDrTz.js';
 import './chart-data-BnNqgnC-.js';

package/dist/pagination.js

@@ -1,6 +1,6 @@
-export { OPFPaginationError, paginate, paginateSlide } from './chunk-BSYQDWT4.js';
-import './chunk-PX5AWL7Y.js';
-import './chunk-5PDN7BN6.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-64YSJZDH.js';
+import './chunk-JT3QXA22.js';
+import './chunk-MBU42S5Y.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-WEDGVC5W.js';
+import './chunk-6WW2EDUW.js';

package/dist/patch.js

@@ -1,6 +1,6 @@
-export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-3XDRQYWZ.js';
-import './chunk-PX5AWL7Y.js';
-import './chunk-5PDN7BN6.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-YZXTXX2D.js';
+import './chunk-JT3QXA22.js';
+import './chunk-MBU42S5Y.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-WEDGVC5W.js';
+import './chunk-6WW2EDUW.js';